From 650a32fb62a038bf7a53cdc06c61d5b23bdf17b0 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Axel=20D=C3=B6rfler?= Date: Mon, 18 Aug 2003 03:41:26 +0000 Subject: [PATCH] Fixed two very subtle and hidden bugs that prevented the module component to work at all: recurse_directory() always returned failure, no matter what opendir() returned (one semicolon too much), create_module() allocated only 4 bytes for the module - sizeof(module) referred to the variable, not the structure name... (the unfortunate consequences of the naming scheme I otherwise like very much - it "just" took me 3 hours to hunt both bugs down). Added some TRACE() and ASSERT()s. Added a new debugger command "modules". git-svn-id: file:///srv/svn/repos/haiku/trunk/current@4300 a95241bf-73f2-0310-859d-f6bbb57e9c96 --- src/kernel/core/module.c | 60 ++++++++++++++++++++++++++++++++++------ 1 file changed, 51 insertions(+), 9 deletions(-) diff --git a/src/kernel/core/module.c b/src/kernel/core/module.c index 913cd5ca2f..79a3621a2d 100644 --- a/src/kernel/core/module.c +++ b/src/kernel/core/module.c @@ -206,8 +206,12 @@ load_module_image(const char *path, module_image **_moduleImage) { module_image *moduleImage; status_t status; + image_id image; - image_id image = elf_load_kspace(path, ""); + TRACE(("load_module_image(path = \"%s\", _image = %p)\n", path, _moduleImage)); + ASSERT(_moduleImage != NULL); + + image = elf_load_kspace(path, ""); if (image < 0) { dprintf("load_module_image failed: %s\n", strerror(image)); return image; @@ -295,7 +299,11 @@ put_module_image(module_image *image) static status_t get_module_image(const char *path, module_image **_image) { - struct module_image *image = (module_image *)hash_lookup(gModuleImagesHash, path); + struct module_image *image; + + TRACE(("get_module_image(path = \"%s\", _image = %p)\n", path, _image)); + + image = (module_image *)hash_lookup(gModuleImagesHash, path); if (image == NULL) { status_t status = load_module_image(path, &image); if (status < B_OK) @@ -318,6 +326,9 @@ create_module(module_info *info, const char *file, int offset, module **_module) { module *module; + TRACE(("create_module(info = %p, file = \"%s\", offset = %d, _module = %p)\n", + info, file, offset, _module)); + if (!info->name) return B_BAD_VALUE; @@ -327,10 +338,10 @@ create_module(module_info *info, const char *file, int offset, module **_module) return B_FILE_EXISTS; } - if ((module = (struct module *)malloc(sizeof(module))) == NULL) + if ((module = (struct module *)malloc(sizeof(struct module))) == NULL) return B_NO_MEMORY; - TRACE(("create_module(%s, %s)\n", info->name, file)); + TRACE(("create_module: name = \"%s\", file = \"%s\"\n", info->name, file)); module->module_image = NULL; module->name = strdup(info->name); @@ -381,6 +392,7 @@ check_module_image(const char *path, const char *searchedName) module_info **info; int index = 0, match = B_ENTRY_NOT_FOUND; + TRACE(("check_module_image(path = \"%s\", searchedName = \"%s\")\n", path, searchedName)); ASSERT(hash_lookup(gModuleImagesHash, path) == NULL); if (load_module_image(path, &image) < B_OK) @@ -398,7 +410,7 @@ check_module_image(const char *path, const char *searchedName) // The module we looked for couldn't be found, so we can unload the // loaded module at this point if (match != B_OK) { - TRACE(("check_module_file: unloading module file %s\n", path)); + TRACE(("check_module_file: unloading module file \"%s\" (not used yet)\n", path)); unload_module_image(image, path); } @@ -417,8 +429,9 @@ static status_t recurse_directory(const char *path, const char *searchedName) { status_t status; + DIR *dir = opendir(path); - if (dir == NULL); + if (dir == NULL) return errno; errno = 0; @@ -518,7 +531,6 @@ search_module(const char *name) static inline status_t init_module(module *module) { - switch (module->state) { case MODULE_QUERIED: case MODULE_LOADED: @@ -751,6 +763,33 @@ nextModuleImage: } +static int +dump_modules(int argc, char **argv) +{ + hash_iterator iterator; + struct module_image *image; + struct module *module; + + hash_rewind(gModulesHash, &iterator); + dprintf("-- known modules:\n"); + + while ((module = (struct module *)hash_next(gModulesHash, &iterator)) != NULL) { + dprintf("%p: \"%s\", \"%s\" (%d), refcount = %ld, state = %d, mimage = %p\n", + module, module->name, module->file, module->offset, module->ref_count, + module->state, module->module_image); + } + + hash_rewind(gModuleImagesHash, &iterator); + dprintf("\n-- loaded modules:\n"); + + while ((image = (struct module_image *)hash_next(gModuleImagesHash, &iterator)) != NULL) { + dprintf("%p: \"%s\" (image_id = %ld), info = %p, refcount = %ld, %s\n", image, + image->path, image->image, image->info, image->ref_count, + image->keep_loaded ? "keep loaded" : "can be unloaded"); + } +} + + // #pragma mark - // Exported Kernel API (private part) @@ -778,7 +817,9 @@ module_init(kernel_args *ka, module_info **sys_module_headers) if (register_module_image("", "(built-in)", 0, sys_module_headers) == NULL) return ENOMEM; } -*/ +*/ + + add_debugger_command("modules", &dump_modules, "list all known & loaded modules"); return B_OK; } @@ -991,6 +1032,7 @@ get_module(const char *path, module_info **_info) status_t status; TRACE(("get_module(%s)\n", path)); + if (path == NULL) return B_BAD_VALUE; @@ -1009,7 +1051,7 @@ get_module(const char *path, module_info **_info) /* We now need to find the module_image for the module. This should * be in memory if we have just run search_modules, but may not be - * if we are used cached information. + * if we are using cached information. * We can't use the module->module_image pointer, because it is not * reliable at this point (it won't be set to NULL when the module_image * is unloaded).