i2p/haiku-beta6
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Renamed some global static variables to match our style guide.

Browse Source 
Changed some comments.


git-svn-id: file:///srv/svn/repos/haiku/trunk/current@7484 a95241bf-73f2-0310-859d-f6bbb57e9c96
This commit is contained in:
Axel Dörfler
2004-05-10 00:09:21 +00:00
parent 1792829685
commit b36321870c
1 changed files with 56 additions and 54 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/kernel/core/module.c
+56 -54
View File
@@ -21,8 +21,6 @@
#define MODULE_HASH_SIZE 16 #define MODULE_HASH_SIZE 16
static bool modules_disable_user_addons = false;
/** The modules referenced by this structure are built-in /** The modules referenced by this structure are built-in
* modules that can't be loaded from disk. * modules that can't be loaded from disk.
*/ */
@@ -53,9 +51,8 @@ typedef enum {
/* Each loaded module image (which can export several modules) is put /* Each loaded module image (which can export several modules) is put
* in a hash (gModuleImagesHash) to be easily found when you search * in a hash (gModuleImagesHash) to be easily found when you search
* for a specific file name. * for a specific file name.
* ToDo: should probably use the VFS to parse the path, and use only the * ToDo: Could use only the inode number for hashing. Would probably be
* inode number for hashing. Would probably a little bit slower, but would * a little bit slower, but would lower the memory foot print quite a lot.
* lower the memory foot print quite a lot.
*/ */
typedef struct module_image { typedef struct module_image {
@@ -112,31 +109,34 @@ typedef struct module_iterator {
} module_iterator; } module_iterator;
static bool sDisableUserAddOns = false;
/* locking scheme: there is a global lock only; having several locks /* locking scheme: there is a global lock only; having several locks
* makes trouble if dependent modules get loaded concurrently -> * makes trouble if dependent modules get loaded concurrently ->
* they have to wait for each other, i.e. we need one lock per module; * they have to wait for each other, i.e. we need one lock per module;
* also we must detect circular references during init and not dead-lock * also we must detect circular references during init and not dead-lock
*/ */
static recursive_lock gModulesLock; static recursive_lock sModulesLock;
/* These are the standard base paths where we start to look for modules /* These are the standard base paths where we start to look for modules
* to load. Order is important, the last entry here will be searched * to load. Order is important, the last entry here will be searched
* first. * first.
* ToDo: these are not yet BeOS compatible (because the current bootfs is very limited) * ToDo: these are not yet BeOS compatible (because the current bootfs is very limited)
* ToDo: these should probably be retrieved by using find_directory().
*/ */
static const char * const gModulePaths[] = { static const char * const sModulePaths[] = {
"/boot/addons/kernel", "/boot/addons/kernel",
"/boot/home/config/add-ons/kernel", "/boot/home/config/add-ons/kernel",
}; };
#define NUM_MODULE_PATHS (sizeof(gModulePaths) / sizeof(gModulePaths[0])) #define NUM_MODULE_PATHS (sizeof(sModulePaths) / sizeof(sModulePaths[0]))
#define USER_MODULE_PATHS 1 /* first user path */ #define USER_MODULE_PATHS 1 /* first user path */
/* we store the loaded modules by directory path, and all known modules by module name /* we store the loaded modules by directory path, and all known modules by module name
* in a hash table for quick access * in a hash table for quick access
*/ */
static hash_table *gModuleImagesHash; static hash_table *sModuleImagesHash;
static hash_table *gModulesHash; static hash_table *sModulesHash;
/** calculates hash for a module using its name */ /** calculates hash for a module using its name */
@@ -264,9 +264,9 @@ load_module_image(const char *path, module_image **_moduleImage)
moduleImage->ref_count = 0; moduleImage->ref_count = 0;
moduleImage->keep_loaded = false; moduleImage->keep_loaded = false;
recursive_lock_lock(&gModulesLock); recursive_lock_lock(&sModulesLock);
hash_insert(gModuleImagesHash, moduleImage); hash_insert(sModuleImagesHash, moduleImage);
recursive_lock_unlock(&gModulesLock); recursive_lock_unlock(&sModulesLock);
*_moduleImage = moduleImage; *_moduleImage = moduleImage;
return B_OK; return B_OK;
@@ -287,7 +287,7 @@ unload_module_image(module_image *moduleImage, const char *path)
if (moduleImage == NULL) { if (moduleImage == NULL) {
// if no image was specified, lookup it up in the hash table // if no image was specified, lookup it up in the hash table
moduleImage = (module_image *)hash_lookup(gModuleImagesHash, path); moduleImage = (module_image *)hash_lookup(sModuleImagesHash, path);
if (moduleImage == NULL) if (moduleImage == NULL)
return B_ENTRY_NOT_FOUND; return B_ENTRY_NOT_FOUND;
} }
@@ -297,9 +297,9 @@ unload_module_image(module_image *moduleImage, const char *path)
return B_ERROR; return B_ERROR;
} }
recursive_lock_lock(&gModulesLock); recursive_lock_lock(&sModulesLock);
hash_remove(gModuleImagesHash, moduleImage); hash_remove(sModuleImagesHash, moduleImage);
recursive_lock_unlock(&gModulesLock); recursive_lock_unlock(&sModulesLock);
elf_unload_kspace(moduleImage->path); elf_unload_kspace(moduleImage->path);
free(moduleImage->path); free(moduleImage->path);
@@ -327,7 +327,7 @@ get_module_image(const char *path, module_image **_image)
TRACE(("get_module_image(path = \"%s\", _image = %p)\n", path, _image)); TRACE(("get_module_image(path = \"%s\", _image = %p)\n", path, _image));
image = (module_image *)hash_lookup(gModuleImagesHash, path); image = (module_image *)hash_lookup(sModuleImagesHash, path);
if (image == NULL) { if (image == NULL) {
status_t status = load_module_image(path, &image); status_t status = load_module_image(path, &image);
if (status < B_OK) if (status < B_OK)
@@ -356,7 +356,7 @@ create_module(module_info *info, const char *file, int offset, module **_module)
if (!info->name) if (!info->name)
return B_BAD_VALUE; return B_BAD_VALUE;
module = (struct module *)hash_lookup(gModulesHash, info->name); module = (struct module *)hash_lookup(sModulesHash, info->name);
if (module) { if (module) {
FATAL(("Duplicate module name (%s) detected... ignoring new one\n", info->name)); FATAL(("Duplicate module name (%s) detected... ignoring new one\n", info->name));
return B_FILE_EXISTS; return B_FILE_EXISTS;
@@ -388,9 +388,9 @@ create_module(module_info *info, const char *file, int offset, module **_module)
module->ref_count = 0; module->ref_count = 0;
module->flags = info->flags; module->flags = info->flags;
recursive_lock_lock(&gModulesLock); recursive_lock_lock(&sModulesLock);
hash_insert(gModulesHash, module); hash_insert(sModulesHash, module);
recursive_lock_unlock(&gModulesLock); recursive_lock_unlock(&sModulesLock);
if (_module) if (_module)
*_module = module; *_module = module;
@@ -414,7 +414,7 @@ check_module_image(const char *path, const char *searchedName)
int index = 0, match = B_ENTRY_NOT_FOUND; int index = 0, match = B_ENTRY_NOT_FOUND;
TRACE(("check_module_image(path = \"%s\", searchedName = \"%s\")\n", path, searchedName)); TRACE(("check_module_image(path = \"%s\", searchedName = \"%s\")\n", path, searchedName));
ASSERT(hash_lookup(gModuleImagesHash, path) == NULL); ASSERT(hash_lookup(sModuleImagesHash, path) == NULL);
if (load_module_image(path, &image) < B_OK) if (load_module_image(path, &image) < B_OK)
return B_ENTRY_NOT_FOUND; return B_ENTRY_NOT_FOUND;
@@ -499,7 +499,7 @@ recurse_directory(const char *path, const char *searchedName)
// because then we know it doesn't contain the module we are // because then we know it doesn't contain the module we are
// searching for (we are here because it couldn't be found in // searching for (we are here because it couldn't be found in
// the first place) // the first place)
if (hash_lookup(gModuleImagesHash, newPath) != NULL) if (hash_lookup(sModuleImagesHash, newPath) != NULL)
continue; continue;
status = check_module_image(newPath, searchedName); status = check_module_image(newPath, searchedName);
@@ -541,25 +541,25 @@ search_module(const char *name)
// The call to vfs_get_module_path() is only for testing purposes // The call to vfs_get_module_path() is only for testing purposes
for (i = 0; i < NUM_MODULE_PATHS; i++) { for (i = 0; i < NUM_MODULE_PATHS; i++) {
if (modules_disable_user_addons && i >= USER_MODULE_PATHS) if (sDisableUserAddOns && i >= USER_MODULE_PATHS)
return NULL; return NULL;
{ {
char path[B_FILE_NAME_LENGTH]; char path[B_FILE_NAME_LENGTH];
if (vfs_get_module_path(gModulePaths[i], name, path, sizeof(path)) < B_OK) { if (vfs_get_module_path(sModulePaths[i], name, path, sizeof(path)) < B_OK) {
TRACE(("vfs_get_module_path() failed for \"%s\"\n", name)); TRACE(("vfs_get_module_path() failed for \"%s\"\n", name));
} else { } else {
TRACE(("vfs_get_module_path(): found \"%s\" (for \"%s\")\n", path, name)); TRACE(("vfs_get_module_path(): found \"%s\" (for \"%s\")\n", path, name));
} }
} }
if ((status = recurse_directory(gModulePaths[i], name)) == B_OK) if ((status = recurse_directory(sModulePaths[i], name)) == B_OK)
break; break;
} }
if (status != B_OK) if (status != B_OK)
return NULL; return NULL;
return (module *)hash_lookup(gModulesHash, name); return (module *)hash_lookup(sModulesHash, name);
} }
@@ -920,19 +920,19 @@ dump_modules(int argc, char **argv)
struct module_image *image; struct module_image *image;
struct module *module; struct module *module;
hash_rewind(gModulesHash, &iterator); hash_rewind(sModulesHash, &iterator);
dprintf("-- known modules:\n"); dprintf("-- known modules:\n");
while ((module = (struct module *)hash_next(gModulesHash, &iterator)) != NULL) { while ((module = (struct module *)hash_next(sModulesHash, &iterator)) != NULL) {
dprintf("%p: \"%s\", \"%s\" (%ld), refcount = %ld, state = %d, mimage = %p\n", dprintf("%p: \"%s\", \"%s\" (%ld), refcount = %ld, state = %d, mimage = %p\n",
module, module->name, module->file, module->offset, module->ref_count, module, module->name, module->file, module->offset, module->ref_count,
module->state, module->module_image); module->state, module->module_image);
} }
hash_rewind(gModuleImagesHash, &iterator); hash_rewind(sModuleImagesHash, &iterator);
dprintf("\n-- loaded modules:\n"); dprintf("\n-- loaded modules:\n");
while ((image = (struct module_image *)hash_next(gModuleImagesHash, &iterator)) != NULL) { while ((image = (struct module_image *)hash_next(sModuleImagesHash, &iterator)) != NULL) {
dprintf("%p: \"%s\" (image_id = %ld), info = %p, refcount = %ld, %s\n", image, dprintf("%p: \"%s\" (image_id = %ld), info = %p, refcount = %ld, %s\n", image,
image->path, image->image, image->info, image->ref_count, image->path, image->image, image->info, image->ref_count,
image->keep_loaded ? "keep loaded" : "can be unloaded"); image->keep_loaded ? "keep loaded" : "can be unloaded");
@@ -952,15 +952,15 @@ dump_modules(int argc, char **argv)
status_t status_t
module_init(kernel_args *args) module_init(kernel_args *args)
{ {
if (recursive_lock_init(&gModulesLock, "modules rlock") < B_OK) if (recursive_lock_init(&sModulesLock, "modules rlock") < B_OK)
return B_ERROR; return B_ERROR;
gModulesHash = hash_init(MODULE_HASH_SIZE, 0, module_compare, module_hash); sModulesHash = hash_init(MODULE_HASH_SIZE, 0, module_compare, module_hash);
if (gModulesHash == NULL) if (sModulesHash == NULL)
return B_NO_MEMORY; return B_NO_MEMORY;
gModuleImagesHash = hash_init(MODULE_HASH_SIZE, 0, module_image_compare, module_image_hash); sModuleImagesHash = hash_init(MODULE_HASH_SIZE, 0, module_image_compare, module_image_hash);
if (gModuleImagesHash == NULL) if (sModuleImagesHash == NULL)
return B_NO_MEMORY; return B_NO_MEMORY;
// register built-in modules // register built-in modules
@@ -971,6 +971,8 @@ module_init(kernel_args *args)
// ToDo! // ToDo!
// ToDo: set sDisableUserAddOns from kernel_args!
add_debugger_command("modules", &dump_modules, "list all known & loaded modules"); add_debugger_command("modules", &dump_modules, "list all known & loaded modules");
return B_OK; return B_OK;
@@ -1019,10 +1021,10 @@ open_module_list(const char *prefix)
for (i = 0; i < NUM_MODULE_PATHS; i++) { for (i = 0; i < NUM_MODULE_PATHS; i++) {
const char *path; const char *path;
if (modules_disable_user_addons && i >= USER_MODULE_PATHS) if (sDisableUserAddOns && i >= USER_MODULE_PATHS)
break; break;
path = strdup(gModulePaths[i]); path = strdup(sModulePaths[i]);
if (path == NULL) { if (path == NULL) {
// ToDo: should we abort the whole operation here? // ToDo: should we abort the whole operation here?
// if we do, don't forget to empty the stack // if we do, don't forget to empty the stack
@@ -1092,12 +1094,12 @@ read_next_module_name(void *cookie, char *buffer, size_t *_bufferSize)
return iterator->status; return iterator->status;
status = iterator->status; status = iterator->status;
recursive_lock_lock(&gModulesLock); recursive_lock_lock(&sModulesLock);
status = iterator_get_next_module(iterator, buffer, _bufferSize); status = iterator_get_next_module(iterator, buffer, _bufferSize);
iterator->status = status; iterator->status = status;
recursive_lock_unlock(&gModulesLock); recursive_lock_unlock(&sModulesLock);
TRACE(("read_next_module_name: finished with status %s\n", strerror(status))); TRACE(("read_next_module_name: finished with status %s\n", strerror(status)));
return status; return status;
@@ -1123,25 +1125,25 @@ get_next_loaded_module_name(uint32 *_cookie, char *buffer, size_t *_bufferSize)
return B_BAD_VALUE; return B_BAD_VALUE;
if (iterator == NULL) { if (iterator == NULL) {
iterator = hash_open(gModulesHash, NULL); iterator = hash_open(sModulesHash, NULL);
if (iterator == NULL) if (iterator == NULL)
return B_NO_MEMORY; return B_NO_MEMORY;
*(hash_iterator **)_cookie = iterator; *(hash_iterator **)_cookie = iterator;
} }
recursive_lock_lock(&gModulesLock); recursive_lock_lock(&sModulesLock);
module = hash_next(gModulesHash, iterator); module = hash_next(sModulesHash, iterator);
if (module != NULL) { if (module != NULL) {
*_bufferSize = strlcpy(buffer, module->name, *_bufferSize); *_bufferSize = strlcpy(buffer, module->name, *_bufferSize);
status = B_OK; status = B_OK;
} else { } else {
hash_close(gModulesHash, iterator, true); hash_close(sModulesHash, iterator, true);
status = B_ENTRY_NOT_FOUND; status = B_ENTRY_NOT_FOUND;
} }
recursive_lock_unlock(&gModulesLock); recursive_lock_unlock(&sModulesLock);
return status; return status;
} }
@@ -1159,9 +1161,9 @@ get_module(const char *path, module_info **_info)
if (path == NULL) if (path == NULL)
return B_BAD_VALUE; return B_BAD_VALUE;
recursive_lock_lock(&gModulesLock); recursive_lock_lock(&sModulesLock);
module = (struct module *)hash_lookup(gModulesHash, path); module = (struct module *)hash_lookup(sModulesHash, path);
// if we don't have it cached yet, search for it // if we don't have it cached yet, search for it
if (module == NULL) { if (module == NULL) {
@@ -1201,7 +1203,7 @@ get_module(const char *path, module_info **_info)
else else
status = B_OK; status = B_OK;
recursive_lock_unlock(&gModulesLock); recursive_lock_unlock(&sModulesLock);
if (status == B_OK) if (status == B_OK)
*_info = module->info; *_info = module->info;
@@ -1209,7 +1211,7 @@ get_module(const char *path, module_info **_info)
return status; return status;
err: err:
recursive_lock_unlock(&gModulesLock); recursive_lock_unlock(&sModulesLock);
return B_ENTRY_NOT_FOUND; return B_ENTRY_NOT_FOUND;
} }
@@ -1221,12 +1223,12 @@ put_module(const char *path)
TRACE(("put_module(path = %s)\n", path)); TRACE(("put_module(path = %s)\n", path));
recursive_lock_lock(&gModulesLock); recursive_lock_lock(&sModulesLock);
module = (struct module *)hash_lookup(gModulesHash, path); module = (struct module *)hash_lookup(sModulesHash, path);
if (module == NULL) { if (module == NULL) {
FATAL(("module: We don't seem to have a reference to module %s\n", path)); FATAL(("module: We don't seem to have a reference to module %s\n", path));
recursive_lock_unlock(&gModulesLock); recursive_lock_unlock(&sModulesLock);
return B_BAD_VALUE; return B_BAD_VALUE;
} }
dec_module_ref_count(module); dec_module_ref_count(module);
@@ -1238,6 +1240,6 @@ put_module(const char *path)
if ((module->flags & B_BUILT_IN_MODULE) == 0) if ((module->flags & B_BUILT_IN_MODULE) == 0)
put_module_image(module->module_image); put_module_image(module->module_image);
recursive_lock_unlock(&gModulesLock); recursive_lock_unlock(&sModulesLock);
return B_OK; return B_OK;
} }