Merge git://git.kernel.org/pub/scm/linux/kernel/git/rusty/linux-2.6-for-linus

* git://git.kernel.org/pub/scm/linux/kernel/git/rusty/linux-2.6-for-linus:
  module: don't call percpu_modfree on NULL pointer.
  module: fix memory leak when load fails after srcversion/version allocated
  module: preferred way to use MODULE_AUTHOR
  param: allow whitespace as kernel parameter separator
  module: reduce string table for loaded modules (v2)
  module: reduce symbol table for loaded modules (v2)

2 files changed, 153 insertions, 13 deletions

diff --git a/kernel/module.c b/kernel/module.c
index e6bc4b28aa62..5a29397ca4b6 100644
--- a/kernel/module.c
+++ b/kernel/module.c
@@ -1797,6 +1797,17 @@ static void setup_modinfo(struct module *mod, Elf_Shdr *sechdrs,
         }
 }
 
+static void free_modinfo(struct module *mod)
+{
+        struct module_attribute *attr;
+        int i;
+
+        for (i = 0; (attr = modinfo_attrs[i]); i++) {
+                if (attr->free)
+                        attr->free(mod);
+        }
+}
+
 #ifdef CONFIG_KALLSYMS
 
 /* lookup symbol in given range of kernel_symbols */
@@ -1862,13 +1873,93 @@ static char elf_type(const Elf_Sym *sym,
         return '?';
 }
 
+static bool is_core_symbol(const Elf_Sym *src, const Elf_Shdr *sechdrs,
+                           unsigned int shnum)
+{
+        const Elf_Shdr *sec;
+
+        if (src->st_shndx == SHN_UNDEF
+            || src->st_shndx >= shnum
+            || !src->st_name)
+                return false;
+
+        sec = sechdrs + src->st_shndx;
+        if (!(sec->sh_flags & SHF_ALLOC)
+#ifndef CONFIG_KALLSYMS_ALL
+            || !(sec->sh_flags & SHF_EXECINSTR)
+#endif
+            || (sec->sh_entsize & INIT_OFFSET_MASK))
+                return false;
+
+        return true;
+}
+
+static unsigned long layout_symtab(struct module *mod,
+                                   Elf_Shdr *sechdrs,
+                                   unsigned int symindex,
+                                   unsigned int strindex,
+                                   const Elf_Ehdr *hdr,
+                                   const char *secstrings,
+                                   unsigned long *pstroffs,
+                                   unsigned long *strmap)
+{
+        unsigned long symoffs;
+        Elf_Shdr *symsect = sechdrs + symindex;
+        Elf_Shdr *strsect = sechdrs + strindex;
+        const Elf_Sym *src;
+        const char *strtab;
+        unsigned int i, nsrc, ndst;
+
+        /* Put symbol section at end of init part of module. */
+        symsect->sh_flags |= SHF_ALLOC;
+        symsect->sh_entsize = get_offset(mod, &mod->init_size, symsect,
+                                         symindex) | INIT_OFFSET_MASK;
+        DEBUGP("\t%s\n", secstrings + symsect->sh_name);
+
+        src = (void *)hdr + symsect->sh_offset;
+        nsrc = symsect->sh_size / sizeof(*src);
+        strtab = (void *)hdr + strsect->sh_offset;
+        for (ndst = i = 1; i < nsrc; ++i, ++src)
+                if (is_core_symbol(src, sechdrs, hdr->e_shnum)) {
+                        unsigned int j = src->st_name;
+
+                        while(!__test_and_set_bit(j, strmap) && strtab[j])
+                                ++j;
+                        ++ndst;
+                }
+
+        /* Append room for core symbols at end of core part. */
+        symoffs = ALIGN(mod->core_size, symsect->sh_addralign ?: 1);
+        mod->core_size = symoffs + ndst * sizeof(Elf_Sym);
+
+        /* Put string table section at end of init part of module. */
+        strsect->sh_flags |= SHF_ALLOC;
+        strsect->sh_entsize = get_offset(mod, &mod->init_size, strsect,
+                                         strindex) | INIT_OFFSET_MASK;
+        DEBUGP("\t%s\n", secstrings + strsect->sh_name);
+
+        /* Append room for core symbols' strings at end of core part. */
+        *pstroffs = mod->core_size;
+        __set_bit(0, strmap);
+        mod->core_size += bitmap_weight(strmap, strsect->sh_size);
+
+        return symoffs;
+}
+
 static void add_kallsyms(struct module *mod,
                          Elf_Shdr *sechdrs,
+                         unsigned int shnum,
                          unsigned int symindex,
                          unsigned int strindex,
-                         const char *secstrings)
+                         unsigned long symoffs,
+                         unsigned long stroffs,
+                         const char *secstrings,
+                         unsigned long *strmap)
 {
-        unsigned int i;
+        unsigned int i, ndst;
+        const Elf_Sym *src;
+        Elf_Sym *dst;
+        char *s;
 
         mod->symtab = (void *)sechdrs[symindex].sh_addr;
         mod->num_symtab = sechdrs[symindex].sh_size / sizeof(Elf_Sym);
@@ -1878,13 +1969,44 @@ static void add_kallsyms(struct module *mod,
         for (i = 0; i < mod->num_symtab; i++)
                 mod->symtab[i].st_info
                         = elf_type(&mod->symtab[i], sechdrs, secstrings, mod);
+
+        mod->core_symtab = dst = mod->module_core + symoffs;
+        src = mod->symtab;
+        *dst = *src;
+        for (ndst = i = 1; i < mod->num_symtab; ++i, ++src) {
+                if (!is_core_symbol(src, sechdrs, shnum))
+                        continue;
+                dst[ndst] = *src;
+                dst[ndst].st_name = bitmap_weight(strmap, dst[ndst].st_name);
+                ++ndst;
+        }
+        mod->core_num_syms = ndst;
+
+        mod->core_strtab = s = mod->module_core + stroffs;
+        for (*s = 0, i = 1; i < sechdrs[strindex].sh_size; ++i)
+                if (test_bit(i, strmap))
+                        *++s = mod->strtab[i];
 }
 #else
+static inline unsigned long layout_symtab(struct module *mod,
+                                          Elf_Shdr *sechdrs,
+                                          unsigned int symindex,
+                                          unsigned int strindex,
+                                          const Elf_Hdr *hdr,
+                                          const char *secstrings,
+                                          unsigned long *pstroffs,
+                                          unsigned long *strmap)
+{
+}
 static inline void add_kallsyms(struct module *mod,
                                 Elf_Shdr *sechdrs,
+                                unsigned int shnum,
                                 unsigned int symindex,
                                 unsigned int strindex,
-                                const char *secstrings)
+                                unsigned long symoffs,
+                                unsigned long stroffs,
+                                const char *secstrings,
+                                const unsigned long *strmap)
 {
 }
 #endif /* CONFIG_KALLSYMS */
@@ -1959,6 +2081,9 @@ static noinline struct module *load_module(void __user *umod,
         struct module *mod;
         long err = 0;
         void *percpu = NULL, *ptr = NULL; /* Stops spurious gcc warning */
+#ifdef CONFIG_KALLSYMS
+        unsigned long symoffs, stroffs, *strmap;
+#endif
         mm_segment_t old_fs;
 
         DEBUGP("load_module: umod=%p, len=%lu, uargs=%p\n",
@@ -2040,11 +2165,6 @@ static noinline struct module *load_module(void __user *umod,
         /* Don't keep modinfo and version sections. */
         sechdrs[infoindex].sh_flags &= ~(unsigned long)SHF_ALLOC;
         sechdrs[versindex].sh_flags &= ~(unsigned long)SHF_ALLOC;
-#ifdef CONFIG_KALLSYMS
-        /* Keep symbol and string tables for decoding later. */
-        sechdrs[symindex].sh_flags |= SHF_ALLOC;
-        sechdrs[strindex].sh_flags |= SHF_ALLOC;
-#endif
 
         /* Check module struct version now, before we try to use module. */
         if (!check_modstruct_version(sechdrs, versindex, mod)) {
@@ -2080,6 +2200,13 @@ static noinline struct module *load_module(void __user *umod,
                 goto free_hdr;
         }
 
+        strmap = kzalloc(BITS_TO_LONGS(sechdrs[strindex].sh_size)
+                         * sizeof(long), GFP_KERNEL);
+        if (!strmap) {
+                err = -ENOMEM;
+                goto free_mod;
+        }
+
         if (find_module(mod->name)) {
                 err = -EEXIST;
                 goto free_mod;
@@ -2109,6 +2236,8 @@ static noinline struct module *load_module(void __user *umod,
            this is done generically; there doesn't appear to be any
            special cases for the architectures. */
         layout_sections(mod, hdr, sechdrs, secstrings);
+        symoffs = layout_symtab(mod, sechdrs, symindex, strindex, hdr,
+                                secstrings, &stroffs, strmap);
 
         /* Do the allocs. */
         ptr = module_alloc_update_bounds(mod->core_size);
@@ -2313,7 +2442,10 @@ static noinline struct module *load_module(void __user *umod,
         percpu_modcopy(mod->percpu, (void *)sechdrs[pcpuindex].sh_addr,
                        sechdrs[pcpuindex].sh_size);
 
-        add_kallsyms(mod, sechdrs, symindex, strindex, secstrings);
+        add_kallsyms(mod, sechdrs, hdr->e_shnum, symindex, strindex,
+                     symoffs, stroffs, secstrings, strmap);
+        kfree(strmap);
+        strmap = NULL;
 
         if (!mod->taints) {
                 struct _ddebug *debug;
@@ -2385,13 +2517,14 @@ static noinline struct module *load_module(void __user *umod,
         synchronize_sched();
         module_arch_cleanup(mod);
  cleanup:
+        free_modinfo(mod);
         kobject_del(&mod->mkobj.kobj);
         kobject_put(&mod->mkobj.kobj);
  free_unload:
         module_unload_free(mod);
 #if defined(CONFIG_MODULE_UNLOAD) && defined(CONFIG_SMP)
- free_init:
         percpu_modfree(mod->refptr);
+ free_init:
 #endif
         module_free(mod, mod->module_init);
  free_core:
@@ -2402,6 +2535,7 @@ static noinline struct module *load_module(void __user *umod,
                 percpu_modfree(percpu);
  free_mod:
         kfree(args);
+        kfree(strmap);
  free_hdr:
         vfree(hdr);
         return ERR_PTR(err);
@@ -2491,6 +2625,11 @@ SYSCALL_DEFINE3(init_module, void __user *, umod,
         /* Drop initial reference. */
         module_put(mod);
         trim_init_extable(mod);
+#ifdef CONFIG_KALLSYMS
+        mod->num_symtab = mod->core_num_syms;
+        mod->symtab = mod->core_symtab;
+        mod->strtab = mod->core_strtab;
+#endif
         module_free(mod, mod->module_init);
         mod->module_init = NULL;
         mod->init_size = 0;
diff --git a/kernel/params.c b/kernel/params.c
index 7f6912ced2ba..9da58eabdcb2 100644
--- a/kernel/params.c
+++ b/kernel/params.c
@@ -23,6 +23,7 @@
 #include <linux/device.h>
 #include <linux/err.h>
 #include <linux/slab.h>
+#include <linux/ctype.h>
 
 #if 0
 #define DEBUGP printk
@@ -87,7 +88,7 @@ static char *next_arg(char *args, char **param, char **val)
         }
 
         for (i = 0; args[i]; i++) {
-                if (args[i] == ' ' && !in_quote)
+                if (isspace(args[i]) && !in_quote)
                         break;
                 if (equals == 0) {
                         if (args[i] == '=')
@@ -121,7 +122,7 @@ static char *next_arg(char *args, char **param, char **val)
                 next = args + i;
 
         /* Chew up trailing spaces. */
-        while (*next == ' ')
+        while (isspace(*next))
                 next++;
         return next;
 }
@@ -138,7 +139,7 @@ int parse_args(const char *name,
         DEBUGP("Parsing ARGS: %s\n", args);
 
         /* Chew leading spaces */
-        while (*args == ' ')
+        while (isspace(*args))
                 args++;
 
         while (*args) {