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