1
2
3
4
5
6
7
8
9
10
11
12
13
14#define _GNU_SOURCE
15#include <stdio.h>
16#include <ctype.h>
17#include <string.h>
18#include "modpost.h"
19#include "../../include/generated/autoconf.h"
20#include "../../include/linux/license.h"
21
22
23#ifdef CONFIG_SYMBOL_PREFIX
24#define MODULE_SYMBOL_PREFIX CONFIG_SYMBOL_PREFIX
25#else
26#define MODULE_SYMBOL_PREFIX ""
27#endif
28
29
30
31int modversions = 0;
32
33int have_vmlinux = 0;
34
35static int all_versions = 0;
36
37static int external_module = 0;
38
39static int vmlinux_section_warnings = 1;
40
41static int warn_unresolved = 0;
42
43static int sec_mismatch_count = 0;
44static int sec_mismatch_verbose = 1;
45
46enum export {
47 export_plain, export_unused, export_gpl,
48 export_unused_gpl, export_gpl_future, export_unknown
49};
50
51#define PRINTF __attribute__ ((format (printf, 1, 2)))
52
53PRINTF void fatal(const char *fmt, ...)
54{
55 va_list arglist;
56
57 fprintf(stderr, "FATAL: ");
58
59 va_start(arglist, fmt);
60 vfprintf(stderr, fmt, arglist);
61 va_end(arglist);
62
63 exit(1);
64}
65
66PRINTF void warn(const char *fmt, ...)
67{
68 va_list arglist;
69
70 fprintf(stderr, "WARNING: ");
71
72 va_start(arglist, fmt);
73 vfprintf(stderr, fmt, arglist);
74 va_end(arglist);
75}
76
77PRINTF void merror(const char *fmt, ...)
78{
79 va_list arglist;
80
81 fprintf(stderr, "ERROR: ");
82
83 va_start(arglist, fmt);
84 vfprintf(stderr, fmt, arglist);
85 va_end(arglist);
86}
87
88static int is_vmlinux(const char *modname)
89{
90 const char *myname;
91
92 myname = strrchr(modname, '/');
93 if (myname)
94 myname++;
95 else
96 myname = modname;
97
98 return (strcmp(myname, "vmlinux") == 0) ||
99 (strcmp(myname, "vmlinux.o") == 0);
100}
101
102void *do_nofail(void *ptr, const char *expr)
103{
104 if (!ptr)
105 fatal("modpost: Memory allocation failure: %s.\n", expr);
106
107 return ptr;
108}
109
110
111static struct module *modules;
112
113static struct module *find_module(char *modname)
114{
115 struct module *mod;
116
117 for (mod = modules; mod; mod = mod->next)
118 if (strcmp(mod->name, modname) == 0)
119 break;
120 return mod;
121}
122
123static struct module *new_module(char *modname)
124{
125 struct module *mod;
126 char *p, *s;
127
128 mod = NOFAIL(malloc(sizeof(*mod)));
129 memset(mod, 0, sizeof(*mod));
130 p = NOFAIL(strdup(modname));
131
132
133 s = strrchr(p, '.');
134 if (s != NULL)
135 if (strcmp(s, ".o") == 0)
136 *s = '\0';
137
138
139 mod->name = p;
140 mod->gpl_compatible = -1;
141 mod->next = modules;
142 modules = mod;
143
144 return mod;
145}
146
147
148
149
150#define SYMBOL_HASH_SIZE 1024
151
152struct symbol {
153 struct symbol *next;
154 struct module *module;
155 unsigned int crc;
156 int crc_valid;
157 unsigned int weak:1;
158 unsigned int vmlinux:1;
159 unsigned int kernel:1;
160
161 unsigned int preloaded:1;
162 enum export export;
163 char name[0];
164};
165
166static struct symbol *symbolhash[SYMBOL_HASH_SIZE];
167
168
169static inline unsigned int tdb_hash(const char *name)
170{
171 unsigned value;
172 unsigned i;
173
174
175 for (value = 0x238F13AF * strlen(name), i = 0; name[i]; i++)
176 value = (value + (((unsigned char *)name)[i] << (i*5 % 24)));
177
178 return (1103515243 * value + 12345);
179}
180
181
182
183
184
185static struct symbol *alloc_symbol(const char *name, unsigned int weak,
186 struct symbol *next)
187{
188 struct symbol *s = NOFAIL(malloc(sizeof(*s) + strlen(name) + 1));
189
190 memset(s, 0, sizeof(*s));
191 strcpy(s->name, name);
192 s->weak = weak;
193 s->next = next;
194 return s;
195}
196
197
198static struct symbol *new_symbol(const char *name, struct module *module,
199 enum export export)
200{
201 unsigned int hash;
202 struct symbol *new;
203
204 hash = tdb_hash(name) % SYMBOL_HASH_SIZE;
205 new = symbolhash[hash] = alloc_symbol(name, 0, symbolhash[hash]);
206 new->module = module;
207 new->export = export;
208 return new;
209}
210
211static struct symbol *find_symbol(const char *name)
212{
213 struct symbol *s;
214
215
216 if (name[0] == '.')
217 name++;
218
219 for (s = symbolhash[tdb_hash(name) % SYMBOL_HASH_SIZE]; s; s = s->next) {
220 if (strcmp(s->name, name) == 0)
221 return s;
222 }
223 return NULL;
224}
225
226static struct {
227 const char *str;
228 enum export export;
229} export_list[] = {
230 { .str = "EXPORT_SYMBOL", .export = export_plain },
231 { .str = "EXPORT_UNUSED_SYMBOL", .export = export_unused },
232 { .str = "EXPORT_SYMBOL_GPL", .export = export_gpl },
233 { .str = "EXPORT_UNUSED_SYMBOL_GPL", .export = export_unused_gpl },
234 { .str = "EXPORT_SYMBOL_GPL_FUTURE", .export = export_gpl_future },
235 { .str = "(unknown)", .export = export_unknown },
236};
237
238
239static const char *export_str(enum export ex)
240{
241 return export_list[ex].str;
242}
243
244static enum export export_no(const char *s)
245{
246 int i;
247
248 if (!s)
249 return export_unknown;
250 for (i = 0; export_list[i].export != export_unknown; i++) {
251 if (strcmp(export_list[i].str, s) == 0)
252 return export_list[i].export;
253 }
254 return export_unknown;
255}
256
257static enum export export_from_sec(struct elf_info *elf, unsigned int sec)
258{
259 if (sec == elf->export_sec)
260 return export_plain;
261 else if (sec == elf->export_unused_sec)
262 return export_unused;
263 else if (sec == elf->export_gpl_sec)
264 return export_gpl;
265 else if (sec == elf->export_unused_gpl_sec)
266 return export_unused_gpl;
267 else if (sec == elf->export_gpl_future_sec)
268 return export_gpl_future;
269 else
270 return export_unknown;
271}
272
273
274
275
276
277static struct symbol *sym_add_exported(const char *name, struct module *mod,
278 enum export export)
279{
280 struct symbol *s = find_symbol(name);
281
282 if (!s) {
283 s = new_symbol(name, mod, export);
284 } else {
285 if (!s->preloaded) {
286 warn("%s: '%s' exported twice. Previous export "
287 "was in %s%s\n", mod->name, name,
288 s->module->name,
289 is_vmlinux(s->module->name) ?"":".ko");
290 } else {
291
292 s->module = mod;
293 }
294 }
295 s->preloaded = 0;
296 s->vmlinux = is_vmlinux(mod->name);
297 s->kernel = 0;
298 s->export = export;
299 return s;
300}
301
302static void sym_update_crc(const char *name, struct module *mod,
303 unsigned int crc, enum export export)
304{
305 struct symbol *s = find_symbol(name);
306
307 if (!s)
308 s = new_symbol(name, mod, export);
309 s->crc = crc;
310 s->crc_valid = 1;
311}
312
313void *grab_file(const char *filename, unsigned long *size)
314{
315 struct stat st;
316 void *map;
317 int fd;
318
319 fd = open(filename, O_RDONLY);
320 if (fd < 0 || fstat(fd, &st) != 0)
321 return NULL;
322
323 *size = st.st_size;
324 map = mmap(NULL, *size, PROT_READ|PROT_WRITE, MAP_PRIVATE, fd, 0);
325 close(fd);
326
327 if (map == MAP_FAILED)
328 return NULL;
329 return map;
330}
331
332
333
334
335
336
337char *get_next_line(unsigned long *pos, void *file, unsigned long size)
338{
339 static char line[4096];
340 int skip = 1;
341 size_t len = 0;
342 signed char *p = (signed char *)file + *pos;
343 char *s = line;
344
345 for (; *pos < size ; (*pos)++) {
346 if (skip && isspace(*p)) {
347 p++;
348 continue;
349 }
350 skip = 0;
351 if (*p != '\n' && (*pos < size)) {
352 len++;
353 *s++ = *p++;
354 if (len > 4095)
355 break;
356 } else {
357
358 *s = '\0';
359 return line;
360 }
361 }
362
363 return NULL;
364}
365
366void release_file(void *file, unsigned long size)
367{
368 munmap(file, size);
369}
370
371static int parse_elf(struct elf_info *info, const char *filename)
372{
373 unsigned int i;
374 Elf_Ehdr *hdr;
375 Elf_Shdr *sechdrs;
376 Elf_Sym *sym;
377 const char *secstrings;
378 unsigned int symtab_idx = ~0U, symtab_shndx_idx = ~0U;
379
380 hdr = grab_file(filename, &info->size);
381 if (!hdr) {
382 perror(filename);
383 exit(1);
384 }
385 info->hdr = hdr;
386 if (info->size < sizeof(*hdr)) {
387
388 return 0;
389 }
390
391 if ((hdr->e_ident[EI_MAG0] != ELFMAG0) ||
392 (hdr->e_ident[EI_MAG1] != ELFMAG1) ||
393 (hdr->e_ident[EI_MAG2] != ELFMAG2) ||
394 (hdr->e_ident[EI_MAG3] != ELFMAG3)) {
395
396 return 0;
397 }
398
399 hdr->e_type = TO_NATIVE(hdr->e_type);
400 hdr->e_machine = TO_NATIVE(hdr->e_machine);
401 hdr->e_version = TO_NATIVE(hdr->e_version);
402 hdr->e_entry = TO_NATIVE(hdr->e_entry);
403 hdr->e_phoff = TO_NATIVE(hdr->e_phoff);
404 hdr->e_shoff = TO_NATIVE(hdr->e_shoff);
405 hdr->e_flags = TO_NATIVE(hdr->e_flags);
406 hdr->e_ehsize = TO_NATIVE(hdr->e_ehsize);
407 hdr->e_phentsize = TO_NATIVE(hdr->e_phentsize);
408 hdr->e_phnum = TO_NATIVE(hdr->e_phnum);
409 hdr->e_shentsize = TO_NATIVE(hdr->e_shentsize);
410 hdr->e_shnum = TO_NATIVE(hdr->e_shnum);
411 hdr->e_shstrndx = TO_NATIVE(hdr->e_shstrndx);
412 sechdrs = (void *)hdr + hdr->e_shoff;
413 info->sechdrs = sechdrs;
414
415
416 if (hdr->e_shoff > info->size) {
417 fatal("section header offset=%lu in file '%s' is bigger than "
418 "filesize=%lu\n", (unsigned long)hdr->e_shoff,
419 filename, info->size);
420 return 0;
421 }
422
423 if (hdr->e_shnum == 0) {
424
425
426
427
428
429 info->num_sections = TO_NATIVE(sechdrs[0].sh_size);
430 }
431 else {
432 info->num_sections = hdr->e_shnum;
433 }
434 if (hdr->e_shstrndx == SHN_XINDEX) {
435 info->secindex_strings =
436 shndx2secindex(TO_NATIVE(sechdrs[0].sh_link));
437 }
438 else {
439 info->secindex_strings = hdr->e_shstrndx;
440 }
441
442
443 for (i = 0; i < info->num_sections; i++) {
444 sechdrs[i].sh_name = TO_NATIVE(sechdrs[i].sh_name);
445 sechdrs[i].sh_type = TO_NATIVE(sechdrs[i].sh_type);
446 sechdrs[i].sh_flags = TO_NATIVE(sechdrs[i].sh_flags);
447 sechdrs[i].sh_addr = TO_NATIVE(sechdrs[i].sh_addr);
448 sechdrs[i].sh_offset = TO_NATIVE(sechdrs[i].sh_offset);
449 sechdrs[i].sh_size = TO_NATIVE(sechdrs[i].sh_size);
450 sechdrs[i].sh_link = TO_NATIVE(sechdrs[i].sh_link);
451 sechdrs[i].sh_info = TO_NATIVE(sechdrs[i].sh_info);
452 sechdrs[i].sh_addralign = TO_NATIVE(sechdrs[i].sh_addralign);
453 sechdrs[i].sh_entsize = TO_NATIVE(sechdrs[i].sh_entsize);
454 }
455
456 secstrings = (void *)hdr + sechdrs[info->secindex_strings].sh_offset;
457 for (i = 1; i < info->num_sections; i++) {
458 const char *secname;
459 int nobits = sechdrs[i].sh_type == SHT_NOBITS;
460
461 if (!nobits && sechdrs[i].sh_offset > info->size) {
462 fatal("%s is truncated. sechdrs[i].sh_offset=%lu > "
463 "sizeof(*hrd)=%zu\n", filename,
464 (unsigned long)sechdrs[i].sh_offset,
465 sizeof(*hdr));
466 return 0;
467 }
468 secname = secstrings + sechdrs[i].sh_name;
469 if (strcmp(secname, ".modinfo") == 0) {
470 if (nobits)
471 fatal("%s has NOBITS .modinfo\n", filename);
472 info->modinfo = (void *)hdr + sechdrs[i].sh_offset;
473 info->modinfo_len = sechdrs[i].sh_size;
474 } else if (strcmp(secname, "__ksymtab") == 0)
475 info->export_sec = i;
476 else if (strcmp(secname, "__ksymtab_unused") == 0)
477 info->export_unused_sec = i;
478 else if (strcmp(secname, "__ksymtab_gpl") == 0)
479 info->export_gpl_sec = i;
480 else if (strcmp(secname, "__ksymtab_unused_gpl") == 0)
481 info->export_unused_gpl_sec = i;
482 else if (strcmp(secname, "__ksymtab_gpl_future") == 0)
483 info->export_gpl_future_sec = i;
484
485 if (sechdrs[i].sh_type == SHT_SYMTAB) {
486 unsigned int sh_link_idx;
487 symtab_idx = i;
488 info->symtab_start = (void *)hdr +
489 sechdrs[i].sh_offset;
490 info->symtab_stop = (void *)hdr +
491 sechdrs[i].sh_offset + sechdrs[i].sh_size;
492 sh_link_idx = shndx2secindex(sechdrs[i].sh_link);
493 info->strtab = (void *)hdr +
494 sechdrs[sh_link_idx].sh_offset;
495 }
496
497
498 if (sechdrs[i].sh_type == SHT_SYMTAB_SHNDX) {
499 symtab_shndx_idx = i;
500 info->symtab_shndx_start = (void *)hdr +
501 sechdrs[i].sh_offset;
502 info->symtab_shndx_stop = (void *)hdr +
503 sechdrs[i].sh_offset + sechdrs[i].sh_size;
504 }
505 }
506 if (!info->symtab_start)
507 fatal("%s has no symtab?\n", filename);
508
509
510 for (sym = info->symtab_start; sym < info->symtab_stop; sym++) {
511 sym->st_shndx = TO_NATIVE(sym->st_shndx);
512 sym->st_name = TO_NATIVE(sym->st_name);
513 sym->st_value = TO_NATIVE(sym->st_value);
514 sym->st_size = TO_NATIVE(sym->st_size);
515 }
516
517 if (symtab_shndx_idx != ~0U) {
518 Elf32_Word *p;
519 if (symtab_idx !=
520 shndx2secindex(sechdrs[symtab_shndx_idx].sh_link))
521 fatal("%s: SYMTAB_SHNDX has bad sh_link: %u!=%u\n",
522 filename,
523 shndx2secindex(sechdrs[symtab_shndx_idx].sh_link),
524 symtab_idx);
525
526 for (p = info->symtab_shndx_start; p < info->symtab_shndx_stop;
527 p++)
528 *p = TO_NATIVE(*p);
529 }
530
531 return 1;
532}
533
534static void parse_elf_finish(struct elf_info *info)
535{
536 release_file(info->hdr, info->size);
537}
538
539static int ignore_undef_symbol(struct elf_info *info, const char *symname)
540{
541
542 if (strcmp(symname, MODULE_SYMBOL_PREFIX "__this_module") == 0)
543 return 1;
544
545 if (strcmp(symname, "_GLOBAL_OFFSET_TABLE_") == 0)
546 return 1;
547 if (info->hdr->e_machine == EM_PPC)
548
549 if (strncmp(symname, "_restgpr_", sizeof("_restgpr_") - 1) == 0 ||
550 strncmp(symname, "_savegpr_", sizeof("_savegpr_") - 1) == 0 ||
551 strncmp(symname, "_rest32gpr_", sizeof("_rest32gpr_") - 1) == 0 ||
552 strncmp(symname, "_save32gpr_", sizeof("_save32gpr_") - 1) == 0)
553 return 1;
554 if (info->hdr->e_machine == EM_PPC64)
555
556 if (strncmp(symname, "_restgpr0_", sizeof("_restgpr0_") - 1) == 0 ||
557 strncmp(symname, "_savegpr0_", sizeof("_savegpr0_") - 1) == 0)
558 return 1;
559
560 return 0;
561}
562
563#define CRC_PFX MODULE_SYMBOL_PREFIX "__crc_"
564#define KSYMTAB_PFX MODULE_SYMBOL_PREFIX "__ksymtab_"
565
566static void handle_modversions(struct module *mod, struct elf_info *info,
567 Elf_Sym *sym, const char *symname)
568{
569 unsigned int crc;
570 enum export export = export_from_sec(info, get_secindex(info, sym));
571
572 switch (sym->st_shndx) {
573 case SHN_COMMON:
574 warn("\"%s\" [%s] is COMMON symbol\n", symname, mod->name);
575 break;
576 case SHN_ABS:
577
578 if (strncmp(symname, CRC_PFX, strlen(CRC_PFX)) == 0) {
579 crc = (unsigned int) sym->st_value;
580 sym_update_crc(symname + strlen(CRC_PFX), mod, crc,
581 export);
582 }
583 break;
584 case SHN_UNDEF:
585
586 if (ELF_ST_BIND(sym->st_info) != STB_GLOBAL &&
587 ELF_ST_BIND(sym->st_info) != STB_WEAK)
588 break;
589 if (ignore_undef_symbol(info, symname))
590 break;
591
592#if defined(STT_REGISTER) || defined(STT_SPARC_REGISTER)
593
594#ifndef STT_SPARC_REGISTER
595#define STT_SPARC_REGISTER STT_REGISTER
596#endif
597 if (info->hdr->e_machine == EM_SPARC ||
598 info->hdr->e_machine == EM_SPARCV9) {
599
600 if (ELF_ST_TYPE(sym->st_info) == STT_SPARC_REGISTER)
601 break;
602 if (symname[0] == '.') {
603 char *munged = strdup(symname);
604 munged[0] = '_';
605 munged[1] = toupper(munged[1]);
606 symname = munged;
607 }
608 }
609#endif
610
611 if (memcmp(symname, MODULE_SYMBOL_PREFIX,
612 strlen(MODULE_SYMBOL_PREFIX)) == 0) {
613 mod->unres =
614 alloc_symbol(symname +
615 strlen(MODULE_SYMBOL_PREFIX),
616 ELF_ST_BIND(sym->st_info) == STB_WEAK,
617 mod->unres);
618 }
619 break;
620 default:
621
622 if (strncmp(symname, KSYMTAB_PFX, strlen(KSYMTAB_PFX)) == 0) {
623 sym_add_exported(symname + strlen(KSYMTAB_PFX), mod,
624 export);
625 }
626 if (strcmp(symname, MODULE_SYMBOL_PREFIX "init_module") == 0)
627 mod->has_init = 1;
628 if (strcmp(symname, MODULE_SYMBOL_PREFIX "cleanup_module") == 0)
629 mod->has_cleanup = 1;
630 break;
631 }
632}
633
634
635
636
637static char *next_string(char *string, unsigned long *secsize)
638{
639
640 while (string[0]) {
641 string++;
642 if ((*secsize)-- <= 1)
643 return NULL;
644 }
645
646
647 while (!string[0]) {
648 string++;
649 if ((*secsize)-- <= 1)
650 return NULL;
651 }
652 return string;
653}
654
655static char *get_next_modinfo(void *modinfo, unsigned long modinfo_len,
656 const char *tag, char *info)
657{
658 char *p;
659 unsigned int taglen = strlen(tag);
660 unsigned long size = modinfo_len;
661
662 if (info) {
663 size -= info - (char *)modinfo;
664 modinfo = next_string(info, &size);
665 }
666
667 for (p = modinfo; p; p = next_string(p, &size)) {
668 if (strncmp(p, tag, taglen) == 0 && p[taglen] == '=')
669 return p + taglen + 1;
670 }
671 return NULL;
672}
673
674static char *get_modinfo(void *modinfo, unsigned long modinfo_len,
675 const char *tag)
676
677{
678 return get_next_modinfo(modinfo, modinfo_len, tag, NULL);
679}
680
681
682
683
684
685static int strrcmp(const char *s, const char *sub)
686{
687 int slen, sublen;
688
689 if (!s || !sub)
690 return 1;
691
692 slen = strlen(s);
693 sublen = strlen(sub);
694
695 if ((slen == 0) || (sublen == 0))
696 return 1;
697
698 if (sublen > slen)
699 return 1;
700
701 return memcmp(s + slen - sublen, sub, sublen);
702}
703
704static const char *sym_name(struct elf_info *elf, Elf_Sym *sym)
705{
706 if (sym)
707 return elf->strtab + sym->st_name;
708 else
709 return "(unknown)";
710}
711
712static const char *sec_name(struct elf_info *elf, int secindex)
713{
714 Elf_Shdr *sechdrs = elf->sechdrs;
715 return (void *)elf->hdr +
716 elf->sechdrs[elf->secindex_strings].sh_offset +
717 sechdrs[secindex].sh_name;
718}
719
720static const char *sech_name(struct elf_info *elf, Elf_Shdr *sechdr)
721{
722 return (void *)elf->hdr +
723 elf->sechdrs[elf->secindex_strings].sh_offset +
724 sechdr->sh_name;
725}
726
727
728
729
730
731static int number_prefix(const char *sym)
732{
733 if (*sym++ == '\0')
734 return 1;
735 if (*sym != '.')
736 return 0;
737 do {
738 char c = *sym++;
739 if (c < '0' || c > '9')
740 return 0;
741 } while (*sym);
742 return 1;
743}
744
745
746
747
748
749
750
751
752
753
754static int match(const char *sym, const char * const pat[])
755{
756 const char *p;
757 while (*pat) {
758 p = *pat++;
759 const char *endp = p + strlen(p) - 1;
760
761
762 if (*p == '*') {
763 if (strrcmp(sym, p + 1) == 0)
764 return 1;
765 }
766
767 else if (*endp == '*') {
768 if (strncmp(sym, p, strlen(p) - 1) == 0)
769 return 1;
770 }
771
772 else if (*endp == '$') {
773 if (strncmp(sym, p, strlen(p) - 1) == 0) {
774 if (number_prefix(sym + strlen(p) - 1))
775 return 1;
776 }
777 }
778
779 else {
780 if (strcmp(p, sym) == 0)
781 return 1;
782 }
783 }
784
785 return 0;
786}
787
788
789static const char *section_white_list[] =
790{
791 ".comment*",
792 ".debug*",
793 ".zdebug*",
794 ".GCC-command-line",
795 ".mdebug*",
796 ".pdr",
797 ".stab*",
798 ".note*",
799 ".got*",
800 ".toc*",
801 NULL
802};
803
804
805
806
807
808
809static void check_section(const char *modname, struct elf_info *elf,
810 Elf_Shdr *sechdr)
811{
812 const char *sec = sech_name(elf, sechdr);
813
814 if (sechdr->sh_type == SHT_PROGBITS &&
815 !(sechdr->sh_flags & SHF_ALLOC) &&
816 !match(sec, section_white_list)) {
817 warn("%s (%s): unexpected non-allocatable section.\n"
818 "Did you forget to use \"ax\"/\"aw\" in a .S file?\n"
819 "Note that for example <linux/init.h> contains\n"
820 "section definitions for use in .S files.\n\n",
821 modname, sec);
822 }
823}
824
825
826
827#define ALL_INIT_DATA_SECTIONS \
828 ".init.setup$", ".init.rodata$", \
829 ".devinit.rodata$", ".cpuinit.rodata$", ".meminit.rodata$" \
830 ".init.data$", ".devinit.data$", ".cpuinit.data$", ".meminit.data$"
831#define ALL_EXIT_DATA_SECTIONS \
832 ".exit.data$", ".devexit.data$", ".cpuexit.data$", ".memexit.data$"
833
834#define ALL_INIT_TEXT_SECTIONS \
835 ".init.text$", ".devinit.text$", ".cpuinit.text$", ".meminit.text$"
836#define ALL_EXIT_TEXT_SECTIONS \
837 ".exit.text$", ".devexit.text$", ".cpuexit.text$", ".memexit.text$"
838
839#define ALL_XXXINIT_SECTIONS DEV_INIT_SECTIONS, CPU_INIT_SECTIONS, \
840 MEM_INIT_SECTIONS
841#define ALL_XXXEXIT_SECTIONS DEV_EXIT_SECTIONS, CPU_EXIT_SECTIONS, \
842 MEM_EXIT_SECTIONS
843
844#define ALL_INIT_SECTIONS INIT_SECTIONS, ALL_XXXINIT_SECTIONS
845#define ALL_EXIT_SECTIONS EXIT_SECTIONS, ALL_XXXEXIT_SECTIONS
846
847#define DATA_SECTIONS ".data$", ".data.rel$"
848#define TEXT_SECTIONS ".text$"
849
850#define INIT_SECTIONS ".init.*"
851#define DEV_INIT_SECTIONS ".devinit.*"
852#define CPU_INIT_SECTIONS ".cpuinit.*"
853#define MEM_INIT_SECTIONS ".meminit.*"
854
855#define EXIT_SECTIONS ".exit.*"
856#define DEV_EXIT_SECTIONS ".devexit.*"
857#define CPU_EXIT_SECTIONS ".cpuexit.*"
858#define MEM_EXIT_SECTIONS ".memexit.*"
859
860
861static const char *init_data_sections[] = { ALL_INIT_DATA_SECTIONS, NULL };
862
863
864static const char *init_sections[] = { ALL_INIT_SECTIONS, NULL };
865
866
867static const char *init_exit_sections[] =
868 {ALL_INIT_SECTIONS, ALL_EXIT_SECTIONS, NULL };
869
870
871static const char *data_sections[] = { DATA_SECTIONS, NULL };
872
873
874
875#define DEFAULT_SYMBOL_WHITE_LIST \
876 "*driver", \
877 "*_template", \
878 "*_timer", \
879 "*_sht", \
880 "*_ops", \
881 "*_probe", \
882 "*_probe_one", \
883 "*_console"
884
885static const char *head_sections[] = { ".head.text*", NULL };
886static const char *linker_symbols[] =
887 { "__init_begin", "_sinittext", "_einittext", NULL };
888
889enum mismatch {
890 TEXT_TO_ANY_INIT,
891 DATA_TO_ANY_INIT,
892 TEXT_TO_ANY_EXIT,
893 DATA_TO_ANY_EXIT,
894 XXXINIT_TO_SOME_INIT,
895 XXXEXIT_TO_SOME_EXIT,
896 ANY_INIT_TO_ANY_EXIT,
897 ANY_EXIT_TO_ANY_INIT,
898 EXPORT_TO_INIT_EXIT,
899};
900
901struct sectioncheck {
902 const char *fromsec[20];
903 const char *tosec[20];
904 enum mismatch mismatch;
905 const char *symbol_white_list[20];
906};
907
908const struct sectioncheck sectioncheck[] = {
909
910
911
912{
913 .fromsec = { TEXT_SECTIONS, NULL },
914 .tosec = { ALL_INIT_SECTIONS, NULL },
915 .mismatch = TEXT_TO_ANY_INIT,
916 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
917},
918{
919 .fromsec = { DATA_SECTIONS, NULL },
920 .tosec = { ALL_XXXINIT_SECTIONS, NULL },
921 .mismatch = DATA_TO_ANY_INIT,
922 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
923},
924{
925 .fromsec = { DATA_SECTIONS, NULL },
926 .tosec = { INIT_SECTIONS, NULL },
927 .mismatch = DATA_TO_ANY_INIT,
928 .symbol_white_list = {
929 "*_template", "*_timer", "*_sht", "*_ops",
930 "*_probe", "*_probe_one", "*_console", NULL
931 },
932},
933{
934 .fromsec = { TEXT_SECTIONS, NULL },
935 .tosec = { ALL_EXIT_SECTIONS, NULL },
936 .mismatch = TEXT_TO_ANY_EXIT,
937 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
938},
939{
940 .fromsec = { DATA_SECTIONS, NULL },
941 .tosec = { ALL_EXIT_SECTIONS, NULL },
942 .mismatch = DATA_TO_ANY_EXIT,
943 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
944},
945
946{
947 .fromsec = { ALL_XXXINIT_SECTIONS, NULL },
948 .tosec = { INIT_SECTIONS, NULL },
949 .mismatch = XXXINIT_TO_SOME_INIT,
950 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
951},
952
953{
954 .fromsec = { MEM_INIT_SECTIONS, NULL },
955 .tosec = { CPU_INIT_SECTIONS, NULL },
956 .mismatch = XXXINIT_TO_SOME_INIT,
957 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
958},
959
960{
961 .fromsec = { CPU_INIT_SECTIONS, NULL },
962 .tosec = { MEM_INIT_SECTIONS, NULL },
963 .mismatch = XXXINIT_TO_SOME_INIT,
964 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
965},
966
967{
968 .fromsec = { ALL_XXXEXIT_SECTIONS, NULL },
969 .tosec = { EXIT_SECTIONS, NULL },
970 .mismatch = XXXEXIT_TO_SOME_EXIT,
971 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
972},
973
974{
975 .fromsec = { MEM_EXIT_SECTIONS, NULL },
976 .tosec = { CPU_EXIT_SECTIONS, NULL },
977 .mismatch = XXXEXIT_TO_SOME_EXIT,
978 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
979},
980
981{
982 .fromsec = { CPU_EXIT_SECTIONS, NULL },
983 .tosec = { MEM_EXIT_SECTIONS, NULL },
984 .mismatch = XXXEXIT_TO_SOME_EXIT,
985 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
986},
987
988{
989 .fromsec = { ALL_INIT_SECTIONS, NULL },
990 .tosec = { ALL_EXIT_SECTIONS, NULL },
991 .mismatch = ANY_INIT_TO_ANY_EXIT,
992 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
993},
994
995{
996 .fromsec = { ALL_EXIT_SECTIONS, NULL },
997 .tosec = { ALL_INIT_SECTIONS, NULL },
998 .mismatch = ANY_EXIT_TO_ANY_INIT,
999 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1000},
1001
1002{
1003 .fromsec = { "__ksymtab*", NULL },
1004 .tosec = { INIT_SECTIONS, EXIT_SECTIONS, NULL },
1005 .mismatch = EXPORT_TO_INIT_EXIT,
1006 .symbol_white_list = { DEFAULT_SYMBOL_WHITE_LIST, NULL },
1007}
1008};
1009
1010static const struct sectioncheck *section_mismatch(
1011 const char *fromsec, const char *tosec)
1012{
1013 int i;
1014 int elems = sizeof(sectioncheck) / sizeof(struct sectioncheck);
1015 const struct sectioncheck *check = §ioncheck[0];
1016
1017 for (i = 0; i < elems; i++) {
1018 if (match(fromsec, check->fromsec) &&
1019 match(tosec, check->tosec))
1020 return check;
1021 check++;
1022 }
1023 return NULL;
1024}
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070static int secref_whitelist(const struct sectioncheck *mismatch,
1071 const char *fromsec, const char *fromsym,
1072 const char *tosec, const char *tosym)
1073{
1074
1075 if (match(tosec, init_data_sections) &&
1076 match(fromsec, data_sections) &&
1077 (strncmp(fromsym, "__param", strlen("__param")) == 0))
1078 return 0;
1079
1080
1081 if (strcmp(tosec, ".init.text") == 0 &&
1082 match(fromsec, data_sections) &&
1083 (strncmp(fromsym, "__param_ops_", strlen("__param_ops_")) == 0))
1084 return 0;
1085
1086
1087 if (match(tosec, init_exit_sections) &&
1088 match(fromsec, data_sections) &&
1089 match(fromsym, mismatch->symbol_white_list))
1090 return 0;
1091
1092
1093 if (match(fromsec, head_sections) &&
1094 match(tosec, init_sections))
1095 return 0;
1096
1097
1098 if (match(tosym, linker_symbols))
1099 return 0;
1100
1101 return 1;
1102}
1103
1104
1105
1106
1107
1108
1109
1110
1111static Elf_Sym *find_elf_symbol(struct elf_info *elf, Elf64_Sword addr,
1112 Elf_Sym *relsym)
1113{
1114 Elf_Sym *sym;
1115 Elf_Sym *near = NULL;
1116 Elf64_Sword distance = 20;
1117 Elf64_Sword d;
1118 unsigned int relsym_secindex;
1119
1120 if (relsym->st_name != 0)
1121 return relsym;
1122
1123 relsym_secindex = get_secindex(elf, relsym);
1124 for (sym = elf->symtab_start; sym < elf->symtab_stop; sym++) {
1125 if (get_secindex(elf, sym) != relsym_secindex)
1126 continue;
1127 if (ELF_ST_TYPE(sym->st_info) == STT_SECTION)
1128 continue;
1129 if (sym->st_value == addr)
1130 return sym;
1131
1132 d = sym->st_value - addr;
1133 if (d < 0)
1134 d = addr - sym->st_value;
1135 if (d < distance) {
1136 distance = d;
1137 near = sym;
1138 }
1139 }
1140
1141 if (distance < 20)
1142 return near;
1143 else
1144 return NULL;
1145}
1146
1147static inline int is_arm_mapping_symbol(const char *str)
1148{
1149 return str[0] == '$' && strchr("atd", str[1])
1150 && (str[2] == '\0' || str[2] == '.');
1151}
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162static inline int is_valid_name(struct elf_info *elf, Elf_Sym *sym)
1163{
1164 const char *name = elf->strtab + sym->st_name;
1165
1166 if (!name || !strlen(name))
1167 return 0;
1168 return !is_arm_mapping_symbol(name);
1169}
1170
1171
1172
1173
1174
1175
1176
1177static Elf_Sym *find_elf_symbol2(struct elf_info *elf, Elf_Addr addr,
1178 const char *sec)
1179{
1180 Elf_Sym *sym;
1181 Elf_Sym *near = NULL;
1182 Elf_Addr distance = ~0;
1183
1184 for (sym = elf->symtab_start; sym < elf->symtab_stop; sym++) {
1185 const char *symsec;
1186
1187 if (is_shndx_special(sym->st_shndx))
1188 continue;
1189 symsec = sec_name(elf, get_secindex(elf, sym));
1190 if (strcmp(symsec, sec) != 0)
1191 continue;
1192 if (!is_valid_name(elf, sym))
1193 continue;
1194 if (sym->st_value <= addr) {
1195 if ((addr - sym->st_value) < distance) {
1196 distance = addr - sym->st_value;
1197 near = sym;
1198 } else if ((addr - sym->st_value) == distance) {
1199 near = sym;
1200 }
1201 }
1202 }
1203 return near;
1204}
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216static char *sec2annotation(const char *s)
1217{
1218 if (match(s, init_exit_sections)) {
1219 char *p = malloc(20);
1220 char *r = p;
1221
1222 *p++ = '_';
1223 *p++ = '_';
1224 if (*s == '.')
1225 s++;
1226 while (*s && *s != '.')
1227 *p++ = *s++;
1228 *p = '\0';
1229 if (*s == '.')
1230 s++;
1231 if (strstr(s, "rodata") != NULL)
1232 strcat(p, "const ");
1233 else if (strstr(s, "data") != NULL)
1234 strcat(p, "data ");
1235 else
1236 strcat(p, " ");
1237 return r;
1238 } else {
1239 return strdup("");
1240 }
1241}
1242
1243static int is_function(Elf_Sym *sym)
1244{
1245 if (sym)
1246 return ELF_ST_TYPE(sym->st_info) == STT_FUNC;
1247 else
1248 return -1;
1249}
1250
1251
1252
1253
1254
1255
1256static void report_sec_mismatch(const char *modname,
1257 const struct sectioncheck *mismatch,
1258 const char *fromsec,
1259 unsigned long long fromaddr,
1260 const char *fromsym,
1261 int from_is_func,
1262 const char *tosec, const char *tosym,
1263 int to_is_func)
1264{
1265 const char *from, *from_p;
1266 const char *to, *to_p;
1267 char *prl_from;
1268 char *prl_to;
1269
1270 switch (from_is_func) {
1271 case 0: from = "variable"; from_p = ""; break;
1272 case 1: from = "function"; from_p = "()"; break;
1273 default: from = "(unknown reference)"; from_p = ""; break;
1274 }
1275 switch (to_is_func) {
1276 case 0: to = "variable"; to_p = ""; break;
1277 case 1: to = "function"; to_p = "()"; break;
1278 default: to = "(unknown reference)"; to_p = ""; break;
1279 }
1280
1281 sec_mismatch_count++;
1282 if (!sec_mismatch_verbose)
1283 return;
1284
1285 warn("%s(%s+0x%llx): Section mismatch in reference from the %s %s%s "
1286 "to the %s %s:%s%s\n",
1287 modname, fromsec, fromaddr, from, fromsym, from_p, to, tosec,
1288 tosym, to_p);
1289
1290 switch (mismatch->mismatch) {
1291 case TEXT_TO_ANY_INIT:
1292 prl_from = sec2annotation(fromsec);
1293 prl_to = sec2annotation(tosec);
1294 fprintf(stderr,
1295 "The function %s%s() references\n"
1296 "the %s %s%s%s.\n"
1297 "This is often because %s lacks a %s\n"
1298 "annotation or the annotation of %s is wrong.\n",
1299 prl_from, fromsym,
1300 to, prl_to, tosym, to_p,
1301 fromsym, prl_to, tosym);
1302 free(prl_from);
1303 free(prl_to);
1304 break;
1305 case DATA_TO_ANY_INIT: {
1306 prl_to = sec2annotation(tosec);
1307 const char *const *s = mismatch->symbol_white_list;
1308 fprintf(stderr,
1309 "The variable %s references\n"
1310 "the %s %s%s%s\n"
1311 "If the reference is valid then annotate the\n"
1312 "variable with __init* or __refdata (see linux/init.h) "
1313 "or name the variable:\n",
1314 fromsym, to, prl_to, tosym, to_p);
1315 while (*s)
1316 fprintf(stderr, "%s, ", *s++);
1317 fprintf(stderr, "\n");
1318 free(prl_to);
1319 break;
1320 }
1321 case TEXT_TO_ANY_EXIT:
1322 prl_to = sec2annotation(tosec);
1323 fprintf(stderr,
1324 "The function %s() references a %s in an exit section.\n"
1325 "Often the %s %s%s has valid usage outside the exit section\n"
1326 "and the fix is to remove the %sannotation of %s.\n",
1327 fromsym, to, to, tosym, to_p, prl_to, tosym);
1328 free(prl_to);
1329 break;
1330 case DATA_TO_ANY_EXIT: {
1331 prl_to = sec2annotation(tosec);
1332 const char *const *s = mismatch->symbol_white_list;
1333 fprintf(stderr,
1334 "The variable %s references\n"
1335 "the %s %s%s%s\n"
1336 "If the reference is valid then annotate the\n"
1337 "variable with __exit* (see linux/init.h) or "
1338 "name the variable:\n",
1339 fromsym, to, prl_to, tosym, to_p);
1340 while (*s)
1341 fprintf(stderr, "%s, ", *s++);
1342 fprintf(stderr, "\n");
1343 free(prl_to);
1344 break;
1345 }
1346 case XXXINIT_TO_SOME_INIT:
1347 case XXXEXIT_TO_SOME_EXIT:
1348 prl_from = sec2annotation(fromsec);
1349 prl_to = sec2annotation(tosec);
1350 fprintf(stderr,
1351 "The %s %s%s%s references\n"
1352 "a %s %s%s%s.\n"
1353 "If %s is only used by %s then\n"
1354 "annotate %s with a matching annotation.\n",
1355 from, prl_from, fromsym, from_p,
1356 to, prl_to, tosym, to_p,
1357 tosym, fromsym, tosym);
1358 free(prl_from);
1359 free(prl_to);
1360 break;
1361 case ANY_INIT_TO_ANY_EXIT:
1362 prl_from = sec2annotation(fromsec);
1363 prl_to = sec2annotation(tosec);
1364 fprintf(stderr,
1365 "The %s %s%s%s references\n"
1366 "a %s %s%s%s.\n"
1367 "This is often seen when error handling "
1368 "in the init function\n"
1369 "uses functionality in the exit path.\n"
1370 "The fix is often to remove the %sannotation of\n"
1371 "%s%s so it may be used outside an exit section.\n",
1372 from, prl_from, fromsym, from_p,
1373 to, prl_to, tosym, to_p,
1374 prl_to, tosym, to_p);
1375 free(prl_from);
1376 free(prl_to);
1377 break;
1378 case ANY_EXIT_TO_ANY_INIT:
1379 prl_from = sec2annotation(fromsec);
1380 prl_to = sec2annotation(tosec);
1381 fprintf(stderr,
1382 "The %s %s%s%s references\n"
1383 "a %s %s%s%s.\n"
1384 "This is often seen when error handling "
1385 "in the exit function\n"
1386 "uses functionality in the init path.\n"
1387 "The fix is often to remove the %sannotation of\n"
1388 "%s%s so it may be used outside an init section.\n",
1389 from, prl_from, fromsym, from_p,
1390 to, prl_to, tosym, to_p,
1391 prl_to, tosym, to_p);
1392 free(prl_from);
1393 free(prl_to);
1394 break;
1395 case EXPORT_TO_INIT_EXIT:
1396 prl_to = sec2annotation(tosec);
1397 fprintf(stderr,
1398 "The symbol %s is exported and annotated %s\n"
1399 "Fix this by removing the %sannotation of %s "
1400 "or drop the export.\n",
1401 tosym, prl_to, prl_to, tosym);
1402 free(prl_to);
1403 break;
1404 }
1405 fprintf(stderr, "\n");
1406}
1407
1408static void check_section_mismatch(const char *modname, struct elf_info *elf,
1409 Elf_Rela *r, Elf_Sym *sym, const char *fromsec)
1410{
1411 const char *tosec;
1412 const struct sectioncheck *mismatch;
1413
1414 tosec = sec_name(elf, get_secindex(elf, sym));
1415 mismatch = section_mismatch(fromsec, tosec);
1416 if (mismatch) {
1417 Elf_Sym *to;
1418 Elf_Sym *from;
1419 const char *tosym;
1420 const char *fromsym;
1421
1422 from = find_elf_symbol2(elf, r->r_offset, fromsec);
1423 fromsym = sym_name(elf, from);
1424 to = find_elf_symbol(elf, r->r_addend, sym);
1425 tosym = sym_name(elf, to);
1426
1427
1428 if (secref_whitelist(mismatch,
1429 fromsec, fromsym, tosec, tosym)) {
1430 report_sec_mismatch(modname, mismatch,
1431 fromsec, r->r_offset, fromsym,
1432 is_function(from), tosec, tosym,
1433 is_function(to));
1434 }
1435 }
1436}
1437
1438static unsigned int *reloc_location(struct elf_info *elf,
1439 Elf_Shdr *sechdr, Elf_Rela *r)
1440{
1441 Elf_Shdr *sechdrs = elf->sechdrs;
1442 int section = shndx2secindex(sechdr->sh_info);
1443
1444 return (void *)elf->hdr + sechdrs[section].sh_offset +
1445 r->r_offset;
1446}
1447
1448static int addend_386_rel(struct elf_info *elf, Elf_Shdr *sechdr, Elf_Rela *r)
1449{
1450 unsigned int r_typ = ELF_R_TYPE(r->r_info);
1451 unsigned int *location = reloc_location(elf, sechdr, r);
1452
1453 switch (r_typ) {
1454 case R_386_32:
1455 r->r_addend = TO_NATIVE(*location);
1456 break;
1457 case R_386_PC32:
1458 r->r_addend = TO_NATIVE(*location) + 4;
1459
1460 if (elf->hdr->e_type == ET_EXEC)
1461 r->r_addend += r->r_offset;
1462 break;
1463 }
1464 return 0;
1465}
1466
1467static int addend_arm_rel(struct elf_info *elf, Elf_Shdr *sechdr, Elf_Rela *r)
1468{
1469 unsigned int r_typ = ELF_R_TYPE(r->r_info);
1470
1471 switch (r_typ) {
1472 case R_ARM_ABS32:
1473
1474 r->r_addend = (int)(long)
1475 (elf->symtab_start + ELF_R_SYM(r->r_info));
1476 break;
1477 case R_ARM_PC24:
1478
1479 r->r_addend = (int)(long)(elf->hdr +
1480 sechdr->sh_offset +
1481 (r->r_offset - sechdr->sh_addr));
1482 break;
1483 default:
1484 return 1;
1485 }
1486 return 0;
1487}
1488
1489static int addend_mips_rel(struct elf_info *elf, Elf_Shdr *sechdr, Elf_Rela *r)
1490{
1491 unsigned int r_typ = ELF_R_TYPE(r->r_info);
1492 unsigned int *location = reloc_location(elf, sechdr, r);
1493 unsigned int inst;
1494
1495 if (r_typ == R_MIPS_HI16)
1496 return 1;
1497 inst = TO_NATIVE(*location);
1498 switch (r_typ) {
1499 case R_MIPS_LO16:
1500 r->r_addend = inst & 0xffff;
1501 break;
1502 case R_MIPS_26:
1503 r->r_addend = (inst & 0x03ffffff) << 2;
1504 break;
1505 case R_MIPS_32:
1506 r->r_addend = inst;
1507 break;
1508 }
1509 return 0;
1510}
1511
1512static void section_rela(const char *modname, struct elf_info *elf,
1513 Elf_Shdr *sechdr)
1514{
1515 Elf_Sym *sym;
1516 Elf_Rela *rela;
1517 Elf_Rela r;
1518 unsigned int r_sym;
1519 const char *fromsec;
1520
1521 Elf_Rela *start = (void *)elf->hdr + sechdr->sh_offset;
1522 Elf_Rela *stop = (void *)start + sechdr->sh_size;
1523
1524 fromsec = sech_name(elf, sechdr);
1525 fromsec += strlen(".rela");
1526
1527 if (match(fromsec, section_white_list))
1528 return;
1529
1530 for (rela = start; rela < stop; rela++) {
1531 r.r_offset = TO_NATIVE(rela->r_offset);
1532#if KERNEL_ELFCLASS == ELFCLASS64
1533 if (elf->hdr->e_machine == EM_MIPS) {
1534 unsigned int r_typ;
1535 r_sym = ELF64_MIPS_R_SYM(rela->r_info);
1536 r_sym = TO_NATIVE(r_sym);
1537 r_typ = ELF64_MIPS_R_TYPE(rela->r_info);
1538 r.r_info = ELF64_R_INFO(r_sym, r_typ);
1539 } else {
1540 r.r_info = TO_NATIVE(rela->r_info);
1541 r_sym = ELF_R_SYM(r.r_info);
1542 }
1543#else
1544 r.r_info = TO_NATIVE(rela->r_info);
1545 r_sym = ELF_R_SYM(r.r_info);
1546#endif
1547 r.r_addend = TO_NATIVE(rela->r_addend);
1548 sym = elf->symtab_start + r_sym;
1549
1550 if (is_shndx_special(sym->st_shndx))
1551 continue;
1552 check_section_mismatch(modname, elf, &r, sym, fromsec);
1553 }
1554}
1555
1556static void section_rel(const char *modname, struct elf_info *elf,
1557 Elf_Shdr *sechdr)
1558{
1559 Elf_Sym *sym;
1560 Elf_Rel *rel;
1561 Elf_Rela r;
1562 unsigned int r_sym;
1563 const char *fromsec;
1564
1565 Elf_Rel *start = (void *)elf->hdr + sechdr->sh_offset;
1566 Elf_Rel *stop = (void *)start + sechdr->sh_size;
1567
1568 fromsec = sech_name(elf, sechdr);
1569 fromsec += strlen(".rel");
1570
1571 if (match(fromsec, section_white_list))
1572 return;
1573
1574 for (rel = start; rel < stop; rel++) {
1575 r.r_offset = TO_NATIVE(rel->r_offset);
1576#if KERNEL_ELFCLASS == ELFCLASS64
1577 if (elf->hdr->e_machine == EM_MIPS) {
1578 unsigned int r_typ;
1579 r_sym = ELF64_MIPS_R_SYM(rel->r_info);
1580 r_sym = TO_NATIVE(r_sym);
1581 r_typ = ELF64_MIPS_R_TYPE(rel->r_info);
1582 r.r_info = ELF64_R_INFO(r_sym, r_typ);
1583 } else {
1584 r.r_info = TO_NATIVE(rel->r_info);
1585 r_sym = ELF_R_SYM(r.r_info);
1586 }
1587#else
1588 r.r_info = TO_NATIVE(rel->r_info);
1589 r_sym = ELF_R_SYM(r.r_info);
1590#endif
1591 r.r_addend = 0;
1592 switch (elf->hdr->e_machine) {
1593 case EM_386:
1594 if (addend_386_rel(elf, sechdr, &r))
1595 continue;
1596 break;
1597 case EM_ARM:
1598 if (addend_arm_rel(elf, sechdr, &r))
1599 continue;
1600 break;
1601 case EM_MIPS:
1602 if (addend_mips_rel(elf, sechdr, &r))
1603 continue;
1604 break;
1605 }
1606 sym = elf->symtab_start + r_sym;
1607
1608 if (is_shndx_special(sym->st_shndx))
1609 continue;
1610 check_section_mismatch(modname, elf, &r, sym, fromsec);
1611 }
1612}
1613
1614
1615
1616
1617
1618
1619
1620
1621
1622
1623
1624
1625
1626static void check_sec_ref(struct module *mod, const char *modname,
1627 struct elf_info *elf)
1628{
1629 int i;
1630 Elf_Shdr *sechdrs = elf->sechdrs;
1631
1632
1633 for (i = 0; i < elf->num_sections; i++) {
1634 check_section(modname, elf, &elf->sechdrs[i]);
1635
1636 if (sechdrs[i].sh_type == SHT_RELA)
1637 section_rela(modname, elf, &elf->sechdrs[i]);
1638 else if (sechdrs[i].sh_type == SHT_REL)
1639 section_rel(modname, elf, &elf->sechdrs[i]);
1640 }
1641}
1642
1643static void read_symbols(char *modname)
1644{
1645 const char *symname;
1646 char *version;
1647 char *license;
1648 struct module *mod;
1649 struct elf_info info = { };
1650 Elf_Sym *sym;
1651
1652 if (!parse_elf(&info, modname))
1653 return;
1654
1655 mod = new_module(modname);
1656
1657
1658
1659 if (is_vmlinux(modname)) {
1660 have_vmlinux = 1;
1661 mod->skip = 1;
1662 }
1663
1664 license = get_modinfo(info.modinfo, info.modinfo_len, "license");
1665 if (info.modinfo && !license && !is_vmlinux(modname))
1666 warn("modpost: missing MODULE_LICENSE() in %s\n"
1667 "see include/linux/module.h for "
1668 "more information\n", modname);
1669 while (license) {
1670 if (license_is_gpl_compatible(license))
1671 mod->gpl_compatible = 1;
1672 else {
1673 mod->gpl_compatible = 0;
1674 break;
1675 }
1676 license = get_next_modinfo(info.modinfo, info.modinfo_len,
1677 "license", license);
1678 }
1679
1680 for (sym = info.symtab_start; sym < info.symtab_stop; sym++) {
1681 symname = info.strtab + sym->st_name;
1682
1683 handle_modversions(mod, &info, sym, symname);
1684 handle_moddevtable(mod, &info, sym, symname);
1685 }
1686 if (!is_vmlinux(modname) ||
1687 (is_vmlinux(modname) && vmlinux_section_warnings))
1688 check_sec_ref(mod, modname, &info);
1689
1690 version = get_modinfo(info.modinfo, info.modinfo_len, "version");
1691 if (version)
1692 maybe_frob_rcs_version(modname, version, info.modinfo,
1693 version - (char *)info.hdr);
1694 if (version || (all_versions && !is_vmlinux(modname)))
1695 get_src_version(modname, mod->srcversion,
1696 sizeof(mod->srcversion)-1);
1697
1698 parse_elf_finish(&info);
1699
1700
1701
1702
1703
1704 if (modversions)
1705 mod->unres = alloc_symbol("module_layout", 0, mod->unres);
1706}
1707
1708#define SZ 500
1709
1710
1711
1712
1713
1714void __attribute__((format(printf, 2, 3))) buf_printf(struct buffer *buf,
1715 const char *fmt, ...)
1716{
1717 char tmp[SZ];
1718 int len;
1719 va_list ap;
1720
1721 va_start(ap, fmt);
1722 len = vsnprintf(tmp, SZ, fmt, ap);
1723 buf_write(buf, tmp, len);
1724 va_end(ap);
1725}
1726
1727void buf_write(struct buffer *buf, const char *s, int len)
1728{
1729 if (buf->size - buf->pos < len) {
1730 buf->size += len + SZ;
1731 buf->p = realloc(buf->p, buf->size);
1732 }
1733 strncpy(buf->p + buf->pos, s, len);
1734 buf->pos += len;
1735}
1736
1737static void check_for_gpl_usage(enum export exp, const char *m, const char *s)
1738{
1739 const char *e = is_vmlinux(m) ?"":".ko";
1740
1741 switch (exp) {
1742 case export_gpl:
1743 fatal("modpost: GPL-incompatible module %s%s "
1744 "uses GPL-only symbol '%s'\n", m, e, s);
1745 break;
1746 case export_unused_gpl:
1747 fatal("modpost: GPL-incompatible module %s%s "
1748 "uses GPL-only symbol marked UNUSED '%s'\n", m, e, s);
1749 break;
1750 case export_gpl_future:
1751 warn("modpost: GPL-incompatible module %s%s "
1752 "uses future GPL-only symbol '%s'\n", m, e, s);
1753 break;
1754 case export_plain:
1755 case export_unused:
1756 case export_unknown:
1757
1758 break;
1759 }
1760}
1761
1762static void check_for_unused(enum export exp, const char *m, const char *s)
1763{
1764 const char *e = is_vmlinux(m) ?"":".ko";
1765
1766 switch (exp) {
1767 case export_unused:
1768 case export_unused_gpl:
1769 warn("modpost: module %s%s "
1770 "uses symbol '%s' marked UNUSED\n", m, e, s);
1771 break;
1772 default:
1773
1774 break;
1775 }
1776}
1777
1778static void check_exports(struct module *mod)
1779{
1780 struct symbol *s, *exp;
1781
1782 for (s = mod->unres; s; s = s->next) {
1783 const char *basename;
1784 exp = find_symbol(s->name);
1785 if (!exp || exp->module == mod)
1786 continue;
1787 basename = strrchr(mod->name, '/');
1788 if (basename)
1789 basename++;
1790 else
1791 basename = mod->name;
1792 if (!mod->gpl_compatible)
1793 check_for_gpl_usage(exp->export, basename, exp->name);
1794 check_for_unused(exp->export, basename, exp->name);
1795 }
1796}
1797
1798
1799
1800
1801static void add_header(struct buffer *b, struct module *mod)
1802{
1803 buf_printf(b, "#include <linux/module.h>\n");
1804 buf_printf(b, "#include <linux/vermagic.h>\n");
1805 buf_printf(b, "#include <linux/compiler.h>\n");
1806 buf_printf(b, "\n");
1807 buf_printf(b, "MODULE_INFO(vermagic, VERMAGIC_STRING);\n");
1808 buf_printf(b, "\n");
1809 buf_printf(b, "struct module __this_module\n");
1810 buf_printf(b, "__attribute__((section(\".gnu.linkonce.this_module\"))) = {\n");
1811 buf_printf(b, " .name = KBUILD_MODNAME,\n");
1812 if (mod->has_init)
1813 buf_printf(b, " .init = init_module,\n");
1814 if (mod->has_cleanup)
1815 buf_printf(b, "#ifdef CONFIG_MODULE_UNLOAD\n"
1816 " .exit = cleanup_module,\n"
1817 "#endif\n");
1818 buf_printf(b, " .arch = MODULE_ARCH_INIT,\n");
1819 buf_printf(b, "};\n");
1820}
1821
1822static void add_staging_flag(struct buffer *b, const char *name)
1823{
1824 static const char *staging_dir = "drivers/staging";
1825
1826 if (strncmp(staging_dir, name, strlen(staging_dir)) == 0)
1827 buf_printf(b, "\nMODULE_INFO(staging, \"Y\");\n");
1828}
1829
1830
1831
1832
1833static int add_versions(struct buffer *b, struct module *mod)
1834{
1835 struct symbol *s, *exp;
1836 int err = 0;
1837
1838 for (s = mod->unres; s; s = s->next) {
1839 exp = find_symbol(s->name);
1840 if (!exp || exp->module == mod) {
1841 if (have_vmlinux && !s->weak) {
1842 if (warn_unresolved) {
1843 warn("\"%s\" [%s.ko] undefined!\n",
1844 s->name, mod->name);
1845 } else {
1846 merror("\"%s\" [%s.ko] undefined!\n",
1847 s->name, mod->name);
1848 err = 1;
1849 }
1850 }
1851 continue;
1852 }
1853 s->module = exp->module;
1854 s->crc_valid = exp->crc_valid;
1855 s->crc = exp->crc;
1856 }
1857
1858 if (!modversions)
1859 return err;
1860
1861 buf_printf(b, "\n");
1862 buf_printf(b, "static const struct modversion_info ____versions[]\n");
1863 buf_printf(b, "__used\n");
1864 buf_printf(b, "__attribute__((section(\"__versions\"))) = {\n");
1865
1866 for (s = mod->unres; s; s = s->next) {
1867 if (!s->module)
1868 continue;
1869 if (!s->crc_valid) {
1870 warn("\"%s\" [%s.ko] has no CRC!\n",
1871 s->name, mod->name);
1872 continue;
1873 }
1874 buf_printf(b, "\t{ %#8x, \"%s\" },\n", s->crc, s->name);
1875 }
1876
1877 buf_printf(b, "};\n");
1878
1879 return err;
1880}
1881
1882static void add_depends(struct buffer *b, struct module *mod,
1883 struct module *modules)
1884{
1885 struct symbol *s;
1886 struct module *m;
1887 int first = 1;
1888
1889 for (m = modules; m; m = m->next)
1890 m->seen = is_vmlinux(m->name);
1891
1892 buf_printf(b, "\n");
1893 buf_printf(b, "static const char __module_depends[]\n");
1894 buf_printf(b, "__used\n");
1895 buf_printf(b, "__attribute__((section(\".modinfo\"))) =\n");
1896 buf_printf(b, "\"depends=");
1897 for (s = mod->unres; s; s = s->next) {
1898 const char *p;
1899 if (!s->module)
1900 continue;
1901
1902 if (s->module->seen)
1903 continue;
1904
1905 s->module->seen = 1;
1906 p = strrchr(s->module->name, '/');
1907 if (p)
1908 p++;
1909 else
1910 p = s->module->name;
1911 buf_printf(b, "%s%s", first ? "" : ",", p);
1912 first = 0;
1913 }
1914 buf_printf(b, "\";\n");
1915}
1916
1917static void add_srcversion(struct buffer *b, struct module *mod)
1918{
1919 if (mod->srcversion[0]) {
1920 buf_printf(b, "\n");
1921 buf_printf(b, "MODULE_INFO(srcversion, \"%s\");\n",
1922 mod->srcversion);
1923 }
1924}
1925
1926static void write_if_changed(struct buffer *b, const char *fname)
1927{
1928 char *tmp;
1929 FILE *file;
1930 struct stat st;
1931
1932 file = fopen(fname, "r");
1933 if (!file)
1934 goto write;
1935
1936 if (fstat(fileno(file), &st) < 0)
1937 goto close_write;
1938
1939 if (st.st_size != b->pos)
1940 goto close_write;
1941
1942 tmp = NOFAIL(malloc(b->pos));
1943 if (fread(tmp, 1, b->pos, file) != b->pos)
1944 goto free_write;
1945
1946 if (memcmp(tmp, b->p, b->pos) != 0)
1947 goto free_write;
1948
1949 free(tmp);
1950 fclose(file);
1951 return;
1952
1953 free_write:
1954 free(tmp);
1955 close_write:
1956 fclose(file);
1957 write:
1958 file = fopen(fname, "w");
1959 if (!file) {
1960 perror(fname);
1961 exit(1);
1962 }
1963 if (fwrite(b->p, 1, b->pos, file) != b->pos) {
1964 perror(fname);
1965 exit(1);
1966 }
1967 fclose(file);
1968}
1969
1970
1971
1972
1973static void read_dump(const char *fname, unsigned int kernel)
1974{
1975 unsigned long size, pos = 0;
1976 void *file = grab_file(fname, &size);
1977 char *line;
1978
1979 if (!file)
1980
1981 return;
1982
1983 while ((line = get_next_line(&pos, file, size))) {
1984 char *symname, *modname, *d, *export, *end;
1985 unsigned int crc;
1986 struct module *mod;
1987 struct symbol *s;
1988
1989 if (!(symname = strchr(line, '\t')))
1990 goto fail;
1991 *symname++ = '\0';
1992 if (!(modname = strchr(symname, '\t')))
1993 goto fail;
1994 *modname++ = '\0';
1995 if ((export = strchr(modname, '\t')) != NULL)
1996 *export++ = '\0';
1997 if (export && ((end = strchr(export, '\t')) != NULL))
1998 *end = '\0';
1999 crc = strtoul(line, &d, 16);
2000 if (*symname == '\0' || *modname == '\0' || *d != '\0')
2001 goto fail;
2002 mod = find_module(modname);
2003 if (!mod) {
2004 if (is_vmlinux(modname))
2005 have_vmlinux = 1;
2006 mod = new_module(modname);
2007 mod->skip = 1;
2008 }
2009 s = sym_add_exported(symname, mod, export_no(export));
2010 s->kernel = kernel;
2011 s->preloaded = 1;
2012 sym_update_crc(symname, mod, crc, export_no(export));
2013 }
2014 return;
2015fail:
2016 fatal("parse error in symbol dump file\n");
2017}
2018
2019
2020
2021
2022
2023static int dump_sym(struct symbol *sym)
2024{
2025 if (!external_module)
2026 return 1;
2027 if (sym->vmlinux || sym->kernel)
2028 return 0;
2029 return 1;
2030}
2031
2032static void write_dump(const char *fname)
2033{
2034 struct buffer buf = { };
2035 struct symbol *symbol;
2036 int n;
2037
2038 for (n = 0; n < SYMBOL_HASH_SIZE ; n++) {
2039 symbol = symbolhash[n];
2040 while (symbol) {
2041 if (dump_sym(symbol))
2042 buf_printf(&buf, "0x%08x\t%s\t%s\t%s\n",
2043 symbol->crc, symbol->name,
2044 symbol->module->name,
2045 export_str(symbol->export));
2046 symbol = symbol->next;
2047 }
2048 }
2049 write_if_changed(&buf, fname);
2050}
2051
2052struct ext_sym_list {
2053 struct ext_sym_list *next;
2054 const char *file;
2055};
2056
2057int main(int argc, char **argv)
2058{
2059 struct module *mod;
2060 struct buffer buf = { };
2061 char *kernel_read = NULL, *module_read = NULL;
2062 char *dump_write = NULL;
2063 int opt;
2064 int err;
2065 struct ext_sym_list *extsym_iter;
2066 struct ext_sym_list *extsym_start = NULL;
2067
2068 while ((opt = getopt(argc, argv, "i:I:e:cmsSo:awM:K:")) != -1) {
2069 switch (opt) {
2070 case 'i':
2071 kernel_read = optarg;
2072 break;
2073 case 'I':
2074 module_read = optarg;
2075 external_module = 1;
2076 break;
2077 case 'c':
2078 cross_build = 1;
2079 break;
2080 case 'e':
2081 external_module = 1;
2082 extsym_iter =
2083 NOFAIL(malloc(sizeof(*extsym_iter)));
2084 extsym_iter->next = extsym_start;
2085 extsym_iter->file = optarg;
2086 extsym_start = extsym_iter;
2087 break;
2088 case 'm':
2089 modversions = 1;
2090 break;
2091 case 'o':
2092 dump_write = optarg;
2093 break;
2094 case 'a':
2095 all_versions = 1;
2096 break;
2097 case 's':
2098 vmlinux_section_warnings = 0;
2099 break;
2100 case 'S':
2101 sec_mismatch_verbose = 0;
2102 break;
2103 case 'w':
2104 warn_unresolved = 1;
2105 break;
2106 default:
2107 exit(1);
2108 }
2109 }
2110
2111 if (kernel_read)
2112 read_dump(kernel_read, 1);
2113 if (module_read)
2114 read_dump(module_read, 0);
2115 while (extsym_start) {
2116 read_dump(extsym_start->file, 0);
2117 extsym_iter = extsym_start->next;
2118 free(extsym_start);
2119 extsym_start = extsym_iter;
2120 }
2121
2122 while (optind < argc)
2123 read_symbols(argv[optind++]);
2124
2125 for (mod = modules; mod; mod = mod->next) {
2126 if (mod->skip)
2127 continue;
2128 check_exports(mod);
2129 }
2130
2131 err = 0;
2132
2133 for (mod = modules; mod; mod = mod->next) {
2134 char fname[strlen(mod->name) + 10];
2135
2136 if (mod->skip)
2137 continue;
2138
2139 buf.pos = 0;
2140
2141 add_header(&buf, mod);
2142 add_staging_flag(&buf, mod->name);
2143 err |= add_versions(&buf, mod);
2144 add_depends(&buf, mod, modules);
2145 add_moddevtable(&buf, mod);
2146 add_srcversion(&buf, mod);
2147
2148 sprintf(fname, "%s.mod.c", mod->name);
2149 write_if_changed(&buf, fname);
2150 }
2151
2152 if (dump_write)
2153 write_dump(dump_write);
2154 if (sec_mismatch_count && !sec_mismatch_verbose)
2155 warn("modpost: Found %d section mismatch(es).\n"
2156 "To see full details build your kernel with:\n"
2157 "'make CONFIG_DEBUG_SECTION_MISMATCH=y'\n",
2158 sec_mismatch_count);
2159
2160 return err;
2161}
2162