ia64/linux-2.6.18-xen.hg

view scripts/mod/modpost.c @ 897:329ea0ccb344

balloon: try harder to balloon up under memory pressure.

Currently if the balloon driver is unable to increase the guest's
reservation it assumes the failure was due to reaching its full
allocation, gives up on the ballooning operation and records the limit
it reached as the "hard limit". The driver will not try again until
the target is set again (even to the same value).

However it is possible that ballooning has in fact failed due to
memory pressure in the host and therefore it is desirable to keep
attempting to reach the target in case memory becomes available. The
most likely scenario is that some guests are ballooning down while
others are ballooning up and therefore there is temporary memory
pressure while things stabilise. You would not expect a well behaved
toolstack to ask a domain to balloon to more than its allocation nor
would you expect it to deliberately over-commit memory by setting
balloon targets which exceed the total host memory.

This patch drops the concept of a hard limit and causes the balloon
driver to retry increasing the reservation on a timer in the same
manner as when decreasing the reservation.

Also if we partially succeed in increasing the reservation
(i.e. receive less pages than we asked for) then we may as well keep
those pages rather than returning them to Xen.

Signed-off-by: Ian Campbell <ian.campbell@citrix.com>
author Keir Fraser <keir.fraser@citrix.com>
date Fri Jun 05 14:01:20 2009 +0100 (2009-06-05)
parents 831230e53067
children
line source
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 */
14 #include <ctype.h>
15 #include "modpost.h"
16 #include "../../include/linux/license.h"
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 /* How a symbol is exported */
27 enum export {
28 export_plain, export_unused, export_gpl,
29 export_unused_gpl, export_gpl_future, export_unknown
30 };
32 void fatal(const char *fmt, ...)
33 {
34 va_list arglist;
36 fprintf(stderr, "FATAL: ");
38 va_start(arglist, fmt);
39 vfprintf(stderr, fmt, arglist);
40 va_end(arglist);
42 exit(1);
43 }
45 void warn(const char *fmt, ...)
46 {
47 va_list arglist;
49 fprintf(stderr, "WARNING: ");
51 va_start(arglist, fmt);
52 vfprintf(stderr, fmt, arglist);
53 va_end(arglist);
54 }
56 static int is_vmlinux(const char *modname)
57 {
58 const char *myname;
60 if ((myname = strrchr(modname, '/')))
61 myname++;
62 else
63 myname = modname;
65 return strcmp(myname, "vmlinux") == 0;
66 }
68 void *do_nofail(void *ptr, const char *expr)
69 {
70 if (!ptr) {
71 fatal("modpost: Memory allocation failure: %s.\n", expr);
72 }
73 return ptr;
74 }
76 /* A list of all modules we processed */
78 static struct module *modules;
80 static struct module *find_module(char *modname)
81 {
82 struct module *mod;
84 for (mod = modules; mod; mod = mod->next)
85 if (strcmp(mod->name, modname) == 0)
86 break;
87 return mod;
88 }
90 static struct module *new_module(char *modname)
91 {
92 struct module *mod;
93 char *p, *s;
95 mod = NOFAIL(malloc(sizeof(*mod)));
96 memset(mod, 0, sizeof(*mod));
97 p = NOFAIL(strdup(modname));
99 /* strip trailing .o */
100 if ((s = strrchr(p, '.')) != NULL)
101 if (strcmp(s, ".o") == 0)
102 *s = '\0';
104 /* add to list */
105 mod->name = p;
106 mod->gpl_compatible = -1;
107 mod->next = modules;
108 modules = mod;
110 return mod;
111 }
113 /* A hash of all exported symbols,
114 * struct symbol is also used for lists of unresolved symbols */
116 #define SYMBOL_HASH_SIZE 1024
118 struct symbol {
119 struct symbol *next;
120 struct module *module;
121 unsigned int crc;
122 int crc_valid;
123 unsigned int weak:1;
124 unsigned int vmlinux:1; /* 1 if symbol is defined in vmlinux */
125 unsigned int kernel:1; /* 1 if symbol is from kernel
126 * (only for external modules) **/
127 unsigned int preloaded:1; /* 1 if symbol from Module.symvers */
128 enum export export; /* Type of export */
129 char name[0];
130 };
132 static struct symbol *symbolhash[SYMBOL_HASH_SIZE];
134 /* This is based on the hash agorithm from gdbm, via tdb */
135 static inline unsigned int tdb_hash(const char *name)
136 {
137 unsigned value; /* Used to compute the hash value. */
138 unsigned i; /* Used to cycle through random values. */
140 /* Set the initial value from the key size. */
141 for (value = 0x238F13AF * strlen(name), i=0; name[i]; i++)
142 value = (value + (((unsigned char *)name)[i] << (i*5 % 24)));
144 return (1103515243 * value + 12345);
145 }
147 /**
148 * Allocate a new symbols for use in the hash of exported symbols or
149 * the list of unresolved symbols per module
150 **/
151 static struct symbol *alloc_symbol(const char *name, unsigned int weak,
152 struct symbol *next)
153 {
154 struct symbol *s = NOFAIL(malloc(sizeof(*s) + strlen(name) + 1));
156 memset(s, 0, sizeof(*s));
157 strcpy(s->name, name);
158 s->weak = weak;
159 s->next = next;
160 return s;
161 }
163 /* For the hash of exported symbols */
164 static struct symbol *new_symbol(const char *name, struct module *module,
165 enum export export)
166 {
167 unsigned int hash;
168 struct symbol *new;
170 hash = tdb_hash(name) % SYMBOL_HASH_SIZE;
171 new = symbolhash[hash] = alloc_symbol(name, 0, symbolhash[hash]);
172 new->module = module;
173 new->export = export;
174 return new;
175 }
177 static struct symbol *find_symbol(const char *name)
178 {
179 struct symbol *s;
181 /* For our purposes, .foo matches foo. PPC64 needs this. */
182 if (name[0] == '.')
183 name++;
185 for (s = symbolhash[tdb_hash(name) % SYMBOL_HASH_SIZE]; s; s=s->next) {
186 if (strcmp(s->name, name) == 0)
187 return s;
188 }
189 return NULL;
190 }
192 static struct {
193 const char *str;
194 enum export export;
195 } export_list[] = {
196 { .str = "EXPORT_SYMBOL", .export = export_plain },
197 { .str = "EXPORT_UNUSED_SYMBOL", .export = export_unused },
198 { .str = "EXPORT_SYMBOL_GPL", .export = export_gpl },
199 { .str = "EXPORT_UNUSED_SYMBOL_GPL", .export = export_unused_gpl },
200 { .str = "EXPORT_SYMBOL_GPL_FUTURE", .export = export_gpl_future },
201 { .str = "(unknown)", .export = export_unknown },
202 };
205 static const char *export_str(enum export ex)
206 {
207 return export_list[ex].str;
208 }
210 static enum export export_no(const char * s)
211 {
212 int i;
213 if (!s)
214 return export_unknown;
215 for (i = 0; export_list[i].export != export_unknown; i++) {
216 if (strcmp(export_list[i].str, s) == 0)
217 return export_list[i].export;
218 }
219 return export_unknown;
220 }
222 static enum export export_from_sec(struct elf_info *elf, Elf_Section sec)
223 {
224 if (sec == elf->export_sec)
225 return export_plain;
226 else if (sec == elf->export_unused_sec)
227 return export_unused;
228 else if (sec == elf->export_gpl_sec)
229 return export_gpl;
230 else if (sec == elf->export_unused_gpl_sec)
231 return export_unused_gpl;
232 else if (sec == elf->export_gpl_future_sec)
233 return export_gpl_future;
234 else
235 return export_unknown;
236 }
238 /**
239 * Add an exported symbol - it may have already been added without a
240 * CRC, in this case just update the CRC
241 **/
242 static struct symbol *sym_add_exported(const char *name, struct module *mod,
243 enum export export)
244 {
245 struct symbol *s = find_symbol(name);
247 if (!s) {
248 s = new_symbol(name, mod, export);
249 } else {
250 if (!s->preloaded) {
251 warn("%s: '%s' exported twice. Previous export "
252 "was in %s%s\n", mod->name, name,
253 s->module->name,
254 is_vmlinux(s->module->name) ?"":".ko");
255 }
256 }
257 s->preloaded = 0;
258 s->vmlinux = is_vmlinux(mod->name);
259 s->kernel = 0;
260 s->export = export;
261 return s;
262 }
264 static void sym_update_crc(const char *name, struct module *mod,
265 unsigned int crc, enum export export)
266 {
267 struct symbol *s = find_symbol(name);
269 if (!s)
270 s = new_symbol(name, mod, export);
271 s->crc = crc;
272 s->crc_valid = 1;
273 }
275 void *grab_file(const char *filename, unsigned long *size)
276 {
277 struct stat st;
278 void *map;
279 int fd;
281 fd = open(filename, O_RDONLY);
282 if (fd < 0 || fstat(fd, &st) != 0)
283 return NULL;
285 *size = st.st_size;
286 map = mmap(NULL, *size, PROT_READ|PROT_WRITE, MAP_PRIVATE, fd, 0);
287 close(fd);
289 if (map == MAP_FAILED)
290 return NULL;
291 return map;
292 }
294 /**
295 * Return a copy of the next line in a mmap'ed file.
296 * spaces in the beginning of the line is trimmed away.
297 * Return a pointer to a static buffer.
298 **/
299 char* get_next_line(unsigned long *pos, void *file, unsigned long size)
300 {
301 static char line[4096];
302 int skip = 1;
303 size_t len = 0;
304 signed char *p = (signed char *)file + *pos;
305 char *s = line;
307 for (; *pos < size ; (*pos)++)
308 {
309 if (skip && isspace(*p)) {
310 p++;
311 continue;
312 }
313 skip = 0;
314 if (*p != '\n' && (*pos < size)) {
315 len++;
316 *s++ = *p++;
317 if (len > 4095)
318 break; /* Too long, stop */
319 } else {
320 /* End of string */
321 *s = '\0';
322 return line;
323 }
324 }
325 /* End of buffer */
326 return NULL;
327 }
329 void release_file(void *file, unsigned long size)
330 {
331 munmap(file, size);
332 }
334 static void parse_elf(struct elf_info *info, const char *filename)
335 {
336 unsigned int i;
337 Elf_Ehdr *hdr = info->hdr;
338 Elf_Shdr *sechdrs;
339 Elf_Sym *sym;
341 hdr = grab_file(filename, &info->size);
342 if (!hdr) {
343 perror(filename);
344 exit(1);
345 }
346 info->hdr = hdr;
347 if (info->size < sizeof(*hdr))
348 goto truncated;
350 /* Fix endianness in ELF header */
351 hdr->e_shoff = TO_NATIVE(hdr->e_shoff);
352 hdr->e_shstrndx = TO_NATIVE(hdr->e_shstrndx);
353 hdr->e_shnum = TO_NATIVE(hdr->e_shnum);
354 hdr->e_machine = TO_NATIVE(hdr->e_machine);
355 sechdrs = (void *)hdr + hdr->e_shoff;
356 info->sechdrs = sechdrs;
358 /* Fix endianness in section headers */
359 for (i = 0; i < hdr->e_shnum; i++) {
360 sechdrs[i].sh_type = TO_NATIVE(sechdrs[i].sh_type);
361 sechdrs[i].sh_offset = TO_NATIVE(sechdrs[i].sh_offset);
362 sechdrs[i].sh_size = TO_NATIVE(sechdrs[i].sh_size);
363 sechdrs[i].sh_link = TO_NATIVE(sechdrs[i].sh_link);
364 sechdrs[i].sh_name = TO_NATIVE(sechdrs[i].sh_name);
365 }
366 /* Find symbol table. */
367 for (i = 1; i < hdr->e_shnum; i++) {
368 const char *secstrings
369 = (void *)hdr + sechdrs[hdr->e_shstrndx].sh_offset;
370 const char *secname;
372 if (sechdrs[i].sh_offset > info->size)
373 goto truncated;
374 secname = secstrings + sechdrs[i].sh_name;
375 if (strcmp(secname, ".modinfo") == 0) {
376 info->modinfo = (void *)hdr + sechdrs[i].sh_offset;
377 info->modinfo_len = sechdrs[i].sh_size;
378 } else if (strcmp(secname, "__ksymtab") == 0)
379 info->export_sec = i;
380 else if (strcmp(secname, "__ksymtab_unused") == 0)
381 info->export_unused_sec = i;
382 else if (strcmp(secname, "__ksymtab_gpl") == 0)
383 info->export_gpl_sec = i;
384 else if (strcmp(secname, "__ksymtab_unused_gpl") == 0)
385 info->export_unused_gpl_sec = i;
386 else if (strcmp(secname, "__ksymtab_gpl_future") == 0)
387 info->export_gpl_future_sec = i;
389 if (sechdrs[i].sh_type != SHT_SYMTAB)
390 continue;
392 info->symtab_start = (void *)hdr + sechdrs[i].sh_offset;
393 info->symtab_stop = (void *)hdr + sechdrs[i].sh_offset
394 + sechdrs[i].sh_size;
395 info->strtab = (void *)hdr +
396 sechdrs[sechdrs[i].sh_link].sh_offset;
397 }
398 if (!info->symtab_start) {
399 fatal("%s has no symtab?\n", filename);
400 }
401 /* Fix endianness in symbols */
402 for (sym = info->symtab_start; sym < info->symtab_stop; sym++) {
403 sym->st_shndx = TO_NATIVE(sym->st_shndx);
404 sym->st_name = TO_NATIVE(sym->st_name);
405 sym->st_value = TO_NATIVE(sym->st_value);
406 sym->st_size = TO_NATIVE(sym->st_size);
407 }
408 return;
410 truncated:
411 fatal("%s is truncated.\n", filename);
412 }
414 static void parse_elf_finish(struct elf_info *info)
415 {
416 release_file(info->hdr, info->size);
417 }
419 #define CRC_PFX MODULE_SYMBOL_PREFIX "__crc_"
420 #define KSYMTAB_PFX MODULE_SYMBOL_PREFIX "__ksymtab_"
422 static void handle_modversions(struct module *mod, struct elf_info *info,
423 Elf_Sym *sym, const char *symname)
424 {
425 unsigned int crc;
426 enum export export = export_from_sec(info, sym->st_shndx);
428 switch (sym->st_shndx) {
429 case SHN_COMMON:
430 warn("\"%s\" [%s] is COMMON symbol\n", symname, mod->name);
431 break;
432 case SHN_ABS:
433 /* CRC'd symbol */
434 if (memcmp(symname, CRC_PFX, strlen(CRC_PFX)) == 0) {
435 crc = (unsigned int) sym->st_value;
436 sym_update_crc(symname + strlen(CRC_PFX), mod, crc,
437 export);
438 }
439 break;
440 case SHN_UNDEF:
441 /* undefined symbol */
442 if (ELF_ST_BIND(sym->st_info) != STB_GLOBAL &&
443 ELF_ST_BIND(sym->st_info) != STB_WEAK)
444 break;
445 /* ignore global offset table */
446 if (strcmp(symname, "_GLOBAL_OFFSET_TABLE_") == 0)
447 break;
448 /* ignore __this_module, it will be resolved shortly */
449 if (strcmp(symname, MODULE_SYMBOL_PREFIX "__this_module") == 0)
450 break;
451 /* cope with newer glibc (2.3.4 or higher) STT_ definition in elf.h */
452 #if defined(STT_REGISTER) || defined(STT_SPARC_REGISTER)
453 /* add compatibility with older glibc */
454 #ifndef STT_SPARC_REGISTER
455 #define STT_SPARC_REGISTER STT_REGISTER
456 #endif
457 if (info->hdr->e_machine == EM_SPARC ||
458 info->hdr->e_machine == EM_SPARCV9) {
459 /* Ignore register directives. */
460 if (ELF_ST_TYPE(sym->st_info) == STT_SPARC_REGISTER)
461 break;
462 if (symname[0] == '.') {
463 char *munged = strdup(symname);
464 munged[0] = '_';
465 munged[1] = toupper(munged[1]);
466 symname = munged;
467 }
468 }
469 #endif
471 if (memcmp(symname, MODULE_SYMBOL_PREFIX,
472 strlen(MODULE_SYMBOL_PREFIX)) == 0)
473 mod->unres = alloc_symbol(symname +
474 strlen(MODULE_SYMBOL_PREFIX),
475 ELF_ST_BIND(sym->st_info) == STB_WEAK,
476 mod->unres);
477 break;
478 default:
479 /* All exported symbols */
480 if (memcmp(symname, KSYMTAB_PFX, strlen(KSYMTAB_PFX)) == 0) {
481 sym_add_exported(symname + strlen(KSYMTAB_PFX), mod,
482 export);
483 }
484 if (strcmp(symname, MODULE_SYMBOL_PREFIX "init_module") == 0)
485 mod->has_init = 1;
486 if (strcmp(symname, MODULE_SYMBOL_PREFIX "cleanup_module") == 0)
487 mod->has_cleanup = 1;
488 break;
489 }
490 }
492 /**
493 * Parse tag=value strings from .modinfo section
494 **/
495 static char *next_string(char *string, unsigned long *secsize)
496 {
497 /* Skip non-zero chars */
498 while (string[0]) {
499 string++;
500 if ((*secsize)-- <= 1)
501 return NULL;
502 }
504 /* Skip any zero padding. */
505 while (!string[0]) {
506 string++;
507 if ((*secsize)-- <= 1)
508 return NULL;
509 }
510 return string;
511 }
513 static char *get_next_modinfo(void *modinfo, unsigned long modinfo_len,
514 const char *tag, char *info)
515 {
516 char *p;
517 unsigned int taglen = strlen(tag);
518 unsigned long size = modinfo_len;
520 if (info) {
521 size -= info - (char *)modinfo;
522 modinfo = next_string(info, &size);
523 }
525 for (p = modinfo; p; p = next_string(p, &size)) {
526 if (strncmp(p, tag, taglen) == 0 && p[taglen] == '=')
527 return p + taglen + 1;
528 }
529 return NULL;
530 }
532 static char *get_modinfo(void *modinfo, unsigned long modinfo_len,
533 const char *tag)
535 {
536 return get_next_modinfo(modinfo, modinfo_len, tag, NULL);
537 }
539 /**
540 * Test if string s ends in string sub
541 * return 0 if match
542 **/
543 static int strrcmp(const char *s, const char *sub)
544 {
545 int slen, sublen;
547 if (!s || !sub)
548 return 1;
550 slen = strlen(s);
551 sublen = strlen(sub);
553 if ((slen == 0) || (sublen == 0))
554 return 1;
556 if (sublen > slen)
557 return 1;
559 return memcmp(s + slen - sublen, sub, sublen);
560 }
562 /**
563 * Whitelist to allow certain references to pass with no warning.
564 * Pattern 1:
565 * If a module parameter is declared __initdata and permissions=0
566 * then this is legal despite the warning generated.
567 * We cannot see value of permissions here, so just ignore
568 * this pattern.
569 * The pattern is identified by:
570 * tosec = .init.data
571 * fromsec = .data*
572 * atsym =__param*
573 *
574 * Pattern 2:
575 * Many drivers utilise a *driver container with references to
576 * add, remove, probe functions etc.
577 * These functions may often be marked __init and we do not want to
578 * warn here.
579 * the pattern is identified by:
580 * tosec = .init.text | .exit.text | .init.data
581 * fromsec = .data
582 * atsym = *driver, *_template, *_sht, *_ops, *_probe, *probe_one
583 **/
584 static int secref_whitelist(const char *tosec, const char *fromsec,
585 const char *atsym)
586 {
587 int f1 = 1, f2 = 1;
588 const char **s;
589 const char *pat2sym[] = {
590 "driver",
591 "_template", /* scsi uses *_template a lot */
592 "_sht", /* scsi also used *_sht to some extent */
593 "_ops",
594 "_probe",
595 "_probe_one",
596 NULL
597 };
599 /* Check for pattern 1 */
600 if (strcmp(tosec, ".init.data") != 0)
601 f1 = 0;
602 if (strncmp(fromsec, ".data", strlen(".data")) != 0)
603 f1 = 0;
604 if (strncmp(atsym, "__param", strlen("__param")) != 0)
605 f1 = 0;
607 if (f1)
608 return f1;
610 /* Check for pattern 2 */
611 if ((strcmp(tosec, ".init.text") != 0) &&
612 (strcmp(tosec, ".exit.text") != 0) &&
613 (strcmp(tosec, ".init.data") != 0))
614 f2 = 0;
615 if (strcmp(fromsec, ".data") != 0)
616 f2 = 0;
618 for (s = pat2sym; *s; s++)
619 if (strrcmp(atsym, *s) == 0)
620 f1 = 1;
622 return f1 && f2;
623 }
625 /**
626 * Find symbol based on relocation record info.
627 * In some cases the symbol supplied is a valid symbol so
628 * return refsym. If st_name != 0 we assume this is a valid symbol.
629 * In other cases the symbol needs to be looked up in the symbol table
630 * based on section and address.
631 * **/
632 static Elf_Sym *find_elf_symbol(struct elf_info *elf, Elf_Addr addr,
633 Elf_Sym *relsym)
634 {
635 Elf_Sym *sym;
637 if (relsym->st_name != 0)
638 return relsym;
639 for (sym = elf->symtab_start; sym < elf->symtab_stop; sym++) {
640 if (sym->st_shndx != relsym->st_shndx)
641 continue;
642 if (sym->st_value == addr)
643 return sym;
644 }
645 return NULL;
646 }
648 /*
649 * Find symbols before or equal addr and after addr - in the section sec.
650 * If we find two symbols with equal offset prefer one with a valid name.
651 * The ELF format may have a better way to detect what type of symbol
652 * it is, but this works for now.
653 **/
654 static void find_symbols_between(struct elf_info *elf, Elf_Addr addr,
655 const char *sec,
656 Elf_Sym **before, Elf_Sym **after)
657 {
658 Elf_Sym *sym;
659 Elf_Ehdr *hdr = elf->hdr;
660 Elf_Addr beforediff = ~0;
661 Elf_Addr afterdiff = ~0;
662 const char *secstrings = (void *)hdr +
663 elf->sechdrs[hdr->e_shstrndx].sh_offset;
665 *before = NULL;
666 *after = NULL;
668 for (sym = elf->symtab_start; sym < elf->symtab_stop; sym++) {
669 const char *symsec;
671 if (sym->st_shndx >= SHN_LORESERVE)
672 continue;
673 symsec = secstrings + elf->sechdrs[sym->st_shndx].sh_name;
674 if (strcmp(symsec, sec) != 0)
675 continue;
676 if (sym->st_value <= addr) {
677 if ((addr - sym->st_value) < beforediff) {
678 beforediff = addr - sym->st_value;
679 *before = sym;
680 }
681 else if ((addr - sym->st_value) == beforediff) {
682 /* equal offset, valid name? */
683 const char *name = elf->strtab + sym->st_name;
684 if (name && strlen(name))
685 *before = sym;
686 }
687 }
688 else
689 {
690 if ((sym->st_value - addr) < afterdiff) {
691 afterdiff = sym->st_value - addr;
692 *after = sym;
693 }
694 else if ((sym->st_value - addr) == afterdiff) {
695 /* equal offset, valid name? */
696 const char *name = elf->strtab + sym->st_name;
697 if (name && strlen(name))
698 *after = sym;
699 }
700 }
701 }
702 }
704 /**
705 * Print a warning about a section mismatch.
706 * Try to find symbols near it so user can find it.
707 * Check whitelist before warning - it may be a false positive.
708 **/
709 static void warn_sec_mismatch(const char *modname, const char *fromsec,
710 struct elf_info *elf, Elf_Sym *sym, Elf_Rela r)
711 {
712 const char *refsymname = "";
713 Elf_Sym *before, *after;
714 Elf_Sym *refsym;
715 Elf_Ehdr *hdr = elf->hdr;
716 Elf_Shdr *sechdrs = elf->sechdrs;
717 const char *secstrings = (void *)hdr +
718 sechdrs[hdr->e_shstrndx].sh_offset;
719 const char *secname = secstrings + sechdrs[sym->st_shndx].sh_name;
721 find_symbols_between(elf, r.r_offset, fromsec, &before, &after);
723 refsym = find_elf_symbol(elf, r.r_addend, sym);
724 if (refsym && strlen(elf->strtab + refsym->st_name))
725 refsymname = elf->strtab + refsym->st_name;
727 /* check whitelist - we may ignore it */
728 if (before &&
729 secref_whitelist(secname, fromsec, elf->strtab + before->st_name))
730 return;
732 if (before && after) {
733 warn("%s - Section mismatch: reference to %s:%s from %s "
734 "between '%s' (at offset 0x%llx) and '%s'\n",
735 modname, secname, refsymname, fromsec,
736 elf->strtab + before->st_name,
737 (long long)r.r_offset,
738 elf->strtab + after->st_name);
739 } else if (before) {
740 warn("%s - Section mismatch: reference to %s:%s from %s "
741 "after '%s' (at offset 0x%llx)\n",
742 modname, secname, refsymname, fromsec,
743 elf->strtab + before->st_name,
744 (long long)r.r_offset);
745 } else if (after) {
746 warn("%s - Section mismatch: reference to %s:%s from %s "
747 "before '%s' (at offset -0x%llx)\n",
748 modname, secname, refsymname, fromsec,
749 elf->strtab + after->st_name,
750 (long long)r.r_offset);
751 } else {
752 warn("%s - Section mismatch: reference to %s:%s from %s "
753 "(offset 0x%llx)\n",
754 modname, secname, fromsec, refsymname,
755 (long long)r.r_offset);
756 }
757 }
759 /**
760 * A module includes a number of sections that are discarded
761 * either when loaded or when used as built-in.
762 * For loaded modules all functions marked __init and all data
763 * marked __initdata will be discarded when the module has been intialized.
764 * Likewise for modules used built-in the sections marked __exit
765 * are discarded because __exit marked function are supposed to be called
766 * only when a moduel is unloaded which never happes for built-in modules.
767 * The check_sec_ref() function traverses all relocation records
768 * to find all references to a section that reference a section that will
769 * be discarded and warns about it.
770 **/
771 static void check_sec_ref(struct module *mod, const char *modname,
772 struct elf_info *elf,
773 int section(const char*),
774 int section_ref_ok(const char *))
775 {
776 int i;
777 Elf_Sym *sym;
778 Elf_Ehdr *hdr = elf->hdr;
779 Elf_Shdr *sechdrs = elf->sechdrs;
780 const char *secstrings = (void *)hdr +
781 sechdrs[hdr->e_shstrndx].sh_offset;
783 /* Walk through all sections */
784 for (i = 0; i < hdr->e_shnum; i++) {
785 const char *name = secstrings + sechdrs[i].sh_name;
786 const char *secname;
787 Elf_Rela r;
788 unsigned int r_sym;
789 /* We want to process only relocation sections and not .init */
790 if (sechdrs[i].sh_type == SHT_RELA) {
791 Elf_Rela *rela;
792 Elf_Rela *start = (void *)hdr + sechdrs[i].sh_offset;
793 Elf_Rela *stop = (void*)start + sechdrs[i].sh_size;
794 name += strlen(".rela");
795 if (section_ref_ok(name))
796 continue;
798 for (rela = start; rela < stop; rela++) {
799 r.r_offset = TO_NATIVE(rela->r_offset);
800 #if KERNEL_ELFCLASS == ELFCLASS64
801 if (hdr->e_machine == EM_MIPS) {
802 r_sym = ELF64_MIPS_R_SYM(rela->r_info);
803 r_sym = TO_NATIVE(r_sym);
804 } else {
805 r.r_info = TO_NATIVE(rela->r_info);
806 r_sym = ELF_R_SYM(r.r_info);
807 }
808 #else
809 r.r_info = TO_NATIVE(rela->r_info);
810 r_sym = ELF_R_SYM(r.r_info);
811 #endif
812 r.r_addend = TO_NATIVE(rela->r_addend);
813 sym = elf->symtab_start + r_sym;
814 /* Skip special sections */
815 if (sym->st_shndx >= SHN_LORESERVE)
816 continue;
818 secname = secstrings +
819 sechdrs[sym->st_shndx].sh_name;
820 if (section(secname))
821 warn_sec_mismatch(modname, name,
822 elf, sym, r);
823 }
824 } else if (sechdrs[i].sh_type == SHT_REL) {
825 Elf_Rel *rel;
826 Elf_Rel *start = (void *)hdr + sechdrs[i].sh_offset;
827 Elf_Rel *stop = (void*)start + sechdrs[i].sh_size;
828 name += strlen(".rel");
829 if (section_ref_ok(name))
830 continue;
832 for (rel = start; rel < stop; rel++) {
833 r.r_offset = TO_NATIVE(rel->r_offset);
834 #if KERNEL_ELFCLASS == ELFCLASS64
835 if (hdr->e_machine == EM_MIPS) {
836 r_sym = ELF64_MIPS_R_SYM(rel->r_info);
837 r_sym = TO_NATIVE(r_sym);
838 } else {
839 r.r_info = TO_NATIVE(rel->r_info);
840 r_sym = ELF_R_SYM(r.r_info);
841 }
842 #else
843 r.r_info = TO_NATIVE(rel->r_info);
844 r_sym = ELF_R_SYM(r.r_info);
845 #endif
846 r.r_addend = 0;
847 sym = elf->symtab_start + r_sym;
848 /* Skip special sections */
849 if (sym->st_shndx >= SHN_LORESERVE)
850 continue;
852 secname = secstrings +
853 sechdrs[sym->st_shndx].sh_name;
854 if (section(secname))
855 warn_sec_mismatch(modname, name,
856 elf, sym, r);
857 }
858 }
859 }
860 }
862 /**
863 * Functions used only during module init is marked __init and is stored in
864 * a .init.text section. Likewise data is marked __initdata and stored in
865 * a .init.data section.
866 * If this section is one of these sections return 1
867 * See include/linux/init.h for the details
868 **/
869 static int init_section(const char *name)
870 {
871 if (strcmp(name, ".init") == 0)
872 return 1;
873 if (strncmp(name, ".init.", strlen(".init.")) == 0)
874 return 1;
875 return 0;
876 }
878 /**
879 * Identify sections from which references to a .init section is OK.
880 *
881 * Unfortunately references to read only data that referenced .init
882 * sections had to be excluded. Almost all of these are false
883 * positives, they are created by gcc. The downside of excluding rodata
884 * is that there really are some user references from rodata to
885 * init code, e.g. drivers/video/vgacon.c:
886 *
887 * const struct consw vga_con = {
888 * con_startup: vgacon_startup,
889 *
890 * where vgacon_startup is __init. If you want to wade through the false
891 * positives, take out the check for rodata.
892 **/
893 static int init_section_ref_ok(const char *name)
894 {
895 const char **s;
896 /* Absolute section names */
897 const char *namelist1[] = {
898 ".init",
899 ".opd", /* see comment [OPD] at exit_section_ref_ok() */
900 ".toc1", /* used by ppc64 */
901 ".stab",
902 ".rodata",
903 ".text.lock",
904 "__bug_table", /* used by powerpc for BUG() */
905 ".pci_fixup_header",
906 ".pci_fixup_final",
907 ".pdr",
908 "__param",
909 "__ex_table",
910 ".fixup",
911 ".smp_locks",
912 ".plt", /* seen on ARCH=um build on x86_64. Harmless */
913 NULL
914 };
915 /* Start of section names */
916 const char *namelist2[] = {
917 ".init.",
918 ".altinstructions",
919 ".eh_frame",
920 ".debug",
921 NULL
922 };
923 /* part of section name */
924 const char *namelist3 [] = {
925 ".unwind", /* sample: IA_64.unwind.init.text */
926 NULL
927 };
929 for (s = namelist1; *s; s++)
930 if (strcmp(*s, name) == 0)
931 return 1;
932 for (s = namelist2; *s; s++)
933 if (strncmp(*s, name, strlen(*s)) == 0)
934 return 1;
935 for (s = namelist3; *s; s++)
936 if (strstr(name, *s) != NULL)
937 return 1;
938 if (strrcmp(name, ".init") == 0)
939 return 1;
940 return 0;
941 }
943 /*
944 * Functions used only during module exit is marked __exit and is stored in
945 * a .exit.text section. Likewise data is marked __exitdata and stored in
946 * a .exit.data section.
947 * If this section is one of these sections return 1
948 * See include/linux/init.h for the details
949 **/
950 static int exit_section(const char *name)
951 {
952 if (strcmp(name, ".exit.text") == 0)
953 return 1;
954 if (strcmp(name, ".exit.data") == 0)
955 return 1;
956 return 0;
958 }
960 /*
961 * Identify sections from which references to a .exit section is OK.
962 *
963 * [OPD] Keith Ownes <kaos@sgi.com> commented:
964 * For our future {in}sanity, add a comment that this is the ppc .opd
965 * section, not the ia64 .opd section.
966 * ia64 .opd should not point to discarded sections.
967 * [.rodata] like for .init.text we ignore .rodata references -same reason
968 **/
969 static int exit_section_ref_ok(const char *name)
970 {
971 const char **s;
972 /* Absolute section names */
973 const char *namelist1[] = {
974 ".exit.text",
975 ".exit.data",
976 ".init.text",
977 ".rodata",
978 ".opd", /* See comment [OPD] */
979 ".toc1", /* used by ppc64 */
980 ".altinstructions",
981 ".pdr",
982 "__bug_table", /* used by powerpc for BUG() */
983 ".exitcall.exit",
984 ".eh_frame",
985 ".stab",
986 "__ex_table",
987 ".fixup",
988 ".smp_locks",
989 ".plt", /* seen on ARCH=um build on x86_64. Harmless */
990 NULL
991 };
992 /* Start of section names */
993 const char *namelist2[] = {
994 ".debug",
995 NULL
996 };
997 /* part of section name */
998 const char *namelist3 [] = {
999 ".unwind", /* Sample: IA_64.unwind.exit.text */
1000 NULL
1001 };
1003 for (s = namelist1; *s; s++)
1004 if (strcmp(*s, name) == 0)
1005 return 1;
1006 for (s = namelist2; *s; s++)
1007 if (strncmp(*s, name, strlen(*s)) == 0)
1008 return 1;
1009 for (s = namelist3; *s; s++)
1010 if (strstr(name, *s) != NULL)
1011 return 1;
1012 return 0;
1015 static void read_symbols(char *modname)
1017 const char *symname;
1018 char *version;
1019 char *license;
1020 struct module *mod;
1021 struct elf_info info = { };
1022 Elf_Sym *sym;
1024 parse_elf(&info, modname);
1026 mod = new_module(modname);
1028 /* When there's no vmlinux, don't print warnings about
1029 * unresolved symbols (since there'll be too many ;) */
1030 if (is_vmlinux(modname)) {
1031 have_vmlinux = 1;
1032 mod->skip = 1;
1035 license = get_modinfo(info.modinfo, info.modinfo_len, "license");
1036 while (license) {
1037 if (license_is_gpl_compatible(license))
1038 mod->gpl_compatible = 1;
1039 else {
1040 mod->gpl_compatible = 0;
1041 break;
1043 license = get_next_modinfo(info.modinfo, info.modinfo_len,
1044 "license", license);
1047 for (sym = info.symtab_start; sym < info.symtab_stop; sym++) {
1048 symname = info.strtab + sym->st_name;
1050 handle_modversions(mod, &info, sym, symname);
1051 handle_moddevtable(mod, &info, sym, symname);
1053 check_sec_ref(mod, modname, &info, init_section, init_section_ref_ok);
1054 check_sec_ref(mod, modname, &info, exit_section, exit_section_ref_ok);
1056 version = get_modinfo(info.modinfo, info.modinfo_len, "version");
1057 if (version)
1058 maybe_frob_rcs_version(modname, version, info.modinfo,
1059 version - (char *)info.hdr);
1060 if (version || (all_versions && !is_vmlinux(modname)))
1061 get_src_version(modname, mod->srcversion,
1062 sizeof(mod->srcversion)-1);
1064 parse_elf_finish(&info);
1066 /* Our trick to get versioning for struct_module - it's
1067 * never passed as an argument to an exported function, so
1068 * the automatic versioning doesn't pick it up, but it's really
1069 * important anyhow */
1070 if (modversions)
1071 mod->unres = alloc_symbol("struct_module", 0, mod->unres);
1074 #define SZ 500
1076 /* We first write the generated file into memory using the
1077 * following helper, then compare to the file on disk and
1078 * only update the later if anything changed */
1080 void __attribute__((format(printf, 2, 3))) buf_printf(struct buffer *buf,
1081 const char *fmt, ...)
1083 char tmp[SZ];
1084 int len;
1085 va_list ap;
1087 va_start(ap, fmt);
1088 len = vsnprintf(tmp, SZ, fmt, ap);
1089 buf_write(buf, tmp, len);
1090 va_end(ap);
1093 void buf_write(struct buffer *buf, const char *s, int len)
1095 if (buf->size - buf->pos < len) {
1096 buf->size += len + SZ;
1097 buf->p = realloc(buf->p, buf->size);
1099 strncpy(buf->p + buf->pos, s, len);
1100 buf->pos += len;
1103 static void check_for_gpl_usage(enum export exp, const char *m, const char *s)
1105 const char *e = is_vmlinux(m) ?"":".ko";
1107 switch (exp) {
1108 case export_gpl:
1109 fatal("modpost: GPL-incompatible module %s%s "
1110 "uses GPL-only symbol '%s'\n", m, e, s);
1111 break;
1112 case export_unused_gpl:
1113 fatal("modpost: GPL-incompatible module %s%s "
1114 "uses GPL-only symbol marked UNUSED '%s'\n", m, e, s);
1115 break;
1116 case export_gpl_future:
1117 warn("modpost: GPL-incompatible module %s%s "
1118 "uses future GPL-only symbol '%s'\n", m, e, s);
1119 break;
1120 case export_plain:
1121 case export_unused:
1122 case export_unknown:
1123 /* ignore */
1124 break;
1128 static void check_for_unused(enum export exp, const char* m, const char* s)
1130 const char *e = is_vmlinux(m) ?"":".ko";
1132 switch (exp) {
1133 case export_unused:
1134 case export_unused_gpl:
1135 warn("modpost: module %s%s "
1136 "uses symbol '%s' marked UNUSED\n", m, e, s);
1137 break;
1138 default:
1139 /* ignore */
1140 break;
1144 static void check_exports(struct module *mod)
1146 struct symbol *s, *exp;
1148 for (s = mod->unres; s; s = s->next) {
1149 const char *basename;
1150 exp = find_symbol(s->name);
1151 if (!exp || exp->module == mod)
1152 continue;
1153 basename = strrchr(mod->name, '/');
1154 if (basename)
1155 basename++;
1156 else
1157 basename = mod->name;
1158 if (!mod->gpl_compatible)
1159 check_for_gpl_usage(exp->export, basename, exp->name);
1160 check_for_unused(exp->export, basename, exp->name);
1164 /**
1165 * Header for the generated file
1166 **/
1167 static void add_header(struct buffer *b, struct module *mod)
1169 buf_printf(b, "#include <linux/module.h>\n");
1170 buf_printf(b, "#include <linux/vermagic.h>\n");
1171 buf_printf(b, "#include <linux/compiler.h>\n");
1172 buf_printf(b, "\n");
1173 buf_printf(b, "MODULE_INFO(vermagic, VERMAGIC_STRING);\n");
1174 buf_printf(b, "\n");
1175 buf_printf(b, "struct module __this_module\n");
1176 buf_printf(b, "__attribute__((section(\".gnu.linkonce.this_module\"))) = {\n");
1177 buf_printf(b, " .name = KBUILD_MODNAME,\n");
1178 if (mod->has_init)
1179 buf_printf(b, " .init = init_module,\n");
1180 if (mod->has_cleanup)
1181 buf_printf(b, "#ifdef CONFIG_MODULE_UNLOAD\n"
1182 " .exit = cleanup_module,\n"
1183 "#endif\n");
1184 buf_printf(b, "};\n");
1187 /**
1188 * Record CRCs for unresolved symbols
1189 **/
1190 static void add_versions(struct buffer *b, struct module *mod)
1192 struct symbol *s, *exp;
1194 for (s = mod->unres; s; s = s->next) {
1195 exp = find_symbol(s->name);
1196 if (!exp || exp->module == mod) {
1197 if (have_vmlinux && !s->weak)
1198 warn("\"%s\" [%s.ko] undefined!\n",
1199 s->name, mod->name);
1200 continue;
1202 s->module = exp->module;
1203 s->crc_valid = exp->crc_valid;
1204 s->crc = exp->crc;
1207 if (!modversions)
1208 return;
1210 buf_printf(b, "\n");
1211 buf_printf(b, "static const struct modversion_info ____versions[]\n");
1212 buf_printf(b, "__attribute_used__\n");
1213 buf_printf(b, "__attribute__((section(\"__versions\"))) = {\n");
1215 for (s = mod->unres; s; s = s->next) {
1216 if (!s->module) {
1217 continue;
1219 if (!s->crc_valid) {
1220 warn("\"%s\" [%s.ko] has no CRC!\n",
1221 s->name, mod->name);
1222 continue;
1224 buf_printf(b, "\t{ %#8x, \"%s\" },\n", s->crc, s->name);
1227 buf_printf(b, "};\n");
1230 static void add_depends(struct buffer *b, struct module *mod,
1231 struct module *modules)
1233 struct symbol *s;
1234 struct module *m;
1235 int first = 1;
1237 for (m = modules; m; m = m->next) {
1238 m->seen = is_vmlinux(m->name);
1241 buf_printf(b, "\n");
1242 buf_printf(b, "static const char __module_depends[]\n");
1243 buf_printf(b, "__attribute_used__\n");
1244 buf_printf(b, "__attribute__((section(\".modinfo\"))) =\n");
1245 buf_printf(b, "\"depends=");
1246 for (s = mod->unres; s; s = s->next) {
1247 if (!s->module)
1248 continue;
1250 if (s->module->seen)
1251 continue;
1253 s->module->seen = 1;
1254 buf_printf(b, "%s%s", first ? "" : ",",
1255 strrchr(s->module->name, '/') + 1);
1256 first = 0;
1258 buf_printf(b, "\";\n");
1261 static void add_srcversion(struct buffer *b, struct module *mod)
1263 if (mod->srcversion[0]) {
1264 buf_printf(b, "\n");
1265 buf_printf(b, "MODULE_INFO(srcversion, \"%s\");\n",
1266 mod->srcversion);
1270 static void write_if_changed(struct buffer *b, const char *fname)
1272 char *tmp;
1273 FILE *file;
1274 struct stat st;
1276 file = fopen(fname, "r");
1277 if (!file)
1278 goto write;
1280 if (fstat(fileno(file), &st) < 0)
1281 goto close_write;
1283 if (st.st_size != b->pos)
1284 goto close_write;
1286 tmp = NOFAIL(malloc(b->pos));
1287 if (fread(tmp, 1, b->pos, file) != b->pos)
1288 goto free_write;
1290 if (memcmp(tmp, b->p, b->pos) != 0)
1291 goto free_write;
1293 free(tmp);
1294 fclose(file);
1295 return;
1297 free_write:
1298 free(tmp);
1299 close_write:
1300 fclose(file);
1301 write:
1302 file = fopen(fname, "w");
1303 if (!file) {
1304 perror(fname);
1305 exit(1);
1307 if (fwrite(b->p, 1, b->pos, file) != b->pos) {
1308 perror(fname);
1309 exit(1);
1311 fclose(file);
1314 /* parse Module.symvers file. line format:
1315 * 0x12345678<tab>symbol<tab>module[[<tab>export]<tab>something]
1316 **/
1317 static void read_dump(const char *fname, unsigned int kernel)
1319 unsigned long size, pos = 0;
1320 void *file = grab_file(fname, &size);
1321 char *line;
1323 if (!file)
1324 /* No symbol versions, silently ignore */
1325 return;
1327 while ((line = get_next_line(&pos, file, size))) {
1328 char *symname, *modname, *d, *export, *end;
1329 unsigned int crc;
1330 struct module *mod;
1331 struct symbol *s;
1333 if (!(symname = strchr(line, '\t')))
1334 goto fail;
1335 *symname++ = '\0';
1336 if (!(modname = strchr(symname, '\t')))
1337 goto fail;
1338 *modname++ = '\0';
1339 if ((export = strchr(modname, '\t')) != NULL)
1340 *export++ = '\0';
1341 if (export && ((end = strchr(export, '\t')) != NULL))
1342 *end = '\0';
1343 crc = strtoul(line, &d, 16);
1344 if (*symname == '\0' || *modname == '\0' || *d != '\0')
1345 goto fail;
1347 if (!(mod = find_module(modname))) {
1348 if (is_vmlinux(modname)) {
1349 have_vmlinux = 1;
1351 mod = new_module(NOFAIL(strdup(modname)));
1352 mod->skip = 1;
1354 s = sym_add_exported(symname, mod, export_no(export));
1355 s->kernel = kernel;
1356 s->preloaded = 1;
1357 sym_update_crc(symname, mod, crc, export_no(export));
1359 return;
1360 fail:
1361 fatal("parse error in symbol dump file\n");
1364 /* For normal builds always dump all symbols.
1365 * For external modules only dump symbols
1366 * that are not read from kernel Module.symvers.
1367 **/
1368 static int dump_sym(struct symbol *sym)
1370 if (!external_module)
1371 return 1;
1372 if (sym->vmlinux || sym->kernel)
1373 return 0;
1374 return 1;
1377 static void write_dump(const char *fname)
1379 struct buffer buf = { };
1380 struct symbol *symbol;
1381 int n;
1383 for (n = 0; n < SYMBOL_HASH_SIZE ; n++) {
1384 symbol = symbolhash[n];
1385 while (symbol) {
1386 if (dump_sym(symbol))
1387 buf_printf(&buf, "0x%08x\t%s\t%s\t%s\n",
1388 symbol->crc, symbol->name,
1389 symbol->module->name,
1390 export_str(symbol->export));
1391 symbol = symbol->next;
1394 write_if_changed(&buf, fname);
1397 int main(int argc, char **argv)
1399 struct module *mod;
1400 struct buffer buf = { };
1401 char fname[SZ];
1402 char *kernel_read = NULL, *module_read = NULL;
1403 char *dump_write = NULL;
1404 int opt;
1406 while ((opt = getopt(argc, argv, "i:I:mo:a")) != -1) {
1407 switch(opt) {
1408 case 'i':
1409 kernel_read = optarg;
1410 break;
1411 case 'I':
1412 module_read = optarg;
1413 external_module = 1;
1414 break;
1415 case 'm':
1416 modversions = 1;
1417 break;
1418 case 'o':
1419 dump_write = optarg;
1420 break;
1421 case 'a':
1422 all_versions = 1;
1423 break;
1424 default:
1425 exit(1);
1429 if (kernel_read)
1430 read_dump(kernel_read, 1);
1431 if (module_read)
1432 read_dump(module_read, 0);
1434 while (optind < argc) {
1435 read_symbols(argv[optind++]);
1438 for (mod = modules; mod; mod = mod->next) {
1439 if (mod->skip)
1440 continue;
1441 check_exports(mod);
1444 for (mod = modules; mod; mod = mod->next) {
1445 if (mod->skip)
1446 continue;
1448 buf.pos = 0;
1450 add_header(&buf, mod);
1451 add_versions(&buf, mod);
1452 add_depends(&buf, mod, modules);
1453 add_moddevtable(&buf, mod);
1454 add_srcversion(&buf, mod);
1456 sprintf(fname, "%s.mod.c", mod->name);
1457 write_if_changed(&buf, fname);
1460 if (dump_write)
1461 write_dump(dump_write);
1463 return 0;