Merge master.kernel.org:/pub/scm/linux/kernel/git/sam/kbuild

* master.kernel.org:/pub/scm/linux/kernel/git/sam/kbuild: (46 commits)
  kbuild: remove obsoleted scripts/reference_* files
  kbuild: fix make help & make *pkg
  kconfig: fix time ordering of writes to .kconfig.d and include/linux/autoconf.h
  Kconfig: remove the CONFIG_CC_ALIGN_* options
  kbuild: add -fverbose-asm to i386 Makefile
  kbuild: clean-up genksyms
  kbuild: Lindent genksyms.c
  kbuild: fix genksyms build error
  kbuild: in makefile.txt note that Makefile is preferred name for kbuild files
  kbuild: replace PHONY with FORCE
  kbuild: Fix bug in crc symbol generating of kernel and modules
  kbuild: change kbuild to not rely on incorrect GNU make behavior
  kbuild: when warning symbols exported twice now tell user this is the problem
  kbuild: fix make dir/file.xx when asm symlink is missing
  kbuild: in the section mismatch check try harder to find symbols
  kbuild: fix section mismatch check for unwind on IA64
  kbuild: kill false positives from section mismatch warnings for powerpc
  kbuild: kill trailing whitespace in modpost & friends
  kbuild: small update of allnoconfig description
  kbuild: make namespace.pl CROSS_COMPILE happy
  ...

Trivial conflict in arch/ppc/boot/Makefile manually fixed up

1 files changed, 562 insertions, 136 deletions

diff --git a/scripts/mod/modpost.c b/scripts/mod/modpost.c
index b8b2a560b26b..0b92ddff26fd 100644
--- a/scripts/mod/modpost.c
+++ b/scripts/mod/modpost.c
@@ -2,7 +2,7 @@
  *
  * Copyright 2003       Kai Germaschewski
  * Copyright 2002-2004  Rusty Russell, IBM Corporation
- *
+ * Copyright 2006       Sam Ravnborg
  * Based in part on module-init-tools/depmod.c,file2alias
  *
  * This software may be used and distributed according to the terms
@@ -20,9 +20,10 @@ int modversions = 0;
 int have_vmlinux = 0;
 /* Is CONFIG_MODULE_SRCVERSION_ALL set? */
 static int all_versions = 0;
+/* If we are modposting external module set to 1 */
+static int external_module = 0;
 
-void
-fatal(const char *fmt, ...)
+void fatal(const char *fmt, ...)
 {
         va_list arglist;
 
@@ -35,8 +36,7 @@ fatal(const char *fmt, ...)
         exit(1);
 }
 
-void
-warn(const char *fmt, ...)
+void warn(const char *fmt, ...)
 {
         va_list arglist;
 
@@ -47,6 +47,18 @@ warn(const char *fmt, ...)
         va_end(arglist);
 }
 
+static int is_vmlinux(const char *modname)
+{
+        const char *myname;
+
+        if ((myname = strrchr(modname, '/')))
+                myname++;
+        else
+                myname = modname;
+
+        return strcmp(myname, "vmlinux") == 0;
+}
+
 void *do_nofail(void *ptr, const char *expr)
 {
         if (!ptr) {
@@ -59,8 +71,7 @@ void *do_nofail(void *ptr, const char *expr)
 
 static struct module *modules;
 
-struct module *
-find_module(char *modname)
+static struct module *find_module(char *modname)
 {
         struct module *mod;
 
@@ -70,12 +81,11 @@ find_module(char *modname)
         return mod;
 }
 
-struct module *
-new_module(char *modname)
+static struct module *new_module(char *modname)
 {
         struct module *mod;
         char *p, *s;
-        
+
         mod = NOFAIL(malloc(sizeof(*mod)));
         memset(mod, 0, sizeof(*mod));
         p = NOFAIL(strdup(modname));
@@ -104,6 +114,10 @@ struct symbol {
         unsigned int crc;
         int crc_valid;
         unsigned int weak:1;
+        unsigned int vmlinux:1;    /* 1 if symbol is defined in vmlinux */
+        unsigned int kernel:1;     /* 1 if symbol is from kernel
+                                    *  (only for external modules) **/
+        unsigned int preloaded:1;  /* 1 if symbol from Module.symvers */
         char name[0];
 };
 
@@ -122,11 +136,12 @@ static inline unsigned int tdb_hash(const char *name)
         return (1103515243 * value + 12345);
 }
 
-/* Allocate a new symbols for use in the hash of exported symbols or
- * the list of unresolved symbols per module */
-
-struct symbol *
-alloc_symbol(const char *name, unsigned int weak, struct symbol *next)
+/**
+ * Allocate a new symbols for use in the hash of exported symbols or
+ * the list of unresolved symbols per module
+ **/
+static struct symbol *alloc_symbol(const char *name, unsigned int weak,
+                                   struct symbol *next)
 {
         struct symbol *s = NOFAIL(malloc(sizeof(*s) + strlen(name) + 1));
 
@@ -138,9 +153,7 @@ alloc_symbol(const char *name, unsigned int weak, struct symbol *next)
 }
 
 /* For the hash of exported symbols */
-
-void
-new_symbol(const char *name, struct module *module, unsigned int *crc)
+static struct symbol *new_symbol(const char *name, struct module *module)
 {
         unsigned int hash;
         struct symbol *new;
@@ -148,14 +161,10 @@ new_symbol(const char *name, struct module *module, unsigned int *crc)
         hash = tdb_hash(name) % SYMBOL_HASH_SIZE;
         new = symbolhash[hash] = alloc_symbol(name, 0, symbolhash[hash]);
         new->module = module;
-        if (crc) {
-                new->crc = *crc;
-                new->crc_valid = 1;
-        }
+        return new;
 }
 
-struct symbol *
-find_symbol(const char *name)
+static struct symbol *find_symbol(const char *name)
 {
         struct symbol *s;
 
@@ -170,25 +179,42 @@ find_symbol(const char *name)
         return NULL;
 }
 
-/* Add an exported symbol - it may have already been added without a
- * CRC, in this case just update the CRC */
-void
-add_exported_symbol(const char *name, struct module *module, unsigned int *crc)
+/**
+ * Add an exported symbol - it may have already been added without a
+ * CRC, in this case just update the CRC
+ **/
+static struct symbol *sym_add_exported(const char *name, struct module *mod)
 {
         struct symbol *s = find_symbol(name);
 
         if (!s) {
-                new_symbol(name, module, crc);
-                return;
-        }
-        if (crc) {
-                s->crc = *crc;
-                s->crc_valid = 1;
+                s = new_symbol(name, mod);
+        } else {
+                if (!s->preloaded) {
+                        warn("%s: '%s' exported twice. Previous export "
+                             "was in %s%s\n", mod->name, name,
+                             s->module->name,
+                             is_vmlinux(s->module->name) ?"":".ko");
+                }
         }
+        s->preloaded = 0;
+        s->vmlinux   = is_vmlinux(mod->name);
+        s->kernel    = 0;
+        return s;
+}
+
+static void sym_update_crc(const char *name, struct module *mod,
+                           unsigned int crc)
+{
+        struct symbol *s = find_symbol(name);
+
+        if (!s)
+                s = new_symbol(name, mod);
+        s->crc = crc;
+        s->crc_valid = 1;
 }
 
-void *
-grab_file(const char *filename, unsigned long *size)
+void *grab_file(const char *filename, unsigned long *size)
 {
         struct stat st;
         void *map;
@@ -207,13 +233,12 @@ grab_file(const char *filename, unsigned long *size)
         return map;
 }
 
-/*
-   Return a copy of the next line in a mmap'ed file.
-   spaces in the beginning of the line is trimmed away.
-   Return a pointer to a static buffer.
-*/
-char*
-get_next_line(unsigned long *pos, void *file, unsigned long size)
+/**
+  * Return a copy of the next line in a mmap'ed file.
+  * spaces in the beginning of the line is trimmed away.
+  * Return a pointer to a static buffer.
+  **/
+char* get_next_line(unsigned long *pos, void *file, unsigned long size)
 {
         static char line[4096];
         int skip = 1;
@@ -243,14 +268,12 @@ get_next_line(unsigned long *pos, void *file, unsigned long size)
         return NULL;
 }
 
-void
-release_file(void *file, unsigned long size)
+void release_file(void *file, unsigned long size)
 {
         munmap(file, size);
 }
 
-void
-parse_elf(struct elf_info *info, const char *filename)
+static void parse_elf(struct elf_info *info, const char *filename)
 {
         unsigned int i;
         Elf_Ehdr *hdr = info->hdr;
@@ -297,14 +320,13 @@ parse_elf(struct elf_info *info, const char *filename)
                         continue;
 
                 info->symtab_start = (void *)hdr + sechdrs[i].sh_offset;
-                info->symtab_stop  = (void *)hdr + sechdrs[i].sh_offset 
+                info->symtab_stop  = (void *)hdr + sechdrs[i].sh_offset
                                                  + sechdrs[i].sh_size;
-                info->strtab       = (void *)hdr + 
+                info->strtab       = (void *)hdr +
                                      sechdrs[sechdrs[i].sh_link].sh_offset;
         }
         if (!info->symtab_start) {
-                fprintf(stderr, "modpost: %s no symtab?\n", filename);
-                abort();
+                fatal("%s has no symtab?\n", filename);
         }
         /* Fix endianness in symbols */
         for (sym = info->symtab_start; sym < info->symtab_stop; sym++) {
@@ -316,36 +338,31 @@ parse_elf(struct elf_info *info, const char *filename)
         return;
 
  truncated:
-        fprintf(stderr, "modpost: %s is truncated.\n", filename);
-        abort();
+        fatal("%s is truncated.\n", filename);
 }
 
-void
-parse_elf_finish(struct elf_info *info)
+static void parse_elf_finish(struct elf_info *info)
 {
         release_file(info->hdr, info->size);
 }
 
-#define CRC_PFX     "__crc_"
-#define KSYMTAB_PFX "__ksymtab_"
+#define CRC_PFX     MODULE_SYMBOL_PREFIX "__crc_"
+#define KSYMTAB_PFX MODULE_SYMBOL_PREFIX "__ksymtab_"
 
-void
-handle_modversions(struct module *mod, struct elf_info *info,
-                   Elf_Sym *sym, const char *symname)
+static void handle_modversions(struct module *mod, struct elf_info *info,
+                               Elf_Sym *sym, const char *symname)
 {
         unsigned int crc;
 
         switch (sym->st_shndx) {
         case SHN_COMMON:
-                fprintf(stderr, "*** Warning: \"%s\" [%s] is COMMON symbol\n",
-                        symname, mod->name);
+                warn("\"%s\" [%s] is COMMON symbol\n", symname, mod->name);
                 break;
         case SHN_ABS:
                 /* CRC'd symbol */
                 if (memcmp(symname, CRC_PFX, strlen(CRC_PFX)) == 0) {
                         crc = (unsigned int) sym->st_value;
-                        add_exported_symbol(symname + strlen(CRC_PFX),
-                                            mod, &crc);
+                        sym_update_crc(symname + strlen(CRC_PFX), mod, crc);
                 }
                 break;
         case SHN_UNDEF:
@@ -370,15 +387,15 @@ handle_modversions(struct module *mod, struct elf_info *info,
                         /* Ignore register directives. */
                         if (ELF_ST_TYPE(sym->st_info) == STT_SPARC_REGISTER)
                                 break;
-                        if (symname[0] == '.') {
-                                char *munged = strdup(symname);
-                                munged[0] = '_';
-                                munged[1] = toupper(munged[1]);
-                                symname = munged;
-                        }
+                        if (symname[0] == '.') {
+                                char *munged = strdup(symname);
+                                munged[0] = '_';
+                                munged[1] = toupper(munged[1]);
+                                symname = munged;
+                        }
                 }
 #endif
-                
+
                 if (memcmp(symname, MODULE_SYMBOL_PREFIX,
                            strlen(MODULE_SYMBOL_PREFIX)) == 0)
                         mod->unres = alloc_symbol(symname +
@@ -389,8 +406,7 @@ handle_modversions(struct module *mod, struct elf_info *info,
         default:
                 /* All exported symbols */
                 if (memcmp(symname, KSYMTAB_PFX, strlen(KSYMTAB_PFX)) == 0) {
-                        add_exported_symbol(symname + strlen(KSYMTAB_PFX),
-                                            mod, NULL);
+                        sym_add_exported(symname + strlen(KSYMTAB_PFX), mod);
                 }
                 if (strcmp(symname, MODULE_SYMBOL_PREFIX "init_module") == 0)
                         mod->has_init = 1;
@@ -400,20 +416,9 @@ handle_modversions(struct module *mod, struct elf_info *info,
         }
 }
 
-int
-is_vmlinux(const char *modname)
-{
-        const char *myname;
-
-        if ((myname = strrchr(modname, '/')))
-                myname++;
-        else
-                myname = modname;
-
-        return strcmp(myname, "vmlinux") == 0;
-}
-
-/* Parse tag=value strings from .modinfo section */
+/**
+ * Parse tag=value strings from .modinfo section
+ **/
 static char *next_string(char *string, unsigned long *secsize)
 {
         /* Skip non-zero chars */
@@ -446,8 +451,418 @@ static char *get_modinfo(void *modinfo, unsigned long modinfo_len,
         return NULL;
 }
 
-void
-read_symbols(char *modname)
+/**
+ * Test if string s ends in string sub
+ * return 0 if match
+ **/
+static int strrcmp(const char *s, const char *sub)
+{
+        int slen, sublen;
+
+        if (!s || !sub)
+                return 1;
+
+        slen = strlen(s);
+        sublen = strlen(sub);
+
+        if ((slen == 0) || (sublen == 0))
+                return 1;
+
+        if (sublen > slen)
+                return 1;
+
+        return memcmp(s + slen - sublen, sub, sublen);
+}
+
+/**
+ * Whitelist to allow certain references to pass with no warning.
+ * Pattern 1:
+ *   If a module parameter is declared __initdata and permissions=0
+ *   then this is legal despite the warning generated.
+ *   We cannot see value of permissions here, so just ignore
+ *   this pattern.
+ *   The pattern is identified by:
+ *   tosec   = .init.data
+ *   fromsec = .data*
+ *   atsym   =__param*
+ *
+ * Pattern 2:
+ *   Many drivers utilise a *_driver container with references to
+ *   add, remove, probe functions etc.
+ *   These functions may often be marked __init and we do not want to
+ *   warn here.
+ *   the pattern is identified by:
+ *   tosec   = .init.text | .exit.text
+ *   fromsec = .data
+ *   atsym = *_driver, *_ops, *_probe, *probe_one
+ **/
+static int secref_whitelist(const char *tosec, const char *fromsec,
+                          const char *atsym)
+{
+        int f1 = 1, f2 = 1;
+        const char **s;
+        const char *pat2sym[] = {
+                "_driver",
+                "_ops",
+                "_probe",
+                "_probe_one",
+                NULL
+        };
+
+        /* Check for pattern 1 */
+        if (strcmp(tosec, ".init.data") != 0)
+                f1 = 0;
+        if (strncmp(fromsec, ".data", strlen(".data")) != 0)
+                f1 = 0;
+        if (strncmp(atsym, "__param", strlen("__param")) != 0)
+                f1 = 0;
+
+        if (f1)
+                return f1;
+
+        /* Check for pattern 2 */
+        if ((strcmp(tosec, ".init.text") != 0) &&
+            (strcmp(tosec, ".exit.text") != 0))
+                f2 = 0;
+        if (strcmp(fromsec, ".data") != 0)
+                f2 = 0;
+
+        for (s = pat2sym; *s; s++)
+                if (strrcmp(atsym, *s) == 0)
+                        f1 = 1;
+
+        return f1 && f2;
+}
+
+/**
+ * Find symbol based on relocation record info.
+ * In some cases the symbol supplied is a valid symbol so
+ * return refsym. If st_name != 0 we assume this is a valid symbol.
+ * In other cases the symbol needs to be looked up in the symbol table
+ * based on section and address.
+ *  **/
+static Elf_Sym *find_elf_symbol(struct elf_info *elf, Elf_Addr addr,
+                                Elf_Sym *relsym)
+{
+        Elf_Sym *sym;
+
+        if (relsym->st_name != 0)
+                return relsym;
+        for (sym = elf->symtab_start; sym < elf->symtab_stop; sym++) {
+                if (sym->st_shndx != relsym->st_shndx)
+                        continue;
+                if (sym->st_value == addr)
+                        return sym;
+        }
+        return NULL;
+}
+
+/*
+ * Find symbols before or equal addr and after addr - in the section sec.
+ * If we find two symbols with equal offset prefer one with a valid name.
+ * The ELF format may have a better way to detect what type of symbol
+ * it is, but this works for now.
+ **/
+static void find_symbols_between(struct elf_info *elf, Elf_Addr addr,
+                                 const char *sec,
+                                 Elf_Sym **before, Elf_Sym **after)
+{
+        Elf_Sym *sym;
+        Elf_Ehdr *hdr = elf->hdr;
+        Elf_Addr beforediff = ~0;
+        Elf_Addr afterdiff = ~0;
+        const char *secstrings = (void *)hdr +
+                                 elf->sechdrs[hdr->e_shstrndx].sh_offset;
+
+        *before = NULL;
+        *after = NULL;
+
+        for (sym = elf->symtab_start; sym < elf->symtab_stop; sym++) {
+                const char *symsec;
+
+                if (sym->st_shndx >= SHN_LORESERVE)
+                        continue;
+                symsec = secstrings + elf->sechdrs[sym->st_shndx].sh_name;
+                if (strcmp(symsec, sec) != 0)
+                        continue;
+                if (sym->st_value <= addr) {
+                        if ((addr - sym->st_value) < beforediff) {
+                                beforediff = addr - sym->st_value;
+                                *before = sym;
+                        }
+                        else if ((addr - sym->st_value) == beforediff) {
+                                /* equal offset, valid name? */
+                                const char *name = elf->strtab + sym->st_name;
+                                if (name && strlen(name))
+                                        *before = sym;
+                        }
+                }
+                else
+                {
+                        if ((sym->st_value - addr) < afterdiff) {
+                                afterdiff = sym->st_value - addr;
+                                *after = sym;
+                        }
+                        else if ((sym->st_value - addr) == afterdiff) {
+                                /* equal offset, valid name? */
+                                const char *name = elf->strtab + sym->st_name;
+                                if (name && strlen(name))
+                                        *after = sym;
+                        }
+                }
+        }
+}
+
+/**
+ * Print a warning about a section mismatch.
+ * Try to find symbols near it so user can find it.
+ * Check whitelist before warning - it may be a false positive.
+ **/
+static void warn_sec_mismatch(const char *modname, const char *fromsec,
+                              struct elf_info *elf, Elf_Sym *sym, Elf_Rela r)
+{
+        const char *refsymname = "";
+        Elf_Sym *before, *after;
+        Elf_Sym *refsym;
+        Elf_Ehdr *hdr = elf->hdr;
+        Elf_Shdr *sechdrs = elf->sechdrs;
+        const char *secstrings = (void *)hdr +
+                                 sechdrs[hdr->e_shstrndx].sh_offset;
+        const char *secname = secstrings + sechdrs[sym->st_shndx].sh_name;
+
+        find_symbols_between(elf, r.r_offset, fromsec, &before, &after);
+
+        refsym = find_elf_symbol(elf, r.r_addend, sym);
+        if (refsym && strlen(elf->strtab + refsym->st_name))
+                refsymname = elf->strtab + refsym->st_name;
+
+        /* check whitelist - we may ignore it */
+        if (before &&
+            secref_whitelist(secname, fromsec, elf->strtab + before->st_name))
+                return;
+
+        if (before && after) {
+                warn("%s - Section mismatch: reference to %s:%s from %s "
+                     "between '%s' (at offset 0x%llx) and '%s'\n",
+                     modname, secname, refsymname, fromsec,
+                     elf->strtab + before->st_name,
+                     (long long)r.r_offset,
+                     elf->strtab + after->st_name);
+        } else if (before) {
+                warn("%s - Section mismatch: reference to %s:%s from %s "
+                     "after '%s' (at offset 0x%llx)\n",
+                     modname, secname, refsymname, fromsec,
+                     elf->strtab + before->st_name,
+                     (long long)r.r_offset);
+        } else if (after) {
+                warn("%s - Section mismatch: reference to %s:%s from %s "
+                     "before '%s' (at offset -0x%llx)\n",
+                     modname, secname, refsymname, fromsec,
+                     elf->strtab + before->st_name,
+                     (long long)r.r_offset);
+        } else {
+                warn("%s - Section mismatch: reference to %s:%s from %s "
+                     "(offset 0x%llx)\n",
+                     modname, secname, fromsec, refsymname,
+                     (long long)r.r_offset);
+        }
+}
+
+/**
+ * A module includes a number of sections that are discarded
+ * either when loaded or when used as built-in.
+ * For loaded modules all functions marked __init and all data
+ * marked __initdata will be discarded when the module has been intialized.
+ * Likewise for modules used built-in the sections marked __exit
+ * are discarded because __exit marked function are supposed to be called
+ * only when a moduel is unloaded which never happes for built-in modules.
+ * The check_sec_ref() function traverses all relocation records
+ * to find all references to a section that reference a section that will
+ * be discarded and warns about it.
+ **/
+static void check_sec_ref(struct module *mod, const char *modname,
+                          struct elf_info *elf,
+                          int section(const char*),
+                          int section_ref_ok(const char *))
+{
+        int i;
+        Elf_Sym  *sym;
+        Elf_Ehdr *hdr = elf->hdr;
+        Elf_Shdr *sechdrs = elf->sechdrs;
+        const char *secstrings = (void *)hdr +
+                                 sechdrs[hdr->e_shstrndx].sh_offset;
+
+        /* Walk through all sections */
+        for (i = 0; i < hdr->e_shnum; i++) {
+                Elf_Rela *rela;
+                Elf_Rela *start = (void *)hdr + sechdrs[i].sh_offset;
+                Elf_Rela *stop  = (void*)start + sechdrs[i].sh_size;
+                const char *name = secstrings + sechdrs[i].sh_name +
+                                                strlen(".rela");
+                /* We want to process only relocation sections and not .init */
+                if (section_ref_ok(name) || (sechdrs[i].sh_type != SHT_RELA))
+                        continue;
+
+                for (rela = start; rela < stop; rela++) {
+                        Elf_Rela r;
+                        const char *secname;
+                        r.r_offset = TO_NATIVE(rela->r_offset);
+                        r.r_info   = TO_NATIVE(rela->r_info);
+                        r.r_addend = TO_NATIVE(rela->r_addend);
+                        sym = elf->symtab_start + ELF_R_SYM(r.r_info);
+                        /* Skip special sections */
+                        if (sym->st_shndx >= SHN_LORESERVE)
+                                continue;
+
+                        secname = secstrings + sechdrs[sym->st_shndx].sh_name;
+                        if (section(secname))
+                                warn_sec_mismatch(modname, name, elf, sym, r);
+                }
+        }
+}
+
+/**
+ * Functions used only during module init is marked __init and is stored in
+ * a .init.text section. Likewise data is marked __initdata and stored in
+ * a .init.data section.
+ * If this section is one of these sections return 1
+ * See include/linux/init.h for the details
+ **/
+static int init_section(const char *name)
+{
+        if (strcmp(name, ".init") == 0)
+                return 1;
+        if (strncmp(name, ".init.", strlen(".init.")) == 0)
+                return 1;
+        return 0;
+}
+
+/**
+ * Identify sections from which references to a .init section is OK.
+ *
+ * Unfortunately references to read only data that referenced .init
+ * sections had to be excluded. Almost all of these are false
+ * positives, they are created by gcc. The downside of excluding rodata
+ * is that there really are some user references from rodata to
+ * init code, e.g. drivers/video/vgacon.c:
+ *
+ * const struct consw vga_con = {
+ *        con_startup:            vgacon_startup,
+ *
+ * where vgacon_startup is __init.  If you want to wade through the false
+ * positives, take out the check for rodata.
+ **/
+static int init_section_ref_ok(const char *name)
+{
+        const char **s;
+        /* Absolute section names */
+        const char *namelist1[] = {
+                ".init",
+                ".opd",   /* see comment [OPD] at exit_section_ref_ok() */
+                ".toc1",  /* used by ppc64 */
+                ".stab",
+                ".rodata",
+                ".text.lock",
+                "__bug_table", /* used by powerpc for BUG() */
+                ".pci_fixup_header",
+                ".pci_fixup_final",
+                ".pdr",
+                "__param",
+                NULL
+        };
+        /* Start of section names */
+        const char *namelist2[] = {
+                ".init.",
+                ".altinstructions",
+                ".eh_frame",
+                ".debug",
+                NULL
+        };
+        /* part of section name */
+        const char *namelist3 [] = {
+                ".unwind",  /* sample: IA_64.unwind.init.text */
+                NULL
+        };
+
+        for (s = namelist1; *s; s++)
+                if (strcmp(*s, name) == 0)
+                        return 1;
+        for (s = namelist2; *s; s++)
+                if (strncmp(*s, name, strlen(*s)) == 0)
+                        return 1;
+        for (s = namelist3; *s; s++)
+                if (strstr(name, *s) != NULL)
+                        return 1;
+        return 0;
+}
+
+/*
+ * Functions used only during module exit is marked __exit and is stored in
+ * a .exit.text section. Likewise data is marked __exitdata and stored in
+ * a .exit.data section.
+ * If this section is one of these sections return 1
+ * See include/linux/init.h for the details
+ **/
+static int exit_section(const char *name)
+{
+        if (strcmp(name, ".exit.text") == 0)
+                return 1;
+        if (strcmp(name, ".exit.data") == 0)
+                return 1;
+        return 0;
+
+}
+
+/*
+ * Identify sections from which references to a .exit section is OK.
+ *
+ * [OPD] Keith Ownes <kaos@sgi.com> commented:
+ * For our future {in}sanity, add a comment that this is the ppc .opd
+ * section, not the ia64 .opd section.
+ * ia64 .opd should not point to discarded sections.
+ **/
+static int exit_section_ref_ok(const char *name)
+{
+        const char **s;
+        /* Absolute section names */
+        const char *namelist1[] = {
+                ".exit.text",
+                ".exit.data",
+                ".init.text",
+                ".opd", /* See comment [OPD] */
+                ".toc1",  /* used by ppc64 */
+                ".altinstructions",
+                ".pdr",
+                "__bug_table", /* used by powerpc for BUG() */
+                ".exitcall.exit",
+                ".eh_frame",
+                ".stab",
+                NULL
+        };
+        /* Start of section names */
+        const char *namelist2[] = {
+                ".debug",
+                NULL
+        };
+        /* part of section name */
+        const char *namelist3 [] = {
+                ".unwind",  /* Sample: IA_64.unwind.exit.text */
+                NULL
+        };
+
+        for (s = namelist1; *s; s++)
+                if (strcmp(*s, name) == 0)
+                        return 1;
+        for (s = namelist2; *s; s++)
+                if (strncmp(*s, name, strlen(*s)) == 0)
+                        return 1;
+        for (s = namelist3; *s; s++)
+                if (strstr(name, *s) != NULL)
+                        return 1;
+        return 0;
+}
+
+static void read_symbols(char *modname)
 {
         const char *symname;
         char *version;
@@ -462,9 +877,7 @@ read_symbols(char *modname)
         /* When there's no vmlinux, don't print warnings about
          * unresolved symbols (since there'll be too many ;) */
         if (is_vmlinux(modname)) {
-                unsigned int fake_crc = 0;
                 have_vmlinux = 1;
-                add_exported_symbol("struct_module", mod, &fake_crc);
                 mod->skip = 1;
         }
 
@@ -474,6 +887,8 @@ read_symbols(char *modname)
                 handle_modversions(mod, &info, sym, symname);
                 handle_moddevtable(mod, &info, sym, symname);
         }
+        check_sec_ref(mod, modname, &info, init_section, init_section_ref_ok);
+        check_sec_ref(mod, modname, &info, exit_section, exit_section_ref_ok);
 
         version = get_modinfo(info.modinfo, info.modinfo_len, "version");
         if (version)
@@ -499,21 +914,20 @@ read_symbols(char *modname)
  * following helper, then compare to the file on disk and
  * only update the later if anything changed */
 
-void __attribute__((format(printf, 2, 3)))
-buf_printf(struct buffer *buf, const char *fmt, ...)
+void __attribute__((format(printf, 2, 3))) buf_printf(struct buffer *buf,
+                                                      const char *fmt, ...)
 {
         char tmp[SZ];
         int len;
         va_list ap;
-        
+
         va_start(ap, fmt);
         len = vsnprintf(tmp, SZ, fmt, ap);
         buf_write(buf, tmp, len);
         va_end(ap);
 }
 
-void
-buf_write(struct buffer *buf, const char *s, int len)
+void buf_write(struct buffer *buf, const char *s, int len)
 {
         if (buf->size - buf->pos < len) {
                 buf->size += len + SZ;
@@ -523,10 +937,10 @@ buf_write(struct buffer *buf, const char *s, int len)
         buf->pos += len;
 }
 
-/* Header for the generated file */
-
-void
-add_header(struct buffer *b, struct module *mod)
+/**
+ * Header for the generated file
+ **/
+static void add_header(struct buffer *b, struct module *mod)
 {
         buf_printf(b, "#include <linux/module.h>\n");
         buf_printf(b, "#include <linux/vermagic.h>\n");
@@ -546,10 +960,10 @@ add_header(struct buffer *b, struct module *mod)
         buf_printf(b, "};\n");
 }
 
-/* Record CRCs for unresolved symbols */
-
-void
-add_versions(struct buffer *b, struct module *mod)
+/**
+ * Record CRCs for unresolved symbols
+ **/
+static void add_versions(struct buffer *b, struct module *mod)
 {
         struct symbol *s, *exp;
 
@@ -557,8 +971,8 @@ add_versions(struct buffer *b, struct module *mod)
                 exp = find_symbol(s->name);
                 if (!exp || exp->module == mod) {
                         if (have_vmlinux && !s->weak)
-                                fprintf(stderr, "*** Warning: \"%s\" [%s.ko] "
-                                "undefined!\n", s->name, mod->name);
+                                warn("\"%s\" [%s.ko] undefined!\n",
+                                     s->name, mod->name);
                         continue;
                 }
                 s->module = exp->module;
@@ -579,8 +993,7 @@ add_versions(struct buffer *b, struct module *mod)
                         continue;
                 }
                 if (!s->crc_valid) {
-                        fprintf(stderr, "*** Warning: \"%s\" [%s.ko] "
-                                "has no CRC!\n",
+                        warn("\"%s\" [%s.ko] has no CRC!\n",
                                 s->name, mod->name);
                         continue;
                 }
@@ -590,8 +1003,8 @@ add_versions(struct buffer *b, struct module *mod)
         buf_printf(b, "};\n");
 }
 
-void
-add_depends(struct buffer *b, struct module *mod, struct module *modules)
+static void add_depends(struct buffer *b, struct module *mod,
+                        struct module *modules)
 {
         struct symbol *s;
         struct module *m;
@@ -621,8 +1034,7 @@ add_depends(struct buffer *b, struct module *mod, struct module *modules)
         buf_printf(b, "\";\n");
 }
 
-void
-add_srcversion(struct buffer *b, struct module *mod)
+static void add_srcversion(struct buffer *b, struct module *mod)
 {
         if (mod->srcversion[0]) {
                 buf_printf(b, "\n");
@@ -631,8 +1043,7 @@ add_srcversion(struct buffer *b, struct module *mod)
         }
 }
 
-void
-write_if_changed(struct buffer *b, const char *fname)
+static void write_if_changed(struct buffer *b, const char *fname)
 {
         char *tmp;
         FILE *file;
@@ -676,8 +1087,7 @@ write_if_changed(struct buffer *b, const char *fname)
         fclose(file);
 }
 
-void
-read_dump(const char *fname)
+static void read_dump(const char *fname, unsigned int kernel)
 {
         unsigned long size, pos = 0;
         void *file = grab_file(fname, &size);
@@ -691,6 +1101,7 @@ read_dump(const char *fname)
                 char *symname, *modname, *d;
                 unsigned int crc;
                 struct module *mod;
+                struct symbol *s;
 
                 if (!(symname = strchr(line, '\t')))
                         goto fail;
@@ -711,15 +1122,30 @@ read_dump(const char *fname)
                         mod = new_module(NOFAIL(strdup(modname)));
                         mod->skip = 1;
                 }
-                add_exported_symbol(symname, mod, &crc);
+                s = sym_add_exported(symname, mod);
+                s->kernel    = kernel;
+                s->preloaded = 1;
+                sym_update_crc(symname, mod, crc);
         }
         return;
 fail:
         fatal("parse error in symbol dump file\n");
 }
 
-void
-write_dump(const char *fname)
+/* For normal builds always dump all symbols.
+ * For external modules only dump symbols
+ * that are not read from kernel Module.symvers.
+ **/
+static int dump_sym(struct symbol *sym)
+{
+        if (!external_module)
+                return 1;
+        if (sym->vmlinux || sym->kernel)
+                return 0;
+        return 1;
+}
+
+static void write_dump(const char *fname)
 {
         struct buffer buf = { };
         struct symbol *symbol;
@@ -728,34 +1154,33 @@ write_dump(const char *fname)
         for (n = 0; n < SYMBOL_HASH_SIZE ; n++) {
                 symbol = symbolhash[n];
                 while (symbol) {
-                        symbol = symbol->next;
-                }
-        }
-
-        for (n = 0; n < SYMBOL_HASH_SIZE ; n++) {
-                symbol = symbolhash[n];
-                while (symbol) {
-                        buf_printf(&buf, "0x%08x\t%s\t%s\n", symbol->crc,
-                                symbol->name, symbol->module->name);
+                        if (dump_sym(symbol))
+                                buf_printf(&buf, "0x%08x\t%s\t%s\n",
+                                        symbol->crc, symbol->name,
+                                        symbol->module->name);
                         symbol = symbol->next;
                 }
         }
         write_if_changed(&buf, fname);
 }
 
-int
-main(int argc, char **argv)
+int main(int argc, char **argv)
 {
         struct module *mod;
         struct buffer buf = { };
         char fname[SZ];
-        char *dump_read = NULL, *dump_write = NULL;
+        char *kernel_read = NULL, *module_read = NULL;
+        char *dump_write = NULL;
         int opt;
 
-        while ((opt = getopt(argc, argv, "i:mo:a")) != -1) {
+        while ((opt = getopt(argc, argv, "i:I:mo:a")) != -1) {
                 switch(opt) {
                         case 'i':
-                                dump_read = optarg;
+                                kernel_read = optarg;
+                                break;
+                        case 'I':
+                                module_read = optarg;
+                                external_module = 1;
                                 break;
                         case 'm':
                                 modversions = 1;
@@ -771,8 +1196,10 @@ main(int argc, char **argv)
                 }
         }
 
-        if (dump_read)
-                read_dump(dump_read);
+        if (kernel_read)
+                read_dump(kernel_read, 1);
+        if (module_read)
+                read_dump(module_read, 0);
 
         while (optind < argc) {
                 read_symbols(argv[optind++]);
@@ -799,4 +1226,3 @@ main(int argc, char **argv)
 
         return 0;
 }
-