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