?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
kbuild: fix a buffer overflow in modpost
[linux-2.6/mini2440.git] / scripts / mod / modpost.c
blob4d1c59063b2766fa7d4afc12c16947cb6b78fbb9
1 /* Postprocess module symbol versions
2 *
3 * Copyright 2003 Kai Germaschewski
4 * Copyright 2002-2004 Rusty Russell, IBM Corporation
5 * Copyright 2006 Sam Ravnborg
6 * Based in part on module-init-tools/depmod.c,file2alias
7 *
8 * This software may be used and distributed according to the terms
9 * of the GNU General Public License, incorporated herein by reference.
10 *
11 * Usage: modpost vmlinux module1.o module2.o ...
12 */
13
14 #include <ctype.h>
15 #include "modpost.h"
16 #include "../../include/linux/license.h"
17
18 /* Are we using CONFIG_MODVERSIONS? */
19 int modversions = 0;
20 /* Warn about undefined symbols? (do so if we have vmlinux) */
21 int have_vmlinux = 0;
22 /* Is CONFIG_MODULE_SRCVERSION_ALL set? */
23 static int all_versions = 0;
24 /* If we are modposting external module set to 1 */
25 static int external_module = 0;
26 /* Warn about section mismatch in vmlinux if set to 1 */
27 static int vmlinux_section_warnings = 1;
28 /* Only warn about unresolved symbols */
29 static int warn_unresolved = 0;
30 /* How a symbol is exported */
31 enum export {
32 export_plain, export_unused, export_gpl,
33 export_unused_gpl, export_gpl_future, export_unknown
34 };
35
36 #define PRINTF __attribute__ ((format (printf, 1, 2)))
37
38 PRINTF void fatal(const char *fmt, ...)
39 {
40 va_list arglist;
41
42 fprintf(stderr, "FATAL: ");
43
44 va_start(arglist, fmt);
45 vfprintf(stderr, fmt, arglist);
46 va_end(arglist);
47
48 exit(1);
49 }
50
51 PRINTF void warn(const char *fmt, ...)
52 {
53 va_list arglist;
54
55 fprintf(stderr, "WARNING: ");
56
57 va_start(arglist, fmt);
58 vfprintf(stderr, fmt, arglist);
59 va_end(arglist);
60 }
61
62 PRINTF void merror(const char *fmt, ...)
63 {
64 va_list arglist;
65
66 fprintf(stderr, "ERROR: ");
67
68 va_start(arglist, fmt);
69 vfprintf(stderr, fmt, arglist);
70 va_end(arglist);
71 }
72
73 static int is_vmlinux(const char *modname)
74 {
75 const char *myname;
76
77 if ((myname = strrchr(modname, '/')))
78 myname++;
79 else
80 myname = modname;
81
82 return (strcmp(myname, "vmlinux") == 0) ||
83 (strcmp(myname, "vmlinux.o") == 0);
84 }
85
86 void *do_nofail(void *ptr, const char *expr)
87 {
88 if (!ptr) {
89 fatal("modpost: Memory allocation failure: %s.\n", expr);
90 }
91 return ptr;
92 }
93
94 /* A list of all modules we processed */
95
96 static struct module *modules;
97
98 static struct module *find_module(char *modname)
99 {
100 struct module *mod;
101
102 for (mod = modules; mod; mod = mod->next)
103 if (strcmp(mod->name, modname) == 0)
104 break;
105 return mod;
106 }
107
108 static struct module *new_module(char *modname)
109 {
110 struct module *mod;
111 char *p, *s;
112
113 mod = NOFAIL(malloc(sizeof(*mod)));
114 memset(mod, 0, sizeof(*mod));
115 p = NOFAIL(strdup(modname));
116
117 /* strip trailing .o */
118 if ((s = strrchr(p, '.')) != NULL)
119 if (strcmp(s, ".o") == 0)
120 *s = '\0';
121
122 /* add to list */
123 mod->name = p;
124 mod->gpl_compatible = -1;
125 mod->next = modules;
126 modules = mod;
127
128 return mod;
129 }
130
131 /* A hash of all exported symbols,
132 * struct symbol is also used for lists of unresolved symbols */
133
134 #define SYMBOL_HASH_SIZE 1024
135
136 struct symbol {
137 struct symbol *next;
138 struct module *module;
139 unsigned int crc;
140 int crc_valid;
141 unsigned int weak:1;
142 unsigned int vmlinux:1; /* 1 if symbol is defined in vmlinux */
143 unsigned int kernel:1; /* 1 if symbol is from kernel
144 * (only for external modules) **/
145 unsigned int preloaded:1; /* 1 if symbol from Module.symvers */
146 enum export export; /* Type of export */
147 char name[0];
148 };
149
150 static struct symbol *symbolhash[SYMBOL_HASH_SIZE];
151
152 /* This is based on the hash agorithm from gdbm, via tdb */
153 static inline unsigned int tdb_hash(const char *name)
154 {
155 unsigned value; /* Used to compute the hash value. */
156 unsigned i; /* Used to cycle through random values. */
157
158 /* Set the initial value from the key size. */
159 for (value = 0x238F13AF * strlen(name), i=0; name[i]; i++)
160 value = (value + (((unsigned char *)name)[i] << (i*5 % 24)));
161
162 return (1103515243 * value + 12345);
163 }
164
165 /**
166 * Allocate a new symbols for use in the hash of exported symbols or
167 * the list of unresolved symbols per module
168 **/
169 static struct symbol *alloc_symbol(const char *name, unsigned int weak,
170 struct symbol *next)
171 {
172 struct symbol *s = NOFAIL(malloc(sizeof(*s) + strlen(name) + 1));
173
174 memset(s, 0, sizeof(*s));
175 strcpy(s->name, name);
176 s->weak = weak;
177 s->next = next;
178 return s;
179 }
180
181 /* For the hash of exported symbols */
182 static struct symbol *new_symbol(const char *name, struct module *module,
183 enum export export)
184 {
185 unsigned int hash;
186 struct symbol *new;
187
188 hash = tdb_hash(name) % SYMBOL_HASH_SIZE;
189 new = symbolhash[hash] = alloc_symbol(name, 0, symbolhash[hash]);
190 new->module = module;
191 new->export = export;
192 return new;
193 }
194
195 static struct symbol *find_symbol(const char *name)
196 {
197 struct symbol *s;
198
199 /* For our purposes, .foo matches foo. PPC64 needs this. */
200 if (name[0] == '.')
201 name++;
202
203 for (s = symbolhash[tdb_hash(name) % SYMBOL_HASH_SIZE]; s; s=s->next) {
204 if (strcmp(s->name, name) == 0)
205 return s;
206 }
207 return NULL;
208 }
209
210 static struct {
211 const char *str;
212 enum export export;
213 } export_list[] = {
214 { .str = "EXPORT_SYMBOL", .export = export_plain },
215 { .str = "EXPORT_UNUSED_SYMBOL", .export = export_unused },
216 { .str = "EXPORT_SYMBOL_GPL", .export = export_gpl },
217 { .str = "EXPORT_UNUSED_SYMBOL_GPL", .export = export_unused_gpl },
218 { .str = "EXPORT_SYMBOL_GPL_FUTURE", .export = export_gpl_future },
219 { .str = "(unknown)", .export = export_unknown },
220 };
221
222
223 static const char *export_str(enum export ex)
224 {
225 return export_list[ex].str;
226 }
227
228 static enum export export_no(const char * s)
229 {
230 int i;
231 if (!s)
232 return export_unknown;
233 for (i = 0; export_list[i].export != export_unknown; i++) {
234 if (strcmp(export_list[i].str, s) == 0)
235 return export_list[i].export;
236 }
237 return export_unknown;
238 }
239
240 static enum export export_from_sec(struct elf_info *elf, Elf_Section sec)
241 {
242 if (sec == elf->export_sec)
243 return export_plain;
244 else if (sec == elf->export_unused_sec)
245 return export_unused;
246 else if (sec == elf->export_gpl_sec)
247 return export_gpl;
248 else if (sec == elf->export_unused_gpl_sec)
249 return export_unused_gpl;
250 else if (sec == elf->export_gpl_future_sec)
251 return export_gpl_future;
252 else
253 return export_unknown;
254 }
255
256 /**
257 * Add an exported symbol - it may have already been added without a
258 * CRC, in this case just update the CRC
259 **/
260 static struct symbol *sym_add_exported(const char *name, struct module *mod,
261 enum export export)
262 {
263 struct symbol *s = find_symbol(name);
264
265 if (!s) {
266 s = new_symbol(name, mod, export);
267 } else {
268 if (!s->preloaded) {
269 warn("%s: '%s' exported twice. Previous export "
270 "was in %s%s\n", mod->name, name,
271 s->module->name,
272 is_vmlinux(s->module->name) ?"":".ko");
273 } else {
274 /* In case Modules.symvers was out of date */
275 s->module = mod;
276 }
277 }
278 s->preloaded = 0;
279 s->vmlinux = is_vmlinux(mod->name);
280 s->kernel = 0;
281 s->export = export;
282 return s;
283 }
284
285 static void sym_update_crc(const char *name, struct module *mod,
286 unsigned int crc, enum export export)
287 {
288 struct symbol *s = find_symbol(name);
289
290 if (!s)
291 s = new_symbol(name, mod, export);
292 s->crc = crc;
293 s->crc_valid = 1;
294 }
295
296 void *grab_file(const char *filename, unsigned long *size)
297 {
298 struct stat st;
299 void *map;
300 int fd;
301
302 fd = open(filename, O_RDONLY);
303 if (fd < 0 || fstat(fd, &st) != 0)
304 return NULL;
305
306 *size = st.st_size;
307 map = mmap(NULL, *size, PROT_READ|PROT_WRITE, MAP_PRIVATE, fd, 0);
308 close(fd);
309
310 if (map == MAP_FAILED)
311 return NULL;
312 return map;
313 }
314
315 /**
316 * Return a copy of the next line in a mmap'ed file.
317 * spaces in the beginning of the line is trimmed away.
318 * Return a pointer to a static buffer.
319 **/
320 char* get_next_line(unsigned long *pos, void *file, unsigned long size)
321 {
322 static char line[4096];
323 int skip = 1;
324 size_t len = 0;
325 signed char *p = (signed char *)file + *pos;
326 char *s = line;
327
328 for (; *pos < size ; (*pos)++)
329 {
330 if (skip && isspace(*p)) {
331 p++;
332 continue;
333 }
334 skip = 0;
335 if (*p != '\n' && (*pos < size)) {
336 len++;
337 *s++ = *p++;
338 if (len > 4095)
339 break; /* Too long, stop */
340 } else {
341 /* End of string */
342 *s = '\0';
343 return line;
344 }
345 }
346 /* End of buffer */
347 return NULL;
348 }
349
350 void release_file(void *file, unsigned long size)
351 {
352 munmap(file, size);
353 }
354
355 static int parse_elf(struct elf_info *info, const char *filename)
356 {
357 unsigned int i;
358 Elf_Ehdr *hdr;
359 Elf_Shdr *sechdrs;
360 Elf_Sym *sym;
361
362 hdr = grab_file(filename, &info->size);
363 if (!hdr) {
364 perror(filename);
365 exit(1);
366 }
367 info->hdr = hdr;
368 if (info->size < sizeof(*hdr)) {
369 /* file too small, assume this is an empty .o file */
370 return 0;
371 }
372 /* Is this a valid ELF file? */
373 if ((hdr->e_ident[EI_MAG0] != ELFMAG0) ||
374 (hdr->e_ident[EI_MAG1] != ELFMAG1) ||
375 (hdr->e_ident[EI_MAG2] != ELFMAG2) ||
376 (hdr->e_ident[EI_MAG3] != ELFMAG3)) {
377 /* Not an ELF file - silently ignore it */
378 return 0;
379 }
380 /* Fix endianness in ELF header */
381 hdr->e_shoff = TO_NATIVE(hdr->e_shoff);
382 hdr->e_shstrndx = TO_NATIVE(hdr->e_shstrndx);
383 hdr->e_shnum = TO_NATIVE(hdr->e_shnum);
384 hdr->e_machine = TO_NATIVE(hdr->e_machine);
385 hdr->e_type = TO_NATIVE(hdr->e_type);
386 sechdrs = (void *)hdr + hdr->e_shoff;
387 info->sechdrs = sechdrs;
388
389 /* Check if file offset is correct */
390 if (hdr->e_shoff > info->size) {
391 fatal("section header offset=%lu in file '%s' is bigger then filesize=%lu\n", (unsigned long)hdr->e_shoff, filename, info->size);
392 return 0;
393 }
394
395 /* Fix endianness in section headers */
396 for (i = 0; i < hdr->e_shnum; i++) {
397 sechdrs[i].sh_type = TO_NATIVE(sechdrs[i].sh_type);
398 sechdrs[i].sh_offset = TO_NATIVE(sechdrs[i].sh_offset);
399 sechdrs[i].sh_size = TO_NATIVE(sechdrs[i].sh_size);
400 sechdrs[i].sh_link = TO_NATIVE(sechdrs[i].sh_link);
401 sechdrs[i].sh_name = TO_NATIVE(sechdrs[i].sh_name);
402 sechdrs[i].sh_info = TO_NATIVE(sechdrs[i].sh_info);
403 sechdrs[i].sh_addr = TO_NATIVE(sechdrs[i].sh_addr);
404 }
405 /* Find symbol table. */
406 for (i = 1; i < hdr->e_shnum; i++) {
407 const char *secstrings
408 = (void *)hdr + sechdrs[hdr->e_shstrndx].sh_offset;
409 const char *secname;
410
411 if (sechdrs[i].sh_offset > info->size) {
412 fatal("%s is truncated. sechdrs[i].sh_offset=%lu > sizeof(*hrd)=%lu\n", filename, (unsigned long)sechdrs[i].sh_offset, sizeof(*hdr));
413 return 0;
414 }
415 secname = secstrings + sechdrs[i].sh_name;
416 if (strcmp(secname, ".modinfo") == 0) {
417 info->modinfo = (void *)hdr + sechdrs[i].sh_offset;
418 info->modinfo_len = sechdrs[i].sh_size;
419 } else if (strcmp(secname, "__ksymtab") == 0)
420 info->export_sec = i;
421 else if (strcmp(secname, "__ksymtab_unused") == 0)
422 info->export_unused_sec = i;
423 else if (strcmp(secname, "__ksymtab_gpl") == 0)
424 info->export_gpl_sec = i;
425 else if (strcmp(secname, "__ksymtab_unused_gpl") == 0)
426 info->export_unused_gpl_sec = i;
427 else if (strcmp(secname, "__ksymtab_gpl_future") == 0)
428 info->export_gpl_future_sec = i;
429
430 if (sechdrs[i].sh_type != SHT_SYMTAB)
431 continue;
432
433 info->symtab_start = (void *)hdr + sechdrs[i].sh_offset;
434 info->symtab_stop = (void *)hdr + sechdrs[i].sh_offset
435 + sechdrs[i].sh_size;
436 info->strtab = (void *)hdr +
437 sechdrs[sechdrs[i].sh_link].sh_offset;
438 }
439 if (!info->symtab_start) {
440 fatal("%s has no symtab?\n", filename);
441 }
442 /* Fix endianness in symbols */
443 for (sym = info->symtab_start; sym < info->symtab_stop; sym++) {
444 sym->st_shndx = TO_NATIVE(sym->st_shndx);
445 sym->st_name = TO_NATIVE(sym->st_name);
446 sym->st_value = TO_NATIVE(sym->st_value);
447 sym->st_size = TO_NATIVE(sym->st_size);
448 }
449 return 1;
450 }
451
452 static void parse_elf_finish(struct elf_info *info)
453 {
454 release_file(info->hdr, info->size);
455 }
456
457 #define CRC_PFX MODULE_SYMBOL_PREFIX "__crc_"
458 #define KSYMTAB_PFX MODULE_SYMBOL_PREFIX "__ksymtab_"
459
460 static void handle_modversions(struct module *mod, struct elf_info *info,
461 Elf_Sym *sym, const char *symname)
462 {
463 unsigned int crc;
464 enum export export = export_from_sec(info, sym->st_shndx);
465
466 switch (sym->st_shndx) {
467 case SHN_COMMON:
468 warn("\"%s\" [%s] is COMMON symbol\n", symname, mod->name);
469 break;
470 case SHN_ABS:
471 /* CRC'd symbol */
472 if (memcmp(symname, CRC_PFX, strlen(CRC_PFX)) == 0) {
473 crc = (unsigned int) sym->st_value;
474 sym_update_crc(symname + strlen(CRC_PFX), mod, crc,
475 export);
476 }
477 break;
478 case SHN_UNDEF:
479 /* undefined symbol */
480 if (ELF_ST_BIND(sym->st_info) != STB_GLOBAL &&
481 ELF_ST_BIND(sym->st_info) != STB_WEAK)
482 break;
483 /* ignore global offset table */
484 if (strcmp(symname, "_GLOBAL_OFFSET_TABLE_") == 0)
485 break;
486 /* ignore __this_module, it will be resolved shortly */
487 if (strcmp(symname, MODULE_SYMBOL_PREFIX "__this_module") == 0)
488 break;
489 /* cope with newer glibc (2.3.4 or higher) STT_ definition in elf.h */
490 #if defined(STT_REGISTER) || defined(STT_SPARC_REGISTER)
491 /* add compatibility with older glibc */
492 #ifndef STT_SPARC_REGISTER
493 #define STT_SPARC_REGISTER STT_REGISTER
494 #endif
495 if (info->hdr->e_machine == EM_SPARC ||
496 info->hdr->e_machine == EM_SPARCV9) {
497 /* Ignore register directives. */
498 if (ELF_ST_TYPE(sym->st_info) == STT_SPARC_REGISTER)
499 break;
500 if (symname[0] == '.') {
501 char *munged = strdup(symname);
502 munged[0] = '_';
503 munged[1] = toupper(munged[1]);
504 symname = munged;
505 }
506 }
507 #endif
508
509 if (memcmp(symname, MODULE_SYMBOL_PREFIX,
510 strlen(MODULE_SYMBOL_PREFIX)) == 0)
511 mod->unres = alloc_symbol(symname +
512 strlen(MODULE_SYMBOL_PREFIX),
513 ELF_ST_BIND(sym->st_info) == STB_WEAK,
514 mod->unres);
515 break;
516 default:
517 /* All exported symbols */
518 if (memcmp(symname, KSYMTAB_PFX, strlen(KSYMTAB_PFX)) == 0) {
519 sym_add_exported(symname + strlen(KSYMTAB_PFX), mod,
520 export);
521 }
522 if (strcmp(symname, MODULE_SYMBOL_PREFIX "init_module") == 0)
523 mod->has_init = 1;
524 if (strcmp(symname, MODULE_SYMBOL_PREFIX "cleanup_module") == 0)
525 mod->has_cleanup = 1;
526 break;
527 }
528 }
529
530 /**
531 * Parse tag=value strings from .modinfo section
532 **/
533 static char *next_string(char *string, unsigned long *secsize)
534 {
535 /* Skip non-zero chars */
536 while (string[0]) {
537 string++;
538 if ((*secsize)-- <= 1)
539 return NULL;
540 }
541
542 /* Skip any zero padding. */
543 while (!string[0]) {
544 string++;
545 if ((*secsize)-- <= 1)
546 return NULL;
547 }
548 return string;
549 }
550
551 static char *get_next_modinfo(void *modinfo, unsigned long modinfo_len,
552 const char *tag, char *info)
553 {
554 char *p;
555 unsigned int taglen = strlen(tag);
556 unsigned long size = modinfo_len;
557
558 if (info) {
559 size -= info - (char *)modinfo;
560 modinfo = next_string(info, &size);
561 }
562
563 for (p = modinfo; p; p = next_string(p, &size)) {
564 if (strncmp(p, tag, taglen) == 0 && p[taglen] == '=')
565 return p + taglen + 1;
566 }
567 return NULL;
568 }
569
570 static char *get_modinfo(void *modinfo, unsigned long modinfo_len,
571 const char *tag)
572
573 {
574 return get_next_modinfo(modinfo, modinfo_len, tag, NULL);
575 }
576
577 /**
578 * Test if string s ends in string sub
579 * return 0 if match
580 **/
581 static int strrcmp(const char *s, const char *sub)
582 {
583 int slen, sublen;
584
585 if (!s || !sub)
586 return 1;
587
588 slen = strlen(s);
589 sublen = strlen(sub);
590
591 if ((slen == 0) || (sublen == 0))
592 return 1;
593
594 if (sublen > slen)
595 return 1;
596
597 return memcmp(s + slen - sublen, sub, sublen);
598 }
599
600 /*
601 * Functions used only during module init is marked __init and is stored in
602 * a .init.text section. Likewise data is marked __initdata and stored in
603 * a .init.data section.
604 * If this section is one of these sections return 1
605 * See include/linux/init.h for the details
606 */
607 static int init_section(const char *name)
608 {
609 if (strcmp(name, ".init") == 0)
610 return 1;
611 if (strncmp(name, ".init.", strlen(".init.")) == 0)
612 return 1;
613 return 0;
614 }
615
616 /*
617 * Functions used only during module exit is marked __exit and is stored in
618 * a .exit.text section. Likewise data is marked __exitdata and stored in
619 * a .exit.data section.
620 * If this section is one of these sections return 1
621 * See include/linux/init.h for the details
622 **/
623 static int exit_section(const char *name)
624 {
625 if (strcmp(name, ".exit.text") == 0)
626 return 1;
627 if (strcmp(name, ".exit.data") == 0)
628 return 1;
629 return 0;
630
631 }
632
633 /*
634 * Data sections are named like this:
635 * .data | .data.rel | .data.rel.*
636 * Return 1 if the specified section is a data section
637 */
638 static int data_section(const char *name)
639 {
640 if ((strcmp(name, ".data") == 0) ||
641 (strcmp(name, ".data.rel") == 0) ||
642 (strncmp(name, ".data.rel.", strlen(".data.rel.")) == 0))
643 return 1;
644 else
645 return 0;
646 }
647
648 /**
649 * Whitelist to allow certain references to pass with no warning.
650 *
651 * Pattern 0:
652 * Do not warn if funtion/data are marked with __init_refok/__initdata_refok.
653 * The pattern is identified by:
654 * fromsec = .text.init.refok* | .data.init.refok*
655 *
656 * Pattern 1:
657 * If a module parameter is declared __initdata and permissions=0
658 * then this is legal despite the warning generated.
659 * We cannot see value of permissions here, so just ignore
660 * this pattern.
661 * The pattern is identified by:
662 * tosec = .init.data
663 * fromsec = .data*
664 * atsym =__param*
665 *
666 * Pattern 2:
667 * Many drivers utilise a *driver container with references to
668 * add, remove, probe functions etc.
669 * These functions may often be marked __init and we do not want to
670 * warn here.
671 * the pattern is identified by:
672 * tosec = init or exit section
673 * fromsec = data section
674 * atsym = *driver, *_template, *_sht, *_ops, *_probe, *probe_one, *_console, *_timer
675 *
676 * Pattern 3:
677 * Whitelist all refereces from .text.head to .init.data
678 * Whitelist all refereces from .text.head to .init.text
679 *
680 * Pattern 4:
681 * Some symbols belong to init section but still it is ok to reference
682 * these from non-init sections as these symbols don't have any memory
683 * allocated for them and symbol address and value are same. So even
684 * if init section is freed, its ok to reference those symbols.
685 * For ex. symbols marking the init section boundaries.
686 * This pattern is identified by
687 * refsymname = __init_begin, _sinittext, _einittext
688 *
689 * Pattern 5:
690 * Xtensa uses literal sections for constants that are accessed PC-relative.
691 * Literal sections may safely reference their text sections.
692 * (Note that the name for the literal section omits any trailing '.text')
693 * tosec = <section>[.text]
694 * fromsec = <section>.literal
695 **/
696 static int secref_whitelist(const char *modname, const char *tosec,
697 const char *fromsec, const char *atsym,
698 const char *refsymname)
699 {
700 int len;
701 const char **s;
702 const char *pat2sym[] = {
703 "driver",
704 "_template", /* scsi uses *_template a lot */
705 "_timer", /* arm uses ops structures named _timer a lot */
706 "_sht", /* scsi also used *_sht to some extent */
707 "_ops",
708 "_probe",
709 "_probe_one",
710 "_console",
711 NULL
712 };
713
714 const char *pat3refsym[] = {
715 "__init_begin",
716 "_sinittext",
717 "_einittext",
718 NULL
719 };
720
721 /* Check for pattern 0 */
722 if ((strncmp(fromsec, ".text.init.refok", strlen(".text.init.refok")) == 0) ||
723 (strncmp(fromsec, ".exit.text.refok", strlen(".exit.text.refok")) == 0) ||
724 (strncmp(fromsec, ".data.init.refok", strlen(".data.init.refok")) == 0))
725 return 1;
726
727 /* Check for pattern 1 */
728 if ((strcmp(tosec, ".init.data") == 0) &&
729 (strncmp(fromsec, ".data", strlen(".data")) == 0) &&
730 (strncmp(atsym, "__param", strlen("__param")) == 0))
731 return 1;
732
733 /* Check for pattern 2 */
734 if ((init_section(tosec) || exit_section(tosec)) && data_section(fromsec))
735 for (s = pat2sym; *s; s++)
736 if (strrcmp(atsym, *s) == 0)
737 return 1;
738
739 /* Check for pattern 3 */
740 if ((strcmp(fromsec, ".text.head") == 0) &&
741 ((strcmp(tosec, ".init.data") == 0) ||
742 (strcmp(tosec, ".init.text") == 0)))
743 return 1;
744
745 /* Check for pattern 4 */
746 for (s = pat3refsym; *s; s++)
747 if (strcmp(refsymname, *s) == 0)
748 return 1;
749
750 /* Check for pattern 5 */
751 if (strrcmp(tosec, ".text") == 0)
752 len = strlen(tosec) - strlen(".text");
753 else
754 len = strlen(tosec);
755 if ((strncmp(tosec, fromsec, len) == 0) && (strlen(fromsec) > len) &&
756 (strcmp(fromsec + len, ".literal") == 0))
757 return 1;
758
759 return 0;
760 }
761
762 /**
763 * Find symbol based on relocation record info.
764 * In some cases the symbol supplied is a valid symbol so
765 * return refsym. If st_name != 0 we assume this is a valid symbol.
766 * In other cases the symbol needs to be looked up in the symbol table
767 * based on section and address.
768 * **/
769 static Elf_Sym *find_elf_symbol(struct elf_info *elf, Elf_Addr addr,
770 Elf_Sym *relsym)
771 {
772 Elf_Sym *sym;
773
774 if (relsym->st_name != 0)
775 return relsym;
776 for (sym = elf->symtab_start; sym < elf->symtab_stop; sym++) {
777 if (sym->st_shndx != relsym->st_shndx)
778 continue;
779 if (ELF_ST_TYPE(sym->st_info) == STT_SECTION)
780 continue;
781 if (sym->st_value == addr)
782 return sym;
783 }
784 return NULL;
785 }
786
787 static inline int is_arm_mapping_symbol(const char *str)
788 {
789 return str[0] == '$' && strchr("atd", str[1])
790 && (str[2] == '\0' || str[2] == '.');
791 }
792
793 /*
794 * If there's no name there, ignore it; likewise, ignore it if it's
795 * one of the magic symbols emitted used by current ARM tools.
796 *
797 * Otherwise if find_symbols_between() returns those symbols, they'll
798 * fail the whitelist tests and cause lots of false alarms ... fixable
799 * only by merging __exit and __init sections into __text, bloating
800 * the kernel (which is especially evil on embedded platforms).
801 */
802 static inline int is_valid_name(struct elf_info *elf, Elf_Sym *sym)
803 {
804 const char *name = elf->strtab + sym->st_name;
805
806 if (!name || !strlen(name))
807 return 0;
808 return !is_arm_mapping_symbol(name);
809 }
810
811 /*
812 * Find symbols before or equal addr and after addr - in the section sec.
813 * If we find two symbols with equal offset prefer one with a valid name.
814 * The ELF format may have a better way to detect what type of symbol
815 * it is, but this works for now.
816 **/
817 static void find_symbols_between(struct elf_info *elf, Elf_Addr addr,
818 const char *sec,
819 Elf_Sym **before, Elf_Sym **after)
820 {
821 Elf_Sym *sym;
822 Elf_Ehdr *hdr = elf->hdr;
823 Elf_Addr beforediff = ~0;
824 Elf_Addr afterdiff = ~0;
825 const char *secstrings = (void *)hdr +
826 elf->sechdrs[hdr->e_shstrndx].sh_offset;
827
828 *before = NULL;
829 *after = NULL;
830
831 for (sym = elf->symtab_start; sym < elf->symtab_stop; sym++) {
832 const char *symsec;
833
834 if (sym->st_shndx >= SHN_LORESERVE)
835 continue;
836 symsec = secstrings + elf->sechdrs[sym->st_shndx].sh_name;
837 if (strcmp(symsec, sec) != 0)
838 continue;
839 if (!is_valid_name(elf, sym))
840 continue;
841 if (sym->st_value <= addr) {
842 if ((addr - sym->st_value) < beforediff) {
843 beforediff = addr - sym->st_value;
844 *before = sym;
845 }
846 else if ((addr - sym->st_value) == beforediff) {
847 *before = sym;
848 }
849 }
850 else
851 {
852 if ((sym->st_value - addr) < afterdiff) {
853 afterdiff = sym->st_value - addr;
854 *after = sym;
855 }
856 else if ((sym->st_value - addr) == afterdiff) {
857 *after = sym;
858 }
859 }
860 }
861 }
862
863 /**
864 * Print a warning about a section mismatch.
865 * Try to find symbols near it so user can find it.
866 * Check whitelist before warning - it may be a false positive.
867 **/
868 static void warn_sec_mismatch(const char *modname, const char *fromsec,
869 struct elf_info *elf, Elf_Sym *sym, Elf_Rela r)
870 {
871 const char *refsymname = "";
872 Elf_Sym *before, *after;
873 Elf_Sym *refsym;
874 Elf_Ehdr *hdr = elf->hdr;
875 Elf_Shdr *sechdrs = elf->sechdrs;
876 const char *secstrings = (void *)hdr +
877 sechdrs[hdr->e_shstrndx].sh_offset;
878 const char *secname = secstrings + sechdrs[sym->st_shndx].sh_name;
879
880 find_symbols_between(elf, r.r_offset, fromsec, &before, &after);
881
882 refsym = find_elf_symbol(elf, r.r_addend, sym);
883 if (refsym && strlen(elf->strtab + refsym->st_name))
884 refsymname = elf->strtab + refsym->st_name;
885
886 /* check whitelist - we may ignore it */
887 if (secref_whitelist(modname, secname, fromsec,
888 before ? elf->strtab + before->st_name : "",
889 refsymname))
890 return;
891
892 if (before && after) {
893 warn("%s(%s+0x%llx): Section mismatch: reference to %s:%s "
894 "(between '%s' and '%s')\n",
895 modname, fromsec, (unsigned long long)r.r_offset,
896 secname, refsymname,
897 elf->strtab + before->st_name,
898 elf->strtab + after->st_name);
899 } else if (before) {
900 warn("%s(%s+0x%llx): Section mismatch: reference to %s:%s "
901 "(after '%s')\n",
902 modname, fromsec, (unsigned long long)r.r_offset,
903 secname, refsymname,
904 elf->strtab + before->st_name);
905 } else if (after) {
906 warn("%s(%s+0x%llx): Section mismatch: reference to %s:%s "
907 "before '%s' (at offset -0x%llx)\n",
908 modname, fromsec, (unsigned long long)r.r_offset,
909 secname, refsymname,
910 elf->strtab + after->st_name,
911 (unsigned long long)r.r_offset);
912 } else {
913 warn("%s(%s+0x%llx): Section mismatch: reference to %s:%s\n",
914 modname, fromsec, (unsigned long long)r.r_offset,
915 secname, refsymname);
916 }
917 }
918
919 static unsigned int *reloc_location(struct elf_info *elf,
920 int rsection, Elf_Rela *r)
921 {
922 Elf_Shdr *sechdrs = elf->sechdrs;
923 int section = sechdrs[rsection].sh_info;
924
925 return (void *)elf->hdr + sechdrs[section].sh_offset +
926 (r->r_offset - sechdrs[section].sh_addr);
927 }
928
929 static int addend_386_rel(struct elf_info *elf, int rsection, Elf_Rela *r)
930 {
931 unsigned int r_typ = ELF_R_TYPE(r->r_info);
932 unsigned int *location = reloc_location(elf, rsection, r);
933
934 switch (r_typ) {
935 case R_386_32:
936 r->r_addend = TO_NATIVE(*location);
937 break;
938 case R_386_PC32:
939 r->r_addend = TO_NATIVE(*location) + 4;
940 /* For CONFIG_RELOCATABLE=y */
941 if (elf->hdr->e_type == ET_EXEC)
942 r->r_addend += r->r_offset;
943 break;
944 }
945 return 0;
946 }
947
948 static int addend_arm_rel(struct elf_info *elf, int rsection, Elf_Rela *r)
949 {
950 unsigned int r_typ = ELF_R_TYPE(r->r_info);
951
952 switch (r_typ) {
953 case R_ARM_ABS32:
954 /* From ARM ABI: (S + A) | T */
955 r->r_addend = (int)(long)(elf->symtab_start + ELF_R_SYM(r->r_info));
956 break;
957 case R_ARM_PC24:
958 /* From ARM ABI: ((S + A) | T) - P */
959 r->r_addend = (int)(long)(elf->hdr + elf->sechdrs[rsection].sh_offset +
960 (r->r_offset - elf->sechdrs[rsection].sh_addr));
961 break;
962 default:
963 return 1;
964 }
965 return 0;
966 }
967
968 static int addend_mips_rel(struct elf_info *elf, int rsection, Elf_Rela *r)
969 {
970 unsigned int r_typ = ELF_R_TYPE(r->r_info);
971 unsigned int *location = reloc_location(elf, rsection, r);
972 unsigned int inst;
973
974 if (r_typ == R_MIPS_HI16)
975 return 1; /* skip this */
976 inst = TO_NATIVE(*location);
977 switch (r_typ) {
978 case R_MIPS_LO16:
979 r->r_addend = inst & 0xffff;
980 break;
981 case R_MIPS_26:
982 r->r_addend = (inst & 0x03ffffff) << 2;
983 break;
984 case R_MIPS_32:
985 r->r_addend = inst;
986 break;
987 }
988 return 0;
989 }
990
991 /**
992 * A module includes a number of sections that are discarded
993 * either when loaded or when used as built-in.
994 * For loaded modules all functions marked __init and all data
995 * marked __initdata will be discarded when the module has been intialized.
996 * Likewise for modules used built-in the sections marked __exit
997 * are discarded because __exit marked function are supposed to be called
998 * only when a moduel is unloaded which never happes for built-in modules.
999 * The check_sec_ref() function traverses all relocation records
1000 * to find all references to a section that reference a section that will
1001 * be discarded and warns about it.
1002 **/
1003 static void check_sec_ref(struct module *mod, const char *modname,
1004 struct elf_info *elf,
1005 int section(const char*),
1006 int section_ref_ok(const char *))
1007 {
1008 int i;
1009 Elf_Sym *sym;
1010 Elf_Ehdr *hdr = elf->hdr;
1011 Elf_Shdr *sechdrs = elf->sechdrs;
1012 const char *secstrings = (void *)hdr +
1013 sechdrs[hdr->e_shstrndx].sh_offset;
1014
1015 /* Walk through all sections */
1016 for (i = 0; i < hdr->e_shnum; i++) {
1017 const char *name = secstrings + sechdrs[i].sh_name;
1018 const char *secname;
1019 Elf_Rela r;
1020 unsigned int r_sym;
1021 /* We want to process only relocation sections and not .init */
1022 if (sechdrs[i].sh_type == SHT_RELA) {
1023 Elf_Rela *rela;
1024 Elf_Rela *start = (void *)hdr + sechdrs[i].sh_offset;
1025 Elf_Rela *stop = (void*)start + sechdrs[i].sh_size;
1026 name += strlen(".rela");
1027 if (section_ref_ok(name))
1028 continue;
1029
1030 for (rela = start; rela < stop; rela++) {
1031 r.r_offset = TO_NATIVE(rela->r_offset);
1032 #if KERNEL_ELFCLASS == ELFCLASS64
1033 if (hdr->e_machine == EM_MIPS) {
1034 unsigned int r_typ;
1035 r_sym = ELF64_MIPS_R_SYM(rela->r_info);
1036 r_sym = TO_NATIVE(r_sym);
1037 r_typ = ELF64_MIPS_R_TYPE(rela->r_info);
1038 r.r_info = ELF64_R_INFO(r_sym, r_typ);
1039 } else {
1040 r.r_info = TO_NATIVE(rela->r_info);
1041 r_sym = ELF_R_SYM(r.r_info);
1042 }
1043 #else
1044 r.r_info = TO_NATIVE(rela->r_info);
1045 r_sym = ELF_R_SYM(r.r_info);
1046 #endif
1047 r.r_addend = TO_NATIVE(rela->r_addend);
1048 sym = elf->symtab_start + r_sym;
1049 /* Skip special sections */
1050 if (sym->st_shndx >= SHN_LORESERVE)
1051 continue;
1052
1053 secname = secstrings +
1054 sechdrs[sym->st_shndx].sh_name;
1055 if (section(secname))
1056 warn_sec_mismatch(modname, name,
1057 elf, sym, r);
1058 }
1059 } else if (sechdrs[i].sh_type == SHT_REL) {
1060 Elf_Rel *rel;
1061 Elf_Rel *start = (void *)hdr + sechdrs[i].sh_offset;
1062 Elf_Rel *stop = (void*)start + sechdrs[i].sh_size;
1063 name += strlen(".rel");
1064 if (section_ref_ok(name))
1065 continue;
1066
1067 for (rel = start; rel < stop; rel++) {
1068 r.r_offset = TO_NATIVE(rel->r_offset);
1069 #if KERNEL_ELFCLASS == ELFCLASS64
1070 if (hdr->e_machine == EM_MIPS) {
1071 unsigned int r_typ;
1072 r_sym = ELF64_MIPS_R_SYM(rel->r_info);
1073 r_sym = TO_NATIVE(r_sym);
1074 r_typ = ELF64_MIPS_R_TYPE(rel->r_info);
1075 r.r_info = ELF64_R_INFO(r_sym, r_typ);
1076 } else {
1077 r.r_info = TO_NATIVE(rel->r_info);
1078 r_sym = ELF_R_SYM(r.r_info);
1079 }
1080 #else
1081 r.r_info = TO_NATIVE(rel->r_info);
1082 r_sym = ELF_R_SYM(r.r_info);
1083 #endif
1084 r.r_addend = 0;
1085 switch (hdr->e_machine) {
1086 case EM_386:
1087 if (addend_386_rel(elf, i, &r))
1088 continue;
1089 break;
1090 case EM_ARM:
1091 if(addend_arm_rel(elf, i, &r))
1092 continue;
1093 break;
1094 case EM_MIPS:
1095 if (addend_mips_rel(elf, i, &r))
1096 continue;
1097 break;
1098 }
1099 sym = elf->symtab_start + r_sym;
1100 /* Skip special sections */
1101 if (sym->st_shndx >= SHN_LORESERVE)
1102 continue;
1103
1104 secname = secstrings +
1105 sechdrs[sym->st_shndx].sh_name;
1106 if (section(secname))
1107 warn_sec_mismatch(modname, name,
1108 elf, sym, r);
1109 }
1110 }
1111 }
1112 }
1113
1114 /*
1115 * Identify sections from which references to either a
1116 * .init or a .exit section is OK.
1117 *
1118 * [OPD] Keith Ownes <kaos@sgi.com> commented:
1119 * For our future {in}sanity, add a comment that this is the ppc .opd
1120 * section, not the ia64 .opd section.
1121 * ia64 .opd should not point to discarded sections.
1122 * [.rodata] like for .init.text we ignore .rodata references -same reason
1123 */
1124 static int initexit_section_ref_ok(const char *name)
1125 {
1126 const char **s;
1127 /* Absolute section names */
1128 const char *namelist1[] = {
1129 "__bug_table", /* used by powerpc for BUG() */
1130 "__ex_table",
1131 ".altinstructions",
1132 ".cranges", /* used by sh64 */
1133 ".fixup",
1134 ".machvec", /* ia64 + powerpc uses these */
1135 ".machine.desc",
1136 ".opd", /* See comment [OPD] */
1137 "__dbe_table",
1138 ".parainstructions",
1139 ".pdr",
1140 ".plt", /* seen on ARCH=um build on x86_64. Harmless */
1141 ".smp_locks",
1142 ".stab",
1143 ".m68k_fixup",
1144 ".xt.prop", /* xtensa informational section */
1145 ".xt.lit", /* xtensa informational section */
1146 NULL
1147 };
1148 /* Start of section names */
1149 const char *namelist2[] = {
1150 ".debug",
1151 ".eh_frame",
1152 ".note", /* ignore ELF notes - may contain anything */
1153 ".got", /* powerpc - global offset table */
1154 ".toc", /* powerpc - table of contents */
1155 NULL
1156 };
1157 /* part of section name */
1158 const char *namelist3 [] = {
1159 ".unwind", /* Sample: IA_64.unwind.exit.text */
1160 NULL
1161 };
1162
1163 for (s = namelist1; *s; s++)
1164 if (strcmp(*s, name) == 0)
1165 return 1;
1166 for (s = namelist2; *s; s++)
1167 if (strncmp(*s, name, strlen(*s)) == 0)
1168 return 1;
1169 for (s = namelist3; *s; s++)
1170 if (strstr(name, *s) != NULL)
1171 return 1;
1172 return 0;
1173 }
1174
1175
1176 /*
1177 * Identify sections from which references to a .init section is OK.
1178 *
1179 * Unfortunately references to read only data that referenced .init
1180 * sections had to be excluded. Almost all of these are false
1181 * positives, they are created by gcc. The downside of excluding rodata
1182 * is that there really are some user references from rodata to
1183 * init code, e.g. drivers/video/vgacon.c:
1184 *
1185 * const struct consw vga_con = {
1186 * con_startup: vgacon_startup,
1187 *
1188 * where vgacon_startup is __init. If you want to wade through the false
1189 * positives, take out the check for rodata.
1190 */
1191 static int init_section_ref_ok(const char *name)
1192 {
1193 const char **s;
1194 /* Absolute section names */
1195 const char *namelist1[] = {
1196 "__dbe_table", /* MIPS generate these */
1197 "__ftr_fixup", /* powerpc cpu feature fixup */
1198 "__fw_ftr_fixup", /* powerpc firmware feature fixup */
1199 "__param",
1200 ".data.rel.ro", /* used by parisc64 */
1201 ".init",
1202 ".text.lock",
1203 NULL
1204 };
1205 /* Start of section names */
1206 const char *namelist2[] = {
1207 ".init.",
1208 ".pci_fixup",
1209 ".rodata",
1210 NULL
1211 };
1212
1213 if (initexit_section_ref_ok(name))
1214 return 1;
1215
1216 for (s = namelist1; *s; s++)
1217 if (strcmp(*s, name) == 0)
1218 return 1;
1219 for (s = namelist2; *s; s++)
1220 if (strncmp(*s, name, strlen(*s)) == 0)
1221 return 1;
1222
1223 /* If section name ends with ".init" we allow references
1224 * as is the case with .initcallN.init, .early_param.init, .taglist.init etc
1225 */
1226 if (strrcmp(name, ".init") == 0)
1227 return 1;
1228 return 0;
1229 }
1230
1231 /*
1232 * Identify sections from which references to a .exit section is OK.
1233 */
1234 static int exit_section_ref_ok(const char *name)
1235 {
1236 const char **s;
1237 /* Absolute section names */
1238 const char *namelist1[] = {
1239 ".exit.data",
1240 ".exit.text",
1241 ".exitcall.exit",
1242 ".rodata",
1243 NULL
1244 };
1245
1246 if (initexit_section_ref_ok(name))
1247 return 1;
1248
1249 for (s = namelist1; *s; s++)
1250 if (strcmp(*s, name) == 0)
1251 return 1;
1252 return 0;
1253 }
1254
1255 static void read_symbols(char *modname)
1256 {
1257 const char *symname;
1258 char *version;
1259 char *license;
1260 struct module *mod;
1261 struct elf_info info = { };
1262 Elf_Sym *sym;
1263
1264 if (!parse_elf(&info, modname))
1265 return;
1266
1267 mod = new_module(modname);
1268
1269 /* When there's no vmlinux, don't print warnings about
1270 * unresolved symbols (since there'll be too many ;) */
1271 if (is_vmlinux(modname)) {
1272 have_vmlinux = 1;
1273 mod->skip = 1;
1274 }
1275
1276 license = get_modinfo(info.modinfo, info.modinfo_len, "license");
1277 while (license) {
1278 if (license_is_gpl_compatible(license))
1279 mod->gpl_compatible = 1;
1280 else {
1281 mod->gpl_compatible = 0;
1282 break;
1283 }
1284 license = get_next_modinfo(info.modinfo, info.modinfo_len,
1285 "license", license);
1286 }
1287
1288 for (sym = info.symtab_start; sym < info.symtab_stop; sym++) {
1289 symname = info.strtab + sym->st_name;
1290
1291 handle_modversions(mod, &info, sym, symname);
1292 handle_moddevtable(mod, &info, sym, symname);
1293 }
1294 if (is_vmlinux(modname) && vmlinux_section_warnings) {
1295 check_sec_ref(mod, modname, &info, init_section, init_section_ref_ok);
1296 check_sec_ref(mod, modname, &info, exit_section, exit_section_ref_ok);
1297 }
1298
1299 version = get_modinfo(info.modinfo, info.modinfo_len, "version");
1300 if (version)
1301 maybe_frob_rcs_version(modname, version, info.modinfo,
1302 version - (char *)info.hdr);
1303 if (version || (all_versions && !is_vmlinux(modname)))
1304 get_src_version(modname, mod->srcversion,
1305 sizeof(mod->srcversion)-1);
1306
1307 parse_elf_finish(&info);
1308
1309 /* Our trick to get versioning for struct_module - it's
1310 * never passed as an argument to an exported function, so
1311 * the automatic versioning doesn't pick it up, but it's really
1312 * important anyhow */
1313 if (modversions)
1314 mod->unres = alloc_symbol("struct_module", 0, mod->unres);
1315 }
1316
1317 #define SZ 500
1318
1319 /* We first write the generated file into memory using the
1320 * following helper, then compare to the file on disk and
1321 * only update the later if anything changed */
1322
1323 void __attribute__((format(printf, 2, 3))) buf_printf(struct buffer *buf,
1324 const char *fmt, ...)
1325 {
1326 char tmp[SZ];
1327 int len;
1328 va_list ap;
1329
1330 va_start(ap, fmt);
1331 len = vsnprintf(tmp, SZ, fmt, ap);
1332 buf_write(buf, tmp, len);
1333 va_end(ap);
1334 }
1335
1336 void buf_write(struct buffer *buf, const char *s, int len)
1337 {
1338 if (buf->size - buf->pos < len) {
1339 buf->size += len + SZ;
1340 buf->p = realloc(buf->p, buf->size);
1341 }
1342 strncpy(buf->p + buf->pos, s, len);
1343 buf->pos += len;
1344 }
1345
1346 static void check_for_gpl_usage(enum export exp, const char *m, const char *s)
1347 {
1348 const char *e = is_vmlinux(m) ?"":".ko";
1349
1350 switch (exp) {
1351 case export_gpl:
1352 fatal("modpost: GPL-incompatible module %s%s "
1353 "uses GPL-only symbol '%s'\n", m, e, s);
1354 break;
1355 case export_unused_gpl:
1356 fatal("modpost: GPL-incompatible module %s%s "
1357 "uses GPL-only symbol marked UNUSED '%s'\n", m, e, s);
1358 break;
1359 case export_gpl_future:
1360 warn("modpost: GPL-incompatible module %s%s "
1361 "uses future GPL-only symbol '%s'\n", m, e, s);
1362 break;
1363 case export_plain:
1364 case export_unused:
1365 case export_unknown:
1366 /* ignore */
1367 break;
1368 }
1369 }
1370
1371 static void check_for_unused(enum export exp, const char* m, const char* s)
1372 {
1373 const char *e = is_vmlinux(m) ?"":".ko";
1374
1375 switch (exp) {
1376 case export_unused:
1377 case export_unused_gpl:
1378 warn("modpost: module %s%s "
1379 "uses symbol '%s' marked UNUSED\n", m, e, s);
1380 break;
1381 default:
1382 /* ignore */
1383 break;
1384 }
1385 }
1386
1387 static void check_exports(struct module *mod)
1388 {
1389 struct symbol *s, *exp;
1390
1391 for (s = mod->unres; s; s = s->next) {
1392 const char *basename;
1393 exp = find_symbol(s->name);
1394 if (!exp || exp->module == mod)
1395 continue;
1396 basename = strrchr(mod->name, '/');
1397 if (basename)
1398 basename++;
1399 else
1400 basename = mod->name;
1401 if (!mod->gpl_compatible)
1402 check_for_gpl_usage(exp->export, basename, exp->name);
1403 check_for_unused(exp->export, basename, exp->name);
1404 }
1405 }
1406
1407 /**
1408 * Header for the generated file
1409 **/
1410 static void add_header(struct buffer *b, struct module *mod)
1411 {
1412 buf_printf(b, "#include <linux/module.h>\n");
1413 buf_printf(b, "#include <linux/vermagic.h>\n");
1414 buf_printf(b, "#include <linux/compiler.h>\n");
1415 buf_printf(b, "\n");
1416 buf_printf(b, "MODULE_INFO(vermagic, VERMAGIC_STRING);\n");
1417 buf_printf(b, "\n");
1418 buf_printf(b, "struct module __this_module\n");
1419 buf_printf(b, "__attribute__((section(\".gnu.linkonce.this_module\"))) = {\n");
1420 buf_printf(b, " .name = KBUILD_MODNAME,\n");
1421 if (mod->has_init)
1422 buf_printf(b, " .init = init_module,\n");
1423 if (mod->has_cleanup)
1424 buf_printf(b, "#ifdef CONFIG_MODULE_UNLOAD\n"
1425 " .exit = cleanup_module,\n"
1426 "#endif\n");
1427 buf_printf(b, " .arch = MODULE_ARCH_INIT,\n");
1428 buf_printf(b, "};\n");
1429 }
1430
1431 /**
1432 * Record CRCs for unresolved symbols
1433 **/
1434 static int add_versions(struct buffer *b, struct module *mod)
1435 {
1436 struct symbol *s, *exp;
1437 int err = 0;
1438
1439 for (s = mod->unres; s; s = s->next) {
1440 exp = find_symbol(s->name);
1441 if (!exp || exp->module == mod) {
1442 if (have_vmlinux && !s->weak) {
1443 if (warn_unresolved) {
1444 warn("\"%s\" [%s.ko] undefined!\n",
1445 s->name, mod->name);
1446 } else {
1447 merror("\"%s\" [%s.ko] undefined!\n",
1448 s->name, mod->name);
1449 err = 1;
1450 }
1451 }
1452 continue;
1453 }
1454 s->module = exp->module;
1455 s->crc_valid = exp->crc_valid;
1456 s->crc = exp->crc;
1457 }
1458
1459 if (!modversions)
1460 return err;
1461
1462 buf_printf(b, "\n");
1463 buf_printf(b, "static const struct modversion_info ____versions[]\n");
1464 buf_printf(b, "__attribute_used__\n");
1465 buf_printf(b, "__attribute__((section(\"__versions\"))) = {\n");
1466
1467 for (s = mod->unres; s; s = s->next) {
1468 if (!s->module) {
1469 continue;
1470 }
1471 if (!s->crc_valid) {
1472 warn("\"%s\" [%s.ko] has no CRC!\n",
1473 s->name, mod->name);
1474 continue;
1475 }
1476 buf_printf(b, "\t{ %#8x, \"%s\" },\n", s->crc, s->name);
1477 }
1478
1479 buf_printf(b, "};\n");
1480
1481 return err;
1482 }
1483
1484 static void add_depends(struct buffer *b, struct module *mod,
1485 struct module *modules)
1486 {
1487 struct symbol *s;
1488 struct module *m;
1489 int first = 1;
1490
1491 for (m = modules; m; m = m->next) {
1492 m->seen = is_vmlinux(m->name);
1493 }
1494
1495 buf_printf(b, "\n");
1496 buf_printf(b, "static const char __module_depends[]\n");
1497 buf_printf(b, "__attribute_used__\n");
1498 buf_printf(b, "__attribute__((section(\".modinfo\"))) =\n");
1499 buf_printf(b, "\"depends=");
1500 for (s = mod->unres; s; s = s->next) {
1501 const char *p;
1502 if (!s->module)
1503 continue;
1504
1505 if (s->module->seen)
1506 continue;
1507
1508 s->module->seen = 1;
1509 if ((p = strrchr(s->module->name, '/')) != NULL)
1510 p++;
1511 else
1512 p = s->module->name;
1513 buf_printf(b, "%s%s", first ? "" : ",", p);
1514 first = 0;
1515 }
1516 buf_printf(b, "\";\n");
1517 }
1518
1519 static void add_srcversion(struct buffer *b, struct module *mod)
1520 {
1521 if (mod->srcversion[0]) {
1522 buf_printf(b, "\n");
1523 buf_printf(b, "MODULE_INFO(srcversion, \"%s\");\n",
1524 mod->srcversion);
1525 }
1526 }
1527
1528 static void write_if_changed(struct buffer *b, const char *fname)
1529 {
1530 char *tmp;
1531 FILE *file;
1532 struct stat st;
1533
1534 file = fopen(fname, "r");
1535 if (!file)
1536 goto write;
1537
1538 if (fstat(fileno(file), &st) < 0)
1539 goto close_write;
1540
1541 if (st.st_size != b->pos)
1542 goto close_write;
1543
1544 tmp = NOFAIL(malloc(b->pos));
1545 if (fread(tmp, 1, b->pos, file) != b->pos)
1546 goto free_write;
1547
1548 if (memcmp(tmp, b->p, b->pos) != 0)
1549 goto free_write;
1550
1551 free(tmp);
1552 fclose(file);
1553 return;
1554
1555 free_write:
1556 free(tmp);
1557 close_write:
1558 fclose(file);
1559 write:
1560 file = fopen(fname, "w");
1561 if (!file) {
1562 perror(fname);
1563 exit(1);
1564 }
1565 if (fwrite(b->p, 1, b->pos, file) != b->pos) {
1566 perror(fname);
1567 exit(1);
1568 }
1569 fclose(file);
1570 }
1571
1572 /* parse Module.symvers file. line format:
1573 * 0x12345678<tab>symbol<tab>module[[<tab>export]<tab>something]
1574 **/
1575 static void read_dump(const char *fname, unsigned int kernel)
1576 {
1577 unsigned long size, pos = 0;
1578 void *file = grab_file(fname, &size);
1579 char *line;
1580
1581 if (!file)
1582 /* No symbol versions, silently ignore */
1583 return;
1584
1585 while ((line = get_next_line(&pos, file, size))) {
1586 char *symname, *modname, *d, *export, *end;
1587 unsigned int crc;
1588 struct module *mod;
1589 struct symbol *s;
1590
1591 if (!(symname = strchr(line, '\t')))
1592 goto fail;
1593 *symname++ = '\0';
1594 if (!(modname = strchr(symname, '\t')))
1595 goto fail;
1596 *modname++ = '\0';
1597 if ((export = strchr(modname, '\t')) != NULL)
1598 *export++ = '\0';
1599 if (export && ((end = strchr(export, '\t')) != NULL))
1600 *end = '\0';
1601 crc = strtoul(line, &d, 16);
1602 if (*symname == '\0' || *modname == '\0' || *d != '\0')
1603 goto fail;
1604
1605 if (!(mod = find_module(modname))) {
1606 if (is_vmlinux(modname)) {
1607 have_vmlinux = 1;
1608 }
1609 mod = new_module(NOFAIL(strdup(modname)));
1610 mod->skip = 1;
1611 }
1612 s = sym_add_exported(symname, mod, export_no(export));
1613 s->kernel = kernel;
1614 s->preloaded = 1;
1615 sym_update_crc(symname, mod, crc, export_no(export));
1616 }
1617 return;
1618 fail:
1619 fatal("parse error in symbol dump file\n");
1620 }
1621
1622 /* For normal builds always dump all symbols.
1623 * For external modules only dump symbols
1624 * that are not read from kernel Module.symvers.
1625 **/
1626 static int dump_sym(struct symbol *sym)
1627 {
1628 if (!external_module)
1629 return 1;
1630 if (sym->vmlinux || sym->kernel)
1631 return 0;
1632 return 1;
1633 }
1634
1635 static void write_dump(const char *fname)
1636 {
1637 struct buffer buf = { };
1638 struct symbol *symbol;
1639 int n;
1640
1641 for (n = 0; n < SYMBOL_HASH_SIZE ; n++) {
1642 symbol = symbolhash[n];
1643 while (symbol) {
1644 if (dump_sym(symbol))
1645 buf_printf(&buf, "0x%08x\t%s\t%s\t%s\n",
1646 symbol->crc, symbol->name,
1647 symbol->module->name,
1648 export_str(symbol->export));
1649 symbol = symbol->next;
1650 }
1651 }
1652 write_if_changed(&buf, fname);
1653 }
1654
1655 int main(int argc, char **argv)
1656 {
1657 struct module *mod;
1658 struct buffer buf = { };
1659 char *kernel_read = NULL, *module_read = NULL;
1660 char *dump_write = NULL;
1661 int opt;
1662 int err;
1663
1664 while ((opt = getopt(argc, argv, "i:I:mso:aw")) != -1) {
1665 switch(opt) {
1666 case 'i':
1667 kernel_read = optarg;
1668 break;
1669 case 'I':
1670 module_read = optarg;
1671 external_module = 1;
1672 break;
1673 case 'm':
1674 modversions = 1;
1675 break;
1676 case 'o':
1677 dump_write = optarg;
1678 break;
1679 case 'a':
1680 all_versions = 1;
1681 break;
1682 case 's':
1683 vmlinux_section_warnings = 0;
1684 break;
1685 case 'w':
1686 warn_unresolved = 1;
1687 break;
1688 default:
1689 exit(1);
1690 }
1691 }
1692
1693 if (kernel_read)
1694 read_dump(kernel_read, 1);
1695 if (module_read)
1696 read_dump(module_read, 0);
1697
1698 while (optind < argc) {
1699 read_symbols(argv[optind++]);
1700 }
1701
1702 for (mod = modules; mod; mod = mod->next) {
1703 if (mod->skip)
1704 continue;
1705 check_exports(mod);
1706 }
1707
1708 err = 0;
1709
1710 for (mod = modules; mod; mod = mod->next) {
1711 char fname[strlen(mod->name) + 10];
1712
1713 if (mod->skip)
1714 continue;
1715
1716 buf.pos = 0;
1717
1718 add_header(&buf, mod);
1719 err |= add_versions(&buf, mod);
1720 add_depends(&buf, mod, modules);
1721 add_moddevtable(&buf, mod);
1722 add_srcversion(&buf, mod);
1723
1724 sprintf(fname, "%s.mod.c", mod->name);
1725 write_if_changed(&buf, fname);
1726 }
1727
1728 if (dump_write)
1729 write_dump(dump_write);
1730
1731 return err;
1732 }
Support for the Chinese Samsung S3C2440 based development boards