?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
kbuild: declare the modpost error functions as printf like
[linux-2.6/libata-dev.git] / scripts / mod / modpost.c
blob3a12c22cc2f8f0ca82f624a50c4878fce389e7bb
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=%u in file '%s' is bigger then filesize=%lu\n", 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=%u > sizeof(*hrd)=%ul\n", filename, (unsigned int)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 } else {
912 warn("%s(%s+0x%llx): Section mismatch: reference to %s:%s\n",
913 modname, fromsec, (unsigned long long)r.r_offset,
914 secname, refsymname);
915 }
916 }
917
918 static unsigned int *reloc_location(struct elf_info *elf,
919 int rsection, Elf_Rela *r)
920 {
921 Elf_Shdr *sechdrs = elf->sechdrs;
922 int section = sechdrs[rsection].sh_info;
923
924 return (void *)elf->hdr + sechdrs[section].sh_offset +
925 (r->r_offset - sechdrs[section].sh_addr);
926 }
927
928 static int addend_386_rel(struct elf_info *elf, int rsection, Elf_Rela *r)
929 {
930 unsigned int r_typ = ELF_R_TYPE(r->r_info);
931 unsigned int *location = reloc_location(elf, rsection, r);
932
933 switch (r_typ) {
934 case R_386_32:
935 r->r_addend = TO_NATIVE(*location);
936 break;
937 case R_386_PC32:
938 r->r_addend = TO_NATIVE(*location) + 4;
939 /* For CONFIG_RELOCATABLE=y */
940 if (elf->hdr->e_type == ET_EXEC)
941 r->r_addend += r->r_offset;
942 break;
943 }
944 return 0;
945 }
946
947 static int addend_arm_rel(struct elf_info *elf, int rsection, Elf_Rela *r)
948 {
949 unsigned int r_typ = ELF_R_TYPE(r->r_info);
950
951 switch (r_typ) {
952 case R_ARM_ABS32:
953 /* From ARM ABI: (S + A) | T */
954 r->r_addend = (int)(long)(elf->symtab_start + ELF_R_SYM(r->r_info));
955 break;
956 case R_ARM_PC24:
957 /* From ARM ABI: ((S + A) | T) - P */
958 r->r_addend = (int)(long)(elf->hdr + elf->sechdrs[rsection].sh_offset +
959 (r->r_offset - elf->sechdrs[rsection].sh_addr));
960 break;
961 default:
962 return 1;
963 }
964 return 0;
965 }
966
967 static int addend_mips_rel(struct elf_info *elf, int rsection, Elf_Rela *r)
968 {
969 unsigned int r_typ = ELF_R_TYPE(r->r_info);
970 unsigned int *location = reloc_location(elf, rsection, r);
971 unsigned int inst;
972
973 if (r_typ == R_MIPS_HI16)
974 return 1; /* skip this */
975 inst = TO_NATIVE(*location);
976 switch (r_typ) {
977 case R_MIPS_LO16:
978 r->r_addend = inst & 0xffff;
979 break;
980 case R_MIPS_26:
981 r->r_addend = (inst & 0x03ffffff) << 2;
982 break;
983 case R_MIPS_32:
984 r->r_addend = inst;
985 break;
986 }
987 return 0;
988 }
989
990 /**
991 * A module includes a number of sections that are discarded
992 * either when loaded or when used as built-in.
993 * For loaded modules all functions marked __init and all data
994 * marked __initdata will be discarded when the module has been intialized.
995 * Likewise for modules used built-in the sections marked __exit
996 * are discarded because __exit marked function are supposed to be called
997 * only when a moduel is unloaded which never happes for built-in modules.
998 * The check_sec_ref() function traverses all relocation records
999 * to find all references to a section that reference a section that will
1000 * be discarded and warns about it.
1001 **/
1002 static void check_sec_ref(struct module *mod, const char *modname,
1003 struct elf_info *elf,
1004 int section(const char*),
1005 int section_ref_ok(const char *))
1006 {
1007 int i;
1008 Elf_Sym *sym;
1009 Elf_Ehdr *hdr = elf->hdr;
1010 Elf_Shdr *sechdrs = elf->sechdrs;
1011 const char *secstrings = (void *)hdr +
1012 sechdrs[hdr->e_shstrndx].sh_offset;
1013
1014 /* Walk through all sections */
1015 for (i = 0; i < hdr->e_shnum; i++) {
1016 const char *name = secstrings + sechdrs[i].sh_name;
1017 const char *secname;
1018 Elf_Rela r;
1019 unsigned int r_sym;
1020 /* We want to process only relocation sections and not .init */
1021 if (sechdrs[i].sh_type == SHT_RELA) {
1022 Elf_Rela *rela;
1023 Elf_Rela *start = (void *)hdr + sechdrs[i].sh_offset;
1024 Elf_Rela *stop = (void*)start + sechdrs[i].sh_size;
1025 name += strlen(".rela");
1026 if (section_ref_ok(name))
1027 continue;
1028
1029 for (rela = start; rela < stop; rela++) {
1030 r.r_offset = TO_NATIVE(rela->r_offset);
1031 #if KERNEL_ELFCLASS == ELFCLASS64
1032 if (hdr->e_machine == EM_MIPS) {
1033 unsigned int r_typ;
1034 r_sym = ELF64_MIPS_R_SYM(rela->r_info);
1035 r_sym = TO_NATIVE(r_sym);
1036 r_typ = ELF64_MIPS_R_TYPE(rela->r_info);
1037 r.r_info = ELF64_R_INFO(r_sym, r_typ);
1038 } else {
1039 r.r_info = TO_NATIVE(rela->r_info);
1040 r_sym = ELF_R_SYM(r.r_info);
1041 }
1042 #else
1043 r.r_info = TO_NATIVE(rela->r_info);
1044 r_sym = ELF_R_SYM(r.r_info);
1045 #endif
1046 r.r_addend = TO_NATIVE(rela->r_addend);
1047 sym = elf->symtab_start + r_sym;
1048 /* Skip special sections */
1049 if (sym->st_shndx >= SHN_LORESERVE)
1050 continue;
1051
1052 secname = secstrings +
1053 sechdrs[sym->st_shndx].sh_name;
1054 if (section(secname))
1055 warn_sec_mismatch(modname, name,
1056 elf, sym, r);
1057 }
1058 } else if (sechdrs[i].sh_type == SHT_REL) {
1059 Elf_Rel *rel;
1060 Elf_Rel *start = (void *)hdr + sechdrs[i].sh_offset;
1061 Elf_Rel *stop = (void*)start + sechdrs[i].sh_size;
1062 name += strlen(".rel");
1063 if (section_ref_ok(name))
1064 continue;
1065
1066 for (rel = start; rel < stop; rel++) {
1067 r.r_offset = TO_NATIVE(rel->r_offset);
1068 #if KERNEL_ELFCLASS == ELFCLASS64
1069 if (hdr->e_machine == EM_MIPS) {
1070 unsigned int r_typ;
1071 r_sym = ELF64_MIPS_R_SYM(rel->r_info);
1072 r_sym = TO_NATIVE(r_sym);
1073 r_typ = ELF64_MIPS_R_TYPE(rel->r_info);
1074 r.r_info = ELF64_R_INFO(r_sym, r_typ);
1075 } else {
1076 r.r_info = TO_NATIVE(rel->r_info);
1077 r_sym = ELF_R_SYM(r.r_info);
1078 }
1079 #else
1080 r.r_info = TO_NATIVE(rel->r_info);
1081 r_sym = ELF_R_SYM(r.r_info);
1082 #endif
1083 r.r_addend = 0;
1084 switch (hdr->e_machine) {
1085 case EM_386:
1086 if (addend_386_rel(elf, i, &r))
1087 continue;
1088 break;
1089 case EM_ARM:
1090 if(addend_arm_rel(elf, i, &r))
1091 continue;
1092 break;
1093 case EM_MIPS:
1094 if (addend_mips_rel(elf, i, &r))
1095 continue;
1096 break;
1097 }
1098 sym = elf->symtab_start + r_sym;
1099 /* Skip special sections */
1100 if (sym->st_shndx >= SHN_LORESERVE)
1101 continue;
1102
1103 secname = secstrings +
1104 sechdrs[sym->st_shndx].sh_name;
1105 if (section(secname))
1106 warn_sec_mismatch(modname, name,
1107 elf, sym, r);
1108 }
1109 }
1110 }
1111 }
1112
1113 /*
1114 * Identify sections from which references to either a
1115 * .init or a .exit section is OK.
1116 *
1117 * [OPD] Keith Ownes <kaos@sgi.com> commented:
1118 * For our future {in}sanity, add a comment that this is the ppc .opd
1119 * section, not the ia64 .opd section.
1120 * ia64 .opd should not point to discarded sections.
1121 * [.rodata] like for .init.text we ignore .rodata references -same reason
1122 */
1123 static int initexit_section_ref_ok(const char *name)
1124 {
1125 const char **s;
1126 /* Absolute section names */
1127 const char *namelist1[] = {
1128 "__bug_table", /* used by powerpc for BUG() */
1129 "__ex_table",
1130 ".altinstructions",
1131 ".cranges", /* used by sh64 */
1132 ".fixup",
1133 ".machvec", /* ia64 + powerpc uses these */
1134 ".machine.desc",
1135 ".opd", /* See comment [OPD] */
1136 "__dbe_table",
1137 ".parainstructions",
1138 ".pdr",
1139 ".plt", /* seen on ARCH=um build on x86_64. Harmless */
1140 ".smp_locks",
1141 ".stab",
1142 ".m68k_fixup",
1143 ".xt.prop", /* xtensa informational section */
1144 ".xt.lit", /* xtensa informational section */
1145 NULL
1146 };
1147 /* Start of section names */
1148 const char *namelist2[] = {
1149 ".debug",
1150 ".eh_frame",
1151 ".note", /* ignore ELF notes - may contain anything */
1152 ".got", /* powerpc - global offset table */
1153 ".toc", /* powerpc - table of contents */
1154 NULL
1155 };
1156 /* part of section name */
1157 const char *namelist3 [] = {
1158 ".unwind", /* Sample: IA_64.unwind.exit.text */
1159 NULL
1160 };
1161
1162 for (s = namelist1; *s; s++)
1163 if (strcmp(*s, name) == 0)
1164 return 1;
1165 for (s = namelist2; *s; s++)
1166 if (strncmp(*s, name, strlen(*s)) == 0)
1167 return 1;
1168 for (s = namelist3; *s; s++)
1169 if (strstr(name, *s) != NULL)
1170 return 1;
1171 return 0;
1172 }
1173
1174
1175 /*
1176 * Identify sections from which references to a .init section is OK.
1177 *
1178 * Unfortunately references to read only data that referenced .init
1179 * sections had to be excluded. Almost all of these are false
1180 * positives, they are created by gcc. The downside of excluding rodata
1181 * is that there really are some user references from rodata to
1182 * init code, e.g. drivers/video/vgacon.c:
1183 *
1184 * const struct consw vga_con = {
1185 * con_startup: vgacon_startup,
1186 *
1187 * where vgacon_startup is __init. If you want to wade through the false
1188 * positives, take out the check for rodata.
1189 */
1190 static int init_section_ref_ok(const char *name)
1191 {
1192 const char **s;
1193 /* Absolute section names */
1194 const char *namelist1[] = {
1195 "__dbe_table", /* MIPS generate these */
1196 "__ftr_fixup", /* powerpc cpu feature fixup */
1197 "__fw_ftr_fixup", /* powerpc firmware feature fixup */
1198 "__param",
1199 ".data.rel.ro", /* used by parisc64 */
1200 ".init",
1201 ".text.lock",
1202 NULL
1203 };
1204 /* Start of section names */
1205 const char *namelist2[] = {
1206 ".init.",
1207 ".pci_fixup",
1208 ".rodata",
1209 NULL
1210 };
1211
1212 if (initexit_section_ref_ok(name))
1213 return 1;
1214
1215 for (s = namelist1; *s; s++)
1216 if (strcmp(*s, name) == 0)
1217 return 1;
1218 for (s = namelist2; *s; s++)
1219 if (strncmp(*s, name, strlen(*s)) == 0)
1220 return 1;
1221
1222 /* If section name ends with ".init" we allow references
1223 * as is the case with .initcallN.init, .early_param.init, .taglist.init etc
1224 */
1225 if (strrcmp(name, ".init") == 0)
1226 return 1;
1227 return 0;
1228 }
1229
1230 /*
1231 * Identify sections from which references to a .exit section is OK.
1232 */
1233 static int exit_section_ref_ok(const char *name)
1234 {
1235 const char **s;
1236 /* Absolute section names */
1237 const char *namelist1[] = {
1238 ".exit.data",
1239 ".exit.text",
1240 ".exitcall.exit",
1241 ".rodata",
1242 NULL
1243 };
1244
1245 if (initexit_section_ref_ok(name))
1246 return 1;
1247
1248 for (s = namelist1; *s; s++)
1249 if (strcmp(*s, name) == 0)
1250 return 1;
1251 return 0;
1252 }
1253
1254 static void read_symbols(char *modname)
1255 {
1256 const char *symname;
1257 char *version;
1258 char *license;
1259 struct module *mod;
1260 struct elf_info info = { };
1261 Elf_Sym *sym;
1262
1263 if (!parse_elf(&info, modname))
1264 return;
1265
1266 mod = new_module(modname);
1267
1268 /* When there's no vmlinux, don't print warnings about
1269 * unresolved symbols (since there'll be too many ;) */
1270 if (is_vmlinux(modname)) {
1271 have_vmlinux = 1;
1272 mod->skip = 1;
1273 }
1274
1275 license = get_modinfo(info.modinfo, info.modinfo_len, "license");
1276 while (license) {
1277 if (license_is_gpl_compatible(license))
1278 mod->gpl_compatible = 1;
1279 else {
1280 mod->gpl_compatible = 0;
1281 break;
1282 }
1283 license = get_next_modinfo(info.modinfo, info.modinfo_len,
1284 "license", license);
1285 }
1286
1287 for (sym = info.symtab_start; sym < info.symtab_stop; sym++) {
1288 symname = info.strtab + sym->st_name;
1289
1290 handle_modversions(mod, &info, sym, symname);
1291 handle_moddevtable(mod, &info, sym, symname);
1292 }
1293 if (is_vmlinux(modname) && vmlinux_section_warnings) {
1294 check_sec_ref(mod, modname, &info, init_section, init_section_ref_ok);
1295 check_sec_ref(mod, modname, &info, exit_section, exit_section_ref_ok);
1296 }
1297
1298 version = get_modinfo(info.modinfo, info.modinfo_len, "version");
1299 if (version)
1300 maybe_frob_rcs_version(modname, version, info.modinfo,
1301 version - (char *)info.hdr);
1302 if (version || (all_versions && !is_vmlinux(modname)))
1303 get_src_version(modname, mod->srcversion,
1304 sizeof(mod->srcversion)-1);
1305
1306 parse_elf_finish(&info);
1307
1308 /* Our trick to get versioning for struct_module - it's
1309 * never passed as an argument to an exported function, so
1310 * the automatic versioning doesn't pick it up, but it's really
1311 * important anyhow */
1312 if (modversions)
1313 mod->unres = alloc_symbol("struct_module", 0, mod->unres);
1314 }
1315
1316 #define SZ 500
1317
1318 /* We first write the generated file into memory using the
1319 * following helper, then compare to the file on disk and
1320 * only update the later if anything changed */
1321
1322 void __attribute__((format(printf, 2, 3))) buf_printf(struct buffer *buf,
1323 const char *fmt, ...)
1324 {
1325 char tmp[SZ];
1326 int len;
1327 va_list ap;
1328
1329 va_start(ap, fmt);
1330 len = vsnprintf(tmp, SZ, fmt, ap);
1331 buf_write(buf, tmp, len);
1332 va_end(ap);
1333 }
1334
1335 void buf_write(struct buffer *buf, const char *s, int len)
1336 {
1337 if (buf->size - buf->pos < len) {
1338 buf->size += len + SZ;
1339 buf->p = realloc(buf->p, buf->size);
1340 }
1341 strncpy(buf->p + buf->pos, s, len);
1342 buf->pos += len;
1343 }
1344
1345 static void check_for_gpl_usage(enum export exp, const char *m, const char *s)
1346 {
1347 const char *e = is_vmlinux(m) ?"":".ko";
1348
1349 switch (exp) {
1350 case export_gpl:
1351 fatal("modpost: GPL-incompatible module %s%s "
1352 "uses GPL-only symbol '%s'\n", m, e, s);
1353 break;
1354 case export_unused_gpl:
1355 fatal("modpost: GPL-incompatible module %s%s "
1356 "uses GPL-only symbol marked UNUSED '%s'\n", m, e, s);
1357 break;
1358 case export_gpl_future:
1359 warn("modpost: GPL-incompatible module %s%s "
1360 "uses future GPL-only symbol '%s'\n", m, e, s);
1361 break;
1362 case export_plain:
1363 case export_unused:
1364 case export_unknown:
1365 /* ignore */
1366 break;
1367 }
1368 }
1369
1370 static void check_for_unused(enum export exp, const char* m, const char* s)
1371 {
1372 const char *e = is_vmlinux(m) ?"":".ko";
1373
1374 switch (exp) {
1375 case export_unused:
1376 case export_unused_gpl:
1377 warn("modpost: module %s%s "
1378 "uses symbol '%s' marked UNUSED\n", m, e, s);
1379 break;
1380 default:
1381 /* ignore */
1382 break;
1383 }
1384 }
1385
1386 static void check_exports(struct module *mod)
1387 {
1388 struct symbol *s, *exp;
1389
1390 for (s = mod->unres; s; s = s->next) {
1391 const char *basename;
1392 exp = find_symbol(s->name);
1393 if (!exp || exp->module == mod)
1394 continue;
1395 basename = strrchr(mod->name, '/');
1396 if (basename)
1397 basename++;
1398 else
1399 basename = mod->name;
1400 if (!mod->gpl_compatible)
1401 check_for_gpl_usage(exp->export, basename, exp->name);
1402 check_for_unused(exp->export, basename, exp->name);
1403 }
1404 }
1405
1406 /**
1407 * Header for the generated file
1408 **/
1409 static void add_header(struct buffer *b, struct module *mod)
1410 {
1411 buf_printf(b, "#include <linux/module.h>\n");
1412 buf_printf(b, "#include <linux/vermagic.h>\n");
1413 buf_printf(b, "#include <linux/compiler.h>\n");
1414 buf_printf(b, "\n");
1415 buf_printf(b, "MODULE_INFO(vermagic, VERMAGIC_STRING);\n");
1416 buf_printf(b, "\n");
1417 buf_printf(b, "struct module __this_module\n");
1418 buf_printf(b, "__attribute__((section(\".gnu.linkonce.this_module\"))) = {\n");
1419 buf_printf(b, " .name = KBUILD_MODNAME,\n");
1420 if (mod->has_init)
1421 buf_printf(b, " .init = init_module,\n");
1422 if (mod->has_cleanup)
1423 buf_printf(b, "#ifdef CONFIG_MODULE_UNLOAD\n"
1424 " .exit = cleanup_module,\n"
1425 "#endif\n");
1426 buf_printf(b, " .arch = MODULE_ARCH_INIT,\n");
1427 buf_printf(b, "};\n");
1428 }
1429
1430 /**
1431 * Record CRCs for unresolved symbols
1432 **/
1433 static int add_versions(struct buffer *b, struct module *mod)
1434 {
1435 struct symbol *s, *exp;
1436 int err = 0;
1437
1438 for (s = mod->unres; s; s = s->next) {
1439 exp = find_symbol(s->name);
1440 if (!exp || exp->module == mod) {
1441 if (have_vmlinux && !s->weak) {
1442 if (warn_unresolved) {
1443 warn("\"%s\" [%s.ko] undefined!\n",
1444 s->name, mod->name);
1445 } else {
1446 merror("\"%s\" [%s.ko] undefined!\n",
1447 s->name, mod->name);
1448 err = 1;
1449 }
1450 }
1451 continue;
1452 }
1453 s->module = exp->module;
1454 s->crc_valid = exp->crc_valid;
1455 s->crc = exp->crc;
1456 }
1457
1458 if (!modversions)
1459 return err;
1460
1461 buf_printf(b, "\n");
1462 buf_printf(b, "static const struct modversion_info ____versions[]\n");
1463 buf_printf(b, "__attribute_used__\n");
1464 buf_printf(b, "__attribute__((section(\"__versions\"))) = {\n");
1465
1466 for (s = mod->unres; s; s = s->next) {
1467 if (!s->module) {
1468 continue;
1469 }
1470 if (!s->crc_valid) {
1471 warn("\"%s\" [%s.ko] has no CRC!\n",
1472 s->name, mod->name);
1473 continue;
1474 }
1475 buf_printf(b, "\t{ %#8x, \"%s\" },\n", s->crc, s->name);
1476 }
1477
1478 buf_printf(b, "};\n");
1479
1480 return err;
1481 }
1482
1483 static void add_depends(struct buffer *b, struct module *mod,
1484 struct module *modules)
1485 {
1486 struct symbol *s;
1487 struct module *m;
1488 int first = 1;
1489
1490 for (m = modules; m; m = m->next) {
1491 m->seen = is_vmlinux(m->name);
1492 }
1493
1494 buf_printf(b, "\n");
1495 buf_printf(b, "static const char __module_depends[]\n");
1496 buf_printf(b, "__attribute_used__\n");
1497 buf_printf(b, "__attribute__((section(\".modinfo\"))) =\n");
1498 buf_printf(b, "\"depends=");
1499 for (s = mod->unres; s; s = s->next) {
1500 const char *p;
1501 if (!s->module)
1502 continue;
1503
1504 if (s->module->seen)
1505 continue;
1506
1507 s->module->seen = 1;
1508 if ((p = strrchr(s->module->name, '/')) != NULL)
1509 p++;
1510 else
1511 p = s->module->name;
1512 buf_printf(b, "%s%s", first ? "" : ",", p);
1513 first = 0;
1514 }
1515 buf_printf(b, "\";\n");
1516 }
1517
1518 static void add_srcversion(struct buffer *b, struct module *mod)
1519 {
1520 if (mod->srcversion[0]) {
1521 buf_printf(b, "\n");
1522 buf_printf(b, "MODULE_INFO(srcversion, \"%s\");\n",
1523 mod->srcversion);
1524 }
1525 }
1526
1527 static void write_if_changed(struct buffer *b, const char *fname)
1528 {
1529 char *tmp;
1530 FILE *file;
1531 struct stat st;
1532
1533 file = fopen(fname, "r");
1534 if (!file)
1535 goto write;
1536
1537 if (fstat(fileno(file), &st) < 0)
1538 goto close_write;
1539
1540 if (st.st_size != b->pos)
1541 goto close_write;
1542
1543 tmp = NOFAIL(malloc(b->pos));
1544 if (fread(tmp, 1, b->pos, file) != b->pos)
1545 goto free_write;
1546
1547 if (memcmp(tmp, b->p, b->pos) != 0)
1548 goto free_write;
1549
1550 free(tmp);
1551 fclose(file);
1552 return;
1553
1554 free_write:
1555 free(tmp);
1556 close_write:
1557 fclose(file);
1558 write:
1559 file = fopen(fname, "w");
1560 if (!file) {
1561 perror(fname);
1562 exit(1);
1563 }
1564 if (fwrite(b->p, 1, b->pos, file) != b->pos) {
1565 perror(fname);
1566 exit(1);
1567 }
1568 fclose(file);
1569 }
1570
1571 /* parse Module.symvers file. line format:
1572 * 0x12345678<tab>symbol<tab>module[[<tab>export]<tab>something]
1573 **/
1574 static void read_dump(const char *fname, unsigned int kernel)
1575 {
1576 unsigned long size, pos = 0;
1577 void *file = grab_file(fname, &size);
1578 char *line;
1579
1580 if (!file)
1581 /* No symbol versions, silently ignore */
1582 return;
1583
1584 while ((line = get_next_line(&pos, file, size))) {
1585 char *symname, *modname, *d, *export, *end;
1586 unsigned int crc;
1587 struct module *mod;
1588 struct symbol *s;
1589
1590 if (!(symname = strchr(line, '\t')))
1591 goto fail;
1592 *symname++ = '\0';
1593 if (!(modname = strchr(symname, '\t')))
1594 goto fail;
1595 *modname++ = '\0';
1596 if ((export = strchr(modname, '\t')) != NULL)
1597 *export++ = '\0';
1598 if (export && ((end = strchr(export, '\t')) != NULL))
1599 *end = '\0';
1600 crc = strtoul(line, &d, 16);
1601 if (*symname == '\0' || *modname == '\0' || *d != '\0')
1602 goto fail;
1603
1604 if (!(mod = find_module(modname))) {
1605 if (is_vmlinux(modname)) {
1606 have_vmlinux = 1;
1607 }
1608 mod = new_module(NOFAIL(strdup(modname)));
1609 mod->skip = 1;
1610 }
1611 s = sym_add_exported(symname, mod, export_no(export));
1612 s->kernel = kernel;
1613 s->preloaded = 1;
1614 sym_update_crc(symname, mod, crc, export_no(export));
1615 }
1616 return;
1617 fail:
1618 fatal("parse error in symbol dump file\n");
1619 }
1620
1621 /* For normal builds always dump all symbols.
1622 * For external modules only dump symbols
1623 * that are not read from kernel Module.symvers.
1624 **/
1625 static int dump_sym(struct symbol *sym)
1626 {
1627 if (!external_module)
1628 return 1;
1629 if (sym->vmlinux || sym->kernel)
1630 return 0;
1631 return 1;
1632 }
1633
1634 static void write_dump(const char *fname)
1635 {
1636 struct buffer buf = { };
1637 struct symbol *symbol;
1638 int n;
1639
1640 for (n = 0; n < SYMBOL_HASH_SIZE ; n++) {
1641 symbol = symbolhash[n];
1642 while (symbol) {
1643 if (dump_sym(symbol))
1644 buf_printf(&buf, "0x%08x\t%s\t%s\t%s\n",
1645 symbol->crc, symbol->name,
1646 symbol->module->name,
1647 export_str(symbol->export));
1648 symbol = symbol->next;
1649 }
1650 }
1651 write_if_changed(&buf, fname);
1652 }
1653
1654 int main(int argc, char **argv)
1655 {
1656 struct module *mod;
1657 struct buffer buf = { };
1658 char fname[SZ];
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 if (mod->skip)
1712 continue;
1713
1714 buf.pos = 0;
1715
1716 add_header(&buf, mod);
1717 err |= add_versions(&buf, mod);
1718 add_depends(&buf, mod, modules);
1719 add_moddevtable(&buf, mod);
1720 add_srcversion(&buf, mod);
1721
1722 sprintf(fname, "%s.mod.c", mod->name);
1723 write_if_changed(&buf, fname);
1724 }
1725
1726 if (dump_write)
1727 write_dump(dump_write);
1728
1729 return err;
1730 }
Linux 2.6 libata-dev (mirror)