Added printks to module loading. p/anton.e/temp
authorAnton Eisenbraun <anton.e@mailbox.tu-berlin.de>
Mon, 8 Jun 2015 18:20:08 +0000 (20:20 +0200)
committerAnton Eisenbraun <anton.e@mailbox.tu-berlin.de>
Mon, 8 Jun 2015 18:20:08 +0000 (20:20 +0200)
arch/x86/kernel/module.c
kernel/module.c

index 216a4d7..6416688 100644 (file)
@@ -99,6 +99,7 @@ int apply_relocate_add(Elf64_Shdr *sechdrs,
                   unsigned int relsec,
                   struct module *me)
 {
+       //apply_relocate_add(info->sechdrs, info->strtab, info->index.sym, i, mod)
        unsigned int i;
        Elf64_Rela *rel = (void *)sechdrs[relsec].sh_addr;
        Elf64_Sym *sym;
@@ -107,6 +108,8 @@ int apply_relocate_add(Elf64_Shdr *sechdrs,
 
        DEBUGP("Applying relocate section %u to %u\n",
               relsec, sechdrs[relsec].sh_info);
+       printk("Applying relocate section %u to %u\n",
+                      relsec, sechdrs[relsec].sh_info);
        for (i = 0; i < sechdrs[relsec].sh_size / sizeof(*rel); i++) {
                /* This is where to make the change */
                loc = (void *)sechdrs[sechdrs[relsec].sh_info].sh_addr
@@ -121,6 +124,10 @@ int apply_relocate_add(Elf64_Shdr *sechdrs,
                       (int)ELF64_R_TYPE(rel[i].r_info),
                       sym->st_value, rel[i].r_addend, (u64)loc);
 
+               printk("type %d st_value %Lx r_addend %Lx loc %Lx\n",
+                                      (int)ELF64_R_TYPE(rel[i].r_info),
+                                      sym->st_value, rel[i].r_addend, (u64)loc);
+
                val = sym->st_value + rel[i].r_addend;
 
                switch (ELF64_R_TYPE(rel[i].r_info)) {
index 0925c9a..3ce6c6f 100644 (file)
@@ -219,13 +219,17 @@ EXPORT_SYMBOL(__module_put_and_exit);
 static unsigned int find_sec(const struct load_info *info, const char *name)
 {
        unsigned int i;
-
+       printk("find section %s\n", name);
        for (i = 1; i < info->hdr->e_shnum; i++) {
                Elf_Shdr *shdr = &info->sechdrs[i];
                /* Alloc bit cleared means "ignore it." */
                if ((shdr->sh_flags & SHF_ALLOC)
                    && strcmp(info->secstrings + shdr->sh_name, name) == 0)
+               {
+                       printk("info->sechdrs[%i] section name(%s)\n",
+                                                       i, (info->secstrings + shdr->sh_name));
                        return i;
+               }
        }
        return 0;
 }
@@ -1261,7 +1265,7 @@ static const struct kernel_symbol *resolve_symbol(struct module *mod,
        const struct kernel_symbol *sym;
        const unsigned long *crc;
        int err;
-
+       printk(" resolving undef symbol %s",name);
        mutex_lock(&module_mutex);
        sym = find_symbol(name, &owner, &crc,
                          !(mod->taints & (1 << TAINT_PROPRIETARY_MODULE)), true);
@@ -1627,6 +1631,7 @@ static int mod_sysfs_init(struct module *mod)
 
        memset(&mod->mkobj.kobj, 0, sizeof(mod->mkobj.kobj));
        mod->mkobj.kobj.kset = module_kset;
+       //Adding the name to sysfs???
        err = kobject_init_and_add(&mod->mkobj.kobj, &module_ktype, NULL,
                                   "%s", mod->name);
        if (err)
@@ -1962,7 +1967,7 @@ static int simplify_symbols(struct module *mod, const struct load_info *info)
 
        for (i = 1; i < symsec->sh_size / sizeof(Elf_Sym); i++) {
                const char *name = info->strtab + sym[i].st_name;
-
+               printk("symbol_value: 0x%08lx", (long)sym[i].st_value);
                switch (sym[i].st_shndx) {
                case SHN_COMMON:
                        /* We compiled with -fno-common.  These are not
@@ -1977,6 +1982,8 @@ static int simplify_symbols(struct module *mod, const struct load_info *info)
                        /* Don't need to do anything */
                        pr_debug("Absolute symbol: 0x%08lx\n",
                               (long)sym[i].st_value);
+                       printk(" Absolute symbol: 0x%08lx",
+                                                      (long)sym[i].st_value);
                        break;
 
                case SHN_UNDEF:
@@ -2005,6 +2012,7 @@ static int simplify_symbols(struct module *mod, const struct load_info *info)
                        sym[i].st_value += secbase;
                        break;
                }
+               printk(" new symbol_value: 0x%08lx sym name:%s\n", (long)sym[i].st_value, name);
        }
 
        return ret;
@@ -2080,11 +2088,11 @@ static void layout_sections(struct module *mod, struct load_info *info)
                info->sechdrs[i].sh_entsize = ~0UL;
 
        pr_debug("Core section allocation order:\n");
+       printk("Core section allocation order:\n");
        for (m = 0; m < ARRAY_SIZE(masks); ++m) {
                for (i = 0; i < info->hdr->e_shnum; ++i) {
                        Elf_Shdr *s = &info->sechdrs[i];
                        const char *sname = info->secstrings + s->sh_name;
-
                        if ((s->sh_flags & masks[m][0]) != masks[m][0]
                            || (s->sh_flags & masks[m][1])
                            || s->sh_entsize != ~0UL
@@ -2092,23 +2100,29 @@ static void layout_sections(struct module *mod, struct load_info *info)
                                continue;
                        s->sh_entsize = get_offset(mod, &mod->core_size, s, i);
                        pr_debug("\t%s\n", sname);
+                       printk("\t%s sh_entsize(%i)\n", sname, s->sh_entsize);
                }
+               //(void *)info->sechdrs[info->index.mod].sh_addr
                switch (m) {
                case 0: /* executable */
+                       printk("executablen mod->core_text_size(%i)\n", mod->core_size);
                        mod->core_size = debug_align(mod->core_size);
                        mod->core_text_size = mod->core_size;
                        break;
                case 1: /* RO: text and ro-data */
+                       printk("RO: text and ro-data mod->core_ro_size(%i)\n", mod->core_size);
                        mod->core_size = debug_align(mod->core_size);
                        mod->core_ro_size = mod->core_size;
                        break;
                case 3: /* whole core */
+                       printk("whole core size(%i)\n", mod->core_size);
                        mod->core_size = debug_align(mod->core_size);
                        break;
                }
        }
 
        pr_debug("Init section allocation order:\n");
+       printk("Init section allocation order:\n");
        for (m = 0; m < ARRAY_SIZE(masks); ++m) {
                for (i = 0; i < info->hdr->e_shnum; ++i) {
                        Elf_Shdr *s = &info->sechdrs[i];
@@ -2122,17 +2136,21 @@ static void layout_sections(struct module *mod, struct load_info *info)
                        s->sh_entsize = (get_offset(mod, &mod->init_size, s, i)
                                         | INIT_OFFSET_MASK);
                        pr_debug("\t%s\n", sname);
+                       printk("\t%s sh_entsize(%i)\n", sname, s->sh_entsize);
                }
                switch (m) {
                case 0: /* executable */
+                       printk("executablen mod->init_text_size(%i)\n", mod->init_size);
                        mod->init_size = debug_align(mod->init_size);
                        mod->init_text_size = mod->init_size;
                        break;
                case 1: /* RO: text and ro-data */
+                       printk("RO: text and ro-data mod->init_ro_size(%i)\n", mod->init_size);
                        mod->init_size = debug_align(mod->init_size);
                        mod->init_ro_size = mod->init_size;
                        break;
                case 3: /* whole init */
+                       printk("whole init size(%i) mod->init_text_size(%i)\n", mod->init_size);
                        mod->init_size = debug_align(mod->init_size);
                        break;
                }
@@ -2305,13 +2323,13 @@ static void layout_symtab(struct module *mod, struct load_info *info)
        Elf_Shdr *strsect = info->sechdrs + info->index.str;
        const Elf_Sym *src;
        unsigned int i, nsrc, ndst, strtab_size = 0;
-
+       printk("layout_symtab\n");
        /* 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,
                                         info->index.sym) | INIT_OFFSET_MASK;
        pr_debug("\t%s\n", info->secstrings + symsect->sh_name);
-
+       printk("\t%s\n", info->secstrings + symsect->sh_name);
        src = (void *)info->hdr + symsect->sh_offset;
        nsrc = symsect->sh_size / sizeof(*src);
 
@@ -2334,6 +2352,7 @@ static void layout_symtab(struct module *mod, struct load_info *info)
        strsect->sh_entsize = get_offset(mod, &mod->init_size, strsect,
                                         info->index.str) | INIT_OFFSET_MASK;
        pr_debug("\t%s\n", info->secstrings + strsect->sh_name);
+       printk("\t%s\n", info->secstrings + strsect->sh_name);
 }
 
 static void add_kallsyms(struct module *mod, const struct load_info *info)
@@ -2513,9 +2532,10 @@ static int copy_module_from_user(const void __user *umod, unsigned long len,
 
        /* Suck in entire file: we'll want most of it. */
        info->hdr = vmalloc(info->len);
+       printk("Valloc space (info->len=%lu) for ELF-Header info->hdr=%p\n",info->len, info->hdr);
        if (!info->hdr)
                return -ENOMEM;
-
+       printk("copy_from_user (to)info->hdr=%p (from)umod=%p info->len=%p\n", info->hdr, umod, info->len);
        if (copy_from_user(info->hdr, umod, info->len) != 0) {
                vfree(info->hdr);
                return -EFAULT;
@@ -2638,27 +2658,33 @@ static struct module *setup_load_info(struct load_info *info, int flags)
        unsigned int i;
        int err;
        struct module *mod;
-
+       printk("setup_load_info:\n");
        /* Set up the convenience variables */
+       printk("Setup section headers info->hdr=%p + info->hdr->e_shoff=%x = info->sechdrs=%p:\n",
+                       (void *)info->hdr, info->hdr->e_shoff, ((void *)info->hdr + info->hdr->e_shoff));
        info->sechdrs = (void *)info->hdr + info->hdr->e_shoff;
        info->secstrings = (void *)info->hdr
                + info->sechdrs[info->hdr->e_shstrndx].sh_offset;
+       printk("Sectionstrings info->secstrings(%p)= (void *)info->hdr(%p) + info->sechdrs[info->hdr->e_shstrndx(%x)].sh_offset(%x)\n",
+                       info->secstrings, (void *)info->hdr,info->hdr->e_shstrndx, info->sechdrs[info->hdr->e_shstrndx].sh_offset);
 
        err = rewrite_section_headers(info, flags);
        if (err)
                return ERR_PTR(err);
 
        /* Find internal symbols and strings. */
+       printk("Find internal symbols and strings\n");
        for (i = 1; i < info->hdr->e_shnum; i++) {
                if (info->sechdrs[i].sh_type == SHT_SYMTAB) {
                        info->index.sym = i;
                        info->index.str = info->sechdrs[i].sh_link;
                        info->strtab = (char *)info->hdr
                                + info->sechdrs[info->index.str].sh_offset;
+                       printk("SYMTAB: info->index.sym(%i) info->index.str(%i) info->strtab(%s)\n", i, info->index.str, info->strtab);
                        break;
                }
        }
-
+       printk("find index for module section =>");
        info->index.mod = find_sec(info, ".gnu.linkonce.this_module");
        if (!info->index.mod) {
                printk(KERN_WARNING "No module found in object\n");
@@ -2666,7 +2692,7 @@ static struct module *setup_load_info(struct load_info *info, int flags)
        }
        /* This is temporary: point mod into copy of data. */
        mod = (void *)info->sechdrs[info->index.mod].sh_addr;
-
+       printk("Virtual address of a module at execution %p\n", mod);
        if (info->index.sym == 0) {
                printk(KERN_WARNING "%s: module has no symbols (stripped?)\n",
                       mod->name);
@@ -2804,7 +2830,7 @@ static int move_module(struct module *mod, struct load_info *info)
 {
        int i;
        void *ptr;
-
+       printk("move_module\n");
        /* Do the allocs. */
        ptr = module_alloc_update_bounds(mod->core_size);
        /*
@@ -2818,7 +2844,7 @@ static int move_module(struct module *mod, struct load_info *info)
 
        memset(ptr, 0, mod->core_size);
        mod->module_core = ptr;
-
+       printk("alloc and memset space for mod->module_core %p\n", mod->module_core);
        if (mod->init_size) {
                ptr = module_alloc_update_bounds(mod->init_size);
                /*
@@ -2834,11 +2860,13 @@ static int move_module(struct module *mod, struct load_info *info)
                }
                memset(ptr, 0, mod->init_size);
                mod->module_init = ptr;
+               printk("alloc and memset space for mod->module_init %p\n", mod->module_init);
        } else
                mod->module_init = NULL;
 
        /* Transfer each section which specifies SHF_ALLOC */
        pr_debug("final section addresses:\n");
+       printk("final section addresses: Move all the core and init section from user to kernel space\n");
        for (i = 0; i < info->hdr->e_shnum; i++) {
                void *dest;
                Elf_Shdr *shdr = &info->sechdrs[i];
@@ -2858,6 +2886,8 @@ static int move_module(struct module *mod, struct load_info *info)
                shdr->sh_addr = (unsigned long)dest;
                pr_debug("\t0x%lx %s\n",
                         (long)shdr->sh_addr, info->secstrings + shdr->sh_name);
+               printk("\t0x%lx %s\n",
+                                        (long)shdr->sh_addr, info->secstrings + shdr->sh_name);
        }
 
        return 0;
@@ -2936,7 +2966,7 @@ static struct module *layout_and_allocate(struct load_info *info, int flags)
        struct module *mod;
        Elf_Shdr *pcpusec;
        int err;
-
+       printk("layout_and_allocate:\n");
        mod = setup_load_info(info, flags);
        if (IS_ERR(mod))
                return mod;
@@ -2974,6 +3004,7 @@ static struct module *layout_and_allocate(struct load_info *info, int flags)
 
        /* Module has been copied to its final place now: return it. */
        mod = (void *)info->sechdrs[info->index.mod].sh_addr;
+       printk("Module has been moved to %p\n", mod);
        kmemleak_load_module(mod, info);
        return mod;
 
@@ -3212,7 +3243,7 @@ static int load_module(struct load_info *info, const char __user *uargs,
 {
        struct module *mod;
        long err;
-
+       printk("load_module:\n");
        err = module_sig_check(info);
        if (err)
                goto free_copy;
@@ -3251,20 +3282,23 @@ static int load_module(struct load_info *info, const char __user *uargs,
 
        /* Now we've got everything in the final locations, we can
         * find optional sections. */
+       printk("find optional sections\n");
        find_module_sections(mod, info);
-
+       printk("check module license:\n");
        err = check_module_license_and_versions(mod);
        if (err)
                goto free_unload;
 
        /* Set up MODINFO_ATTR fields */
+       printk("set up modinfo:\n");
        setup_modinfo(mod, info);
 
        /* Fix up syms, so that st_value is a pointer to location. */
+       printk("Fix up syms:\n");
        err = simplify_symbols(mod, info);
        if (err < 0)
                goto free_modinfo;
-
+       printk("apply_relocations:\n");
        err = apply_relocations(mod, info);
        if (err < 0)
                goto free_modinfo;
@@ -3342,6 +3376,7 @@ SYSCALL_DEFINE3(init_module, void __user *, umod,
        int err;
        struct load_info info = { };
 
+       printk("Syscall init_module: umod=%p, len=%lu, uargs=%p\n",umod, len, uargs);
        err = may_init_module();
        if (err)
                return err;
@@ -3349,6 +3384,7 @@ SYSCALL_DEFINE3(init_module, void __user *, umod,
        pr_debug("init_module: umod=%p, len=%lu, uargs=%p\n",
               umod, len, uargs);
 
+       printk("copy_module_from_user: umod=%p, len=%lu, info=%p\n", umod, len, &info);
        err = copy_module_from_user(umod, len, &info);
        if (err)
                return err;