2 files changed, 94 insertions, 76 deletions

diff --git a/scripts/mod/file2alias.c b/scripts/mod/file2alias.c
index a3344285ccf4..40e0045876ee 100644
--- a/scripts/mod/file2alias.c
+++ b/scripts/mod/file2alias.c
@@ -641,7 +641,7 @@ static int do_virtio_entry(const char *filename, struct virtio_device_id *id,
         id->vendor = TO_NATIVE(id->vendor);
 
         strcpy(alias, "virtio:");
-        ADD(alias, "d", 1, id->device);
+        ADD(alias, "d", id->device != VIRTIO_DEV_ANY_ID, id->device);
         ADD(alias, "v", id->vendor != VIRTIO_DEV_ANY_ID, id->vendor);
 
         add_wildcard(alias);
diff --git a/scripts/mod/modpost.c b/scripts/mod/modpost.c
index df6e6286a065..4522948a012e 100644
--- a/scripts/mod/modpost.c
+++ b/scripts/mod/modpost.c
@@ -384,11 +384,19 @@ static int parse_elf(struct elf_info *info, const char *filename)
                 return 0;
         }
         /* Fix endianness in ELF header */
-        hdr->e_shoff    = TO_NATIVE(hdr->e_shoff);
-        hdr->e_shstrndx = TO_NATIVE(hdr->e_shstrndx);
-        hdr->e_shnum    = TO_NATIVE(hdr->e_shnum);
-        hdr->e_machine  = TO_NATIVE(hdr->e_machine);
-        hdr->e_type     = TO_NATIVE(hdr->e_type);
+        hdr->e_type      = TO_NATIVE(hdr->e_type);
+        hdr->e_machine   = TO_NATIVE(hdr->e_machine);
+        hdr->e_version   = TO_NATIVE(hdr->e_version);
+        hdr->e_entry     = TO_NATIVE(hdr->e_entry);
+        hdr->e_phoff     = TO_NATIVE(hdr->e_phoff);
+        hdr->e_shoff     = TO_NATIVE(hdr->e_shoff);
+        hdr->e_flags     = TO_NATIVE(hdr->e_flags);
+        hdr->e_ehsize    = TO_NATIVE(hdr->e_ehsize);
+        hdr->e_phentsize = TO_NATIVE(hdr->e_phentsize);
+        hdr->e_phnum     = TO_NATIVE(hdr->e_phnum);
+        hdr->e_shentsize = TO_NATIVE(hdr->e_shentsize);
+        hdr->e_shnum     = TO_NATIVE(hdr->e_shnum);
+        hdr->e_shstrndx  = TO_NATIVE(hdr->e_shstrndx);
         sechdrs = (void *)hdr + hdr->e_shoff;
         info->sechdrs = sechdrs;
 
@@ -402,13 +410,16 @@ static int parse_elf(struct elf_info *info, const char *filename)
 
         /* Fix endianness in section headers */
         for (i = 0; i < hdr->e_shnum; i++) {
-                sechdrs[i].sh_type   = TO_NATIVE(sechdrs[i].sh_type);
-                sechdrs[i].sh_offset = TO_NATIVE(sechdrs[i].sh_offset);
-                sechdrs[i].sh_size   = TO_NATIVE(sechdrs[i].sh_size);
-                sechdrs[i].sh_link   = TO_NATIVE(sechdrs[i].sh_link);
-                sechdrs[i].sh_name   = TO_NATIVE(sechdrs[i].sh_name);
-                sechdrs[i].sh_info   = TO_NATIVE(sechdrs[i].sh_info);
-                sechdrs[i].sh_addr   = TO_NATIVE(sechdrs[i].sh_addr);
+                sechdrs[i].sh_name      = TO_NATIVE(sechdrs[i].sh_name);
+                sechdrs[i].sh_type      = TO_NATIVE(sechdrs[i].sh_type);
+                sechdrs[i].sh_flags     = TO_NATIVE(sechdrs[i].sh_flags);
+                sechdrs[i].sh_addr      = TO_NATIVE(sechdrs[i].sh_addr);
+                sechdrs[i].sh_offset    = TO_NATIVE(sechdrs[i].sh_offset);
+                sechdrs[i].sh_size      = TO_NATIVE(sechdrs[i].sh_size);
+                sechdrs[i].sh_link      = TO_NATIVE(sechdrs[i].sh_link);
+                sechdrs[i].sh_info      = TO_NATIVE(sechdrs[i].sh_info);
+                sechdrs[i].sh_addralign = TO_NATIVE(sechdrs[i].sh_addralign);
+                sechdrs[i].sh_entsize   = TO_NATIVE(sechdrs[i].sh_entsize);
         }
         /* Find symbol table. */
         for (i = 1; i < hdr->e_shnum; i++) {
@@ -716,46 +727,44 @@ int match(const char *sym, const char * const pat[])
 
 /* sections that we do not want to do full section mismatch check on */
 static const char *section_white_list[] =
-        { ".debug*", ".stab*", ".note*", ".got*", ".toc*", NULL };
+{
+        ".comment*",
+        ".debug*",
+        ".mdebug*",        /* alpha, score, mips etc. */
+        ".pdr",            /* alpha, score, mips etc. */
+        ".stab*",
+        ".note*",
+        ".got*",
+        ".toc*",
+        NULL
+};
 
 /*
- * Is this section one we do not want to check?
- * This is often debug sections.
- * If we are going to check this section then
- * test if section name ends with a dot and a number.
- * This is used to find sections where the linker have
- * appended a dot-number to make the name unique.
+ * This is used to find sections missing the SHF_ALLOC flag.
  * The cause of this is often a section specified in assembler
- * without "ax" / "aw" and the same section used in .c
- * code where gcc add these.
+ * without "ax" / "aw".
  */
-static int check_section(const char *modname, const char *sec)
-{
-        const char *e = sec + strlen(sec) - 1;
-        if (match(sec, section_white_list))
-                return 1;
-
-        if (*e && isdigit(*e)) {
-                /* consume all digits */
-                while (*e && e != sec && isdigit(*e))
-                        e--;
-                if (*e == '.' && !strstr(sec, ".linkonce")) {
-                        warn("%s (%s): unexpected section name.\n"
-                             "The (.[number]+) following section name are "
-                             "ld generated and not expected.\n"
-                             "Did you forget to use \"ax\"/\"aw\" "
-                             "in a .S file?\n"
-                             "Note that for example <linux/init.h> contains\n"
-                             "section definitions for use in .S files.\n\n",
-                             modname, sec);
-                }
+static void check_section(const char *modname, struct elf_info *elf,
+                          Elf_Shdr *sechdr)
+{
+        const char *sec = sech_name(elf, sechdr);
+
+        if (sechdr->sh_type == SHT_PROGBITS &&
+            !(sechdr->sh_flags & SHF_ALLOC) &&
+            !match(sec, section_white_list)) {
+                warn("%s (%s): unexpected non-allocatable section.\n"
+                     "Did you forget to use \"ax\"/\"aw\" in a .S file?\n"
+                     "Note that for example <linux/init.h> contains\n"
+                     "section definitions for use in .S files.\n\n",
+                     modname, sec);
         }
-        return 0;
 }
 
 
 
 #define ALL_INIT_DATA_SECTIONS \
+        ".init.setup$", ".init.rodata$", \
+        ".devinit.rodata$", ".cpuinit.rodata$", ".meminit.rodata$" \
         ".init.data$", ".devinit.data$", ".cpuinit.data$", ".meminit.data$"
 #define ALL_EXIT_DATA_SECTIONS \
         ".exit.data$", ".devexit.data$", ".cpuexit.data$", ".memexit.data$"
@@ -765,21 +774,23 @@ static int check_section(const char *modname, const char *sec)
 #define ALL_EXIT_TEXT_SECTIONS \
         ".exit.text$", ".devexit.text$", ".cpuexit.text$", ".memexit.text$"
 
-#define ALL_INIT_SECTIONS ALL_INIT_DATA_SECTIONS, ALL_INIT_TEXT_SECTIONS
-#define ALL_EXIT_SECTIONS ALL_EXIT_DATA_SECTIONS, ALL_EXIT_TEXT_SECTIONS
+#define ALL_INIT_SECTIONS INIT_SECTIONS, DEV_INIT_SECTIONS, \
+        CPU_INIT_SECTIONS, MEM_INIT_SECTIONS
+#define ALL_EXIT_SECTIONS EXIT_SECTIONS, DEV_EXIT_SECTIONS, \
+        CPU_EXIT_SECTIONS, MEM_EXIT_SECTIONS
 
 #define DATA_SECTIONS ".data$", ".data.rel$"
 #define TEXT_SECTIONS ".text$"
 
-#define INIT_SECTIONS      ".init.data$", ".init.text$"
-#define DEV_INIT_SECTIONS  ".devinit.data$", ".devinit.text$"
-#define CPU_INIT_SECTIONS  ".cpuinit.data$", ".cpuinit.text$"
-#define MEM_INIT_SECTIONS  ".meminit.data$", ".meminit.text$"
+#define INIT_SECTIONS      ".init.*"
+#define DEV_INIT_SECTIONS  ".devinit.*"
+#define CPU_INIT_SECTIONS  ".cpuinit.*"
+#define MEM_INIT_SECTIONS  ".meminit.*"
 
-#define EXIT_SECTIONS      ".exit.data$", ".exit.text$"
-#define DEV_EXIT_SECTIONS  ".devexit.data$", ".devexit.text$"
-#define CPU_EXIT_SECTIONS  ".cpuexit.data$", ".cpuexit.text$"
-#define MEM_EXIT_SECTIONS  ".memexit.data$", ".memexit.text$"
+#define EXIT_SECTIONS      ".exit.*"
+#define DEV_EXIT_SECTIONS  ".devexit.*"
+#define CPU_EXIT_SECTIONS  ".cpuexit.*"
+#define MEM_EXIT_SECTIONS  ".memexit.*"
 
 /* init data sections */
 static const char *init_data_sections[] = { ALL_INIT_DATA_SECTIONS, NULL };
@@ -794,15 +805,6 @@ static const char *init_exit_sections[] =
 /* data section */
 static const char *data_sections[] = { DATA_SECTIONS, NULL };
 
-/* sections that may refer to an init/exit section with no warning */
-static const char *initref_sections[] =
-{
-        ".text.init.refok*",
-        ".exit.text.refok*",
-        ".data.init.refok*",
-        NULL
-};
-
 
 /* symbols in .data that may refer to init/exit sections */
 static const char *symbol_white_list[] =
@@ -871,12 +873,36 @@ const struct sectioncheck sectioncheck[] = {
         .tosec   = { INIT_SECTIONS, NULL },
         .mismatch = XXXINIT_TO_INIT,
 },
+/* Do not reference cpuinit code/data from meminit code/data */
+{
+        .fromsec = { MEM_INIT_SECTIONS, NULL },
+        .tosec   = { CPU_INIT_SECTIONS, NULL },
+        .mismatch = XXXINIT_TO_INIT,
+},
+/* Do not reference meminit code/data from cpuinit code/data */
+{
+        .fromsec = { CPU_INIT_SECTIONS, NULL },
+        .tosec   = { MEM_INIT_SECTIONS, NULL },
+        .mismatch = XXXINIT_TO_INIT,
+},
 /* Do not reference exit code/data from devexit/cpuexit/memexit code/data */
 {
         .fromsec = { DEV_EXIT_SECTIONS, CPU_EXIT_SECTIONS, MEM_EXIT_SECTIONS, NULL },
         .tosec   = { EXIT_SECTIONS, NULL },
         .mismatch = XXXEXIT_TO_EXIT,
 },
+/* Do not reference cpuexit code/data from memexit code/data */
+{
+        .fromsec = { MEM_EXIT_SECTIONS, NULL },
+        .tosec   = { CPU_EXIT_SECTIONS, NULL },
+        .mismatch = XXXEXIT_TO_EXIT,
+},
+/* Do not reference memexit code/data from cpuexit code/data */
+{
+        .fromsec = { CPU_EXIT_SECTIONS, NULL },
+        .tosec   = { MEM_EXIT_SECTIONS, NULL },
+        .mismatch = XXXEXIT_TO_EXIT,
+},
 /* Do not use exit code/data from init code */
 {
         .fromsec = { ALL_INIT_SECTIONS, NULL },
@@ -915,11 +941,6 @@ static int section_mismatch(const char *fromsec, const char *tosec)
 /**
  * Whitelist to allow certain references to pass with no warning.
  *
- * Pattern 0:
- *   Do not warn if funtion/data are marked with __init_refok/__initdata_refok.
- *   The pattern is identified by:
- *   fromsec = .text.init.refok* | .data.init.refok*
- *
  * Pattern 1:
  *   If a module parameter is declared __initdata and permissions=0
  *   then this is legal despite the warning generated.
@@ -942,8 +963,7 @@ static int section_mismatch(const char *fromsec, const char *tosec)
  *           *probe_one, *_console, *_timer
  *
  * Pattern 3:
- *   Whitelist all refereces from .text.head to .init.data
- *   Whitelist all refereces from .text.head to .init.text
+ *   Whitelist all references from .head.text to any init section
  *
  * Pattern 4:
  *   Some symbols belong to init section but still it is ok to reference
@@ -958,10 +978,6 @@ static int section_mismatch(const char *fromsec, const char *tosec)
 static int secref_whitelist(const char *fromsec, const char *fromsym,
                             const char *tosec, const char *tosym)
 {
-        /* Check for pattern 0 */
-        if (match(fromsec, initref_sections))
-                return 0;
-
         /* Check for pattern 1 */
         if (match(tosec, init_data_sections) &&
             match(fromsec, data_sections) &&
@@ -1180,7 +1196,7 @@ static void report_sec_mismatch(const char *modname, enum mismatch mismatch,
                 "The variable %s references\n"
                 "the %s %s%s%s\n"
                 "If the reference is valid then annotate the\n"
-                "variable with __init* (see linux/init.h) "
+                "variable with __init* or __refdata (see linux/init.h) "
                 "or name the variable:\n",
                 fromsym, to, sec2annotation(tosec), tosym, to_p);
                 while (*s)
@@ -1377,7 +1393,7 @@ static void section_rela(const char *modname, struct elf_info *elf,
         fromsec = sech_name(elf, sechdr);
         fromsec += strlen(".rela");
         /* if from section (name) is know good then skip it */
-        if (check_section(modname, fromsec))
+        if (match(fromsec, section_white_list))
                 return;
 
         for (rela = start; rela < stop; rela++) {
@@ -1421,7 +1437,7 @@ static void section_rel(const char *modname, struct elf_info *elf,
         fromsec = sech_name(elf, sechdr);
         fromsec += strlen(".rel");
         /* if from section (name) is know good then skip it */
-        if (check_section(modname, fromsec))
+        if (match(fromsec, section_white_list))
                 return;
 
         for (rel = start; rel < stop; rel++) {
@@ -1484,6 +1500,7 @@ static void check_sec_ref(struct module *mod, const char *modname,
 
         /* Walk through all sections */
         for (i = 0; i < elf->hdr->e_shnum; i++) {
+                check_section(modname, elf, &elf->sechdrs[i]);
                 /* We want to process only relocation sections and not .init */
                 if (sechdrs[i].sh_type == SHT_RELA)
                         section_rela(modname, elf, &elf->sechdrs[i]);
@@ -2008,6 +2025,7 @@ static void read_markers(const char *fname)
                 if (!mod->skip)
                         add_marker(mod, marker, fmt);
         }
+        release_file(file, size);
         return;
 fail:
         fatal("parse error in markers list file\n");