From b0ac62573a6282a0114d2b23e5a6f04e472fb051 Mon Sep 17 00:00:00 2001 From: "Kevin P. Fleming" Date: Sat, 25 Mar 2006 23:22:44 +0000 Subject: [PATCH] revert loader changes that have clearly not undergone adequate testing before commit git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@14952 65c4cc65-6c06-0410-ace0-fbb531ad65f3 --- asterisk.c | 6 +- codecs/codec_a_mu.c | 2 +- codecs/codec_adpcm.c | 2 +- codecs/codec_alaw.c | 2 +- codecs/codec_g723_1.c | 2 +- codecs/codec_g726.c | 2 +- codecs/codec_gsm.c | 2 +- codecs/codec_ilbc.c | 2 +- codecs/codec_lpc10.c | 2 +- codecs/codec_speex.c | 2 +- codecs/codec_ulaw.c | 2 +- include/asterisk/module.h | 272 +++++++-------------- loader.c | 501 ++++---------------------------------- res/res_smdi.c | 13 +- 14 files changed, 148 insertions(+), 664 deletions(-) diff --git a/asterisk.c b/asterisk.c index d5394ca0c5..e26e6a517a 100644 --- a/asterisk.c +++ b/asterisk.c @@ -1,7 +1,7 @@ /* * Asterisk -- An open source telephony toolkit. * - * Copyright (C) 1999 - 2005, Digium, Inc. + * Copyright (C) 1999 - 2006, Digium, Inc. * * Mark Spencer * @@ -882,11 +882,11 @@ static void quit_handler(int num, int nice, int safeshutdown, int restart) if (ast_socket > -1) { close(ast_socket); ast_socket = -1; + unlink(ast_config_AST_SOCKET); + pthread_cancel(lthread); } if (ast_consock > -1) close(ast_consock); - if (ast_socket > -1) - unlink(ast_config_AST_SOCKET); if (!ast_opt_remote) unlink(ast_config_AST_PID); printf(term_quit()); diff --git a/codecs/codec_a_mu.c b/codecs/codec_a_mu.c index f03612b134..c21b26c95d 100644 --- a/codecs/codec_a_mu.c +++ b/codecs/codec_a_mu.c @@ -316,7 +316,7 @@ char *description(void) int usecount(void) { int res; - OLD_STANDARD_USECOUNT(res); + STANDARD_USECOUNT(res); return res; } diff --git a/codecs/codec_adpcm.c b/codecs/codec_adpcm.c index 19970a5018..19fd33c319 100644 --- a/codecs/codec_adpcm.c +++ b/codecs/codec_adpcm.c @@ -616,7 +616,7 @@ char *description(void) int usecount(void) { int res; - OLD_STANDARD_USECOUNT(res); + STANDARD_USECOUNT(res); return res; } diff --git a/codecs/codec_alaw.c b/codecs/codec_alaw.c index 480b92c2af..a56e42a022 100644 --- a/codecs/codec_alaw.c +++ b/codecs/codec_alaw.c @@ -416,7 +416,7 @@ char *description(void) int usecount(void) { int res; - OLD_STANDARD_USECOUNT(res); + STANDARD_USECOUNT(res); return res; } diff --git a/codecs/codec_g723_1.c b/codecs/codec_g723_1.c index c226bb0c28..fc508ff268 100644 --- a/codecs/codec_g723_1.c +++ b/codecs/codec_g723_1.c @@ -407,7 +407,7 @@ char *description(void) int usecount(void) { int res; - OLD_STANDARD_USECOUNT(res); + STANDARD_USECOUNT(res); return res; } diff --git a/codecs/codec_g726.c b/codecs/codec_g726.c index 6a33d8519b..2a39e90a30 100644 --- a/codecs/codec_g726.c +++ b/codecs/codec_g726.c @@ -1078,7 +1078,7 @@ int usecount (void) { int res; - OLD_STANDARD_USECOUNT (res); + STANDARD_USECOUNT (res); return res; } diff --git a/codecs/codec_gsm.c b/codecs/codec_gsm.c index 59ce77fab0..ee28e852d0 100644 --- a/codecs/codec_gsm.c +++ b/codecs/codec_gsm.c @@ -347,7 +347,7 @@ char *description(void) int usecount(void) { int res; - OLD_STANDARD_USECOUNT(res); + STANDARD_USECOUNT(res); return res; } diff --git a/codecs/codec_ilbc.c b/codecs/codec_ilbc.c index fb042cfa56..8c928fbcdf 100644 --- a/codecs/codec_ilbc.c +++ b/codecs/codec_ilbc.c @@ -307,7 +307,7 @@ char *description(void) int usecount(void) { int res; - OLD_STANDARD_USECOUNT(res); + STANDARD_USECOUNT(res); return res; } diff --git a/codecs/codec_lpc10.c b/codecs/codec_lpc10.c index f9157cdc83..fe37383a76 100644 --- a/codecs/codec_lpc10.c +++ b/codecs/codec_lpc10.c @@ -420,7 +420,7 @@ char *description(void) int usecount(void) { int res; - OLD_STANDARD_USECOUNT(res); + STANDARD_USECOUNT(res); return res; } diff --git a/codecs/codec_speex.c b/codecs/codec_speex.c index fc9b22bfb7..7d7871e218 100644 --- a/codecs/codec_speex.c +++ b/codecs/codec_speex.c @@ -602,7 +602,7 @@ char *description(void) int usecount(void) { int res; - OLD_STANDARD_USECOUNT(res); + STANDARD_USECOUNT(res); return res; } diff --git a/codecs/codec_ulaw.c b/codecs/codec_ulaw.c index 4f38a024ec..38332019c6 100644 --- a/codecs/codec_ulaw.c +++ b/codecs/codec_ulaw.c @@ -418,7 +418,7 @@ char *description(void) int usecount(void) { int res; - OLD_STANDARD_USECOUNT(res); + STANDARD_USECOUNT(res); return res; } diff --git a/include/asterisk/module.h b/include/asterisk/module.h index 1c01d483fc..e159642c05 100644 --- a/include/asterisk/module.h +++ b/include/asterisk/module.h @@ -28,20 +28,12 @@ #include "asterisk/utils.h" -#include "asterisk/linkedlists.h" /* we use list macros here */ - #if defined(__cplusplus) || defined(c_plusplus) extern "C" { #endif -#ifndef STATIC_MODULE -#define STATIC_MODULE /* empty - symbols are global */ -#else -#undef STATIC_MODULE -#define STATIC_MODULE static /* symbols are static */ -#endif - /* Every module should provide these functions */ + /*! * \brief Initialize the module. * @@ -53,7 +45,7 @@ extern "C" { * If the module is not loaded successfully, Asterisk will call its * unload_module() function. */ -STATIC_MODULE int load_module(void); +int load_module(void); /*! * \brief Cleanup all module structures, sockets, etc. @@ -64,7 +56,7 @@ STATIC_MODULE int load_module(void); * * \return Zero on success, or non-zero on error. */ -STATIC_MODULE int unload_module(void); +int unload_module(void); /*! * \brief Provides a usecount. @@ -76,13 +68,13 @@ STATIC_MODULE int unload_module(void); * * \return The module's usecount. */ -STATIC_MODULE int usecount(void); /* How many channels provided by this module are in use? */ +int usecount(void); /* How many channels provided by this module are in use? */ /*! \brief Provides a description of the module. * * \return a short description of your module */ -STATIC_MODULE char *description(void); /* Description of this module */ +char *description(void); /* Description of this module */ /*! * \brief Returns the ASTERISK_GPL_KEY @@ -99,7 +91,7 @@ STATIC_MODULE char *description(void); /* Description of this module */ * * \return ASTERISK_GPL_KEY */ -STATIC_MODULE char *key(void); /* Return the below mentioned key, unmodified */ +char *key(void); /* Return the below mentioned key, unmodified */ /*! * \brief Reload stuff. @@ -109,7 +101,7 @@ STATIC_MODULE char *key(void); /* Return the below mentioned key, unmodified */ * * \return The return value is not used. */ -STATIC_MODULE int reload(void); /* reload configs */ +int reload(void); /* reload configs */ /*! \brief The text the key() function should return. */ #define ASTERISK_GPL_KEY \ @@ -268,66 +260,52 @@ int ast_register_atexit(void (*func)(void)); */ void ast_unregister_atexit(void (*func)(void)); -/*! - * \brief Given a function address, find the corresponding module. - * This is required as a workaround to the fact that we do not - * have a module argument to the load_module() function. - * Hopefully the performance implications are small. - */ -struct module *ast_find_module(int (*load_fn)(void)); - /* Local user routines keep track of which channels are using a given module resource. They can help make removing modules safer, particularly if they're in use at the time they have been requested to be removed */ +/*! + * \brief Standard localuser struct definition. + * used to keep track of channels using a given resource. + */ struct localuser { struct ast_channel *chan; - AST_LIST_ENTRY(localuser) next; + struct localuser *next; }; -/*! structure used for lock and refcount of module users. - * The mutex protects the usecnt field and whatever needs to be - * protected (typically, a list of struct localuser). - * As a trick, if usecnt is initialized with -1, - * ast_format_register will init the mutex for you. - */ -struct ast_module_lock { - ast_mutex_t lock; - AST_LIST_HEAD_NOLOCK(localuser_head, localuser) u; - int usecnt; /* number of active clients */ -}; - -struct localuser *ast_localuser_add(struct ast_module_lock *m, struct ast_channel *chan); -void ast_localuser_remove(struct ast_module_lock *m, struct localuser *u); -void ast_hangup_localusers(struct ast_module_lock *m); +#define STANDARD_LOCAL_USER /* unused and deprecated now */ /*! - * \brief create a localuser mutex and several other variables used for keeping the - * use count. + * \brief The localuser declaration. + * + * This creates a localuser mutex and the head of a list of localusers + * that is used for keeping track of channels using a resource, as well + * as the use count. * * Sample Usage: * \code * LOCAL_USER_DECL; * \endcode */ -#define LOCAL_USER_DECL \ - static struct ast_module_lock me = { \ - .u = AST_LIST_HEAD_NOLOCK_INIT_VALUE, \ - .usecnt = 0, \ - .lock = AST_MUTEX_INIT_VALUE } +#define LOCAL_USER_DECL AST_MUTEX_DEFINE_STATIC(localuser_lock); \ + static struct localuser *localusers = NULL; \ + static int localusecnt = 0; -#define STANDARD_USECOUNT_DECL LOCAL_USER_DECL /* XXX lock remains unused */ +#define STANDARD_USECOUNT_DECL \ + AST_MUTEX_DEFINE_STATIC(localuser_lock); \ + static int localusecnt = 0; -/*! run 'x' protected by lock, then call ast_update_use_count() */ -#define __MOD_PROTECT(x) do { \ - ast_mutex_lock(&me.lock); \ - x; \ - ast_mutex_unlock(&me.lock); \ - ast_update_use_count(); \ - } while (0) +#define STANDARD_INCREMENT_USECOUNT \ + ast_mutex_lock(&localuser_lock); \ + localusecnt++; \ + ast_mutex_unlock(&localuser_lock); \ + ast_update_use_count(); -#define STANDARD_INCREMENT_USECOUNT __MOD_PROTECT(me.usecnt++) -#define STANDARD_DECREMENT_USECOUNT __MOD_PROTECT(me.usecnt--) +#define STANDARD_DECREMENT_USECOUNT \ + ast_mutex_lock(&localuser_lock); \ + localusecnt--; \ + ast_mutex_unlock(&localuser_lock); \ + ast_update_use_count(); /*! * \brief Add a localuser. @@ -340,11 +318,18 @@ void ast_hangup_localusers(struct ast_module_lock *m); * \note This function dynamically allocates memory. If this operation fails * it will cause your function to return -1 to the caller. */ -#define LOCAL_USER_ADD(u) do { \ - u = ast_localuser_add(&me, chan); \ - if (!u) \ - return -1; \ - } while (0) +#define LOCAL_USER_ADD(u) { \ + \ + if (!(u = ast_calloc(1, sizeof(*u)))) \ + return -1; \ + ast_mutex_lock(&localuser_lock); \ + u->chan = chan; \ + u->next = localusers; \ + localusers = u; \ + localusecnt++; \ + ast_mutex_unlock(&localuser_lock); \ + ast_update_use_count(); \ +} /*! * \brief Remove a localuser. @@ -353,7 +338,26 @@ void ast_hangup_localusers(struct ast_module_lock *m); * This macro removes a localuser from the list of users and decrements the * usecount. */ -#define LOCAL_USER_REMOVE(u) ast_localuser_remove(&me, u) +#define LOCAL_USER_REMOVE(u) { \ + struct localuser *uc, *ul = NULL; \ + ast_mutex_lock(&localuser_lock); \ + uc = localusers; \ + while (uc) { \ + if (uc == u) { \ + if (ul) \ + ul->next = uc->next; \ + else \ + localusers = uc->next; \ + break; \ + } \ + ul = uc; \ + uc = uc->next; \ + }\ + free(u); \ + localusecnt--; \ + ast_mutex_unlock(&localuser_lock); \ + ast_update_use_count(); \ +} /*! * \brief Hangup all localusers. @@ -361,7 +365,20 @@ void ast_hangup_localusers(struct ast_module_lock *m); * This macro hangs up on all current localusers and sets the usecount to zero * when finished. */ -#define STANDARD_HANGUP_LOCALUSERS ast_hangup_localusers(&me) +#define STANDARD_HANGUP_LOCALUSERS { \ + struct localuser *u, *ul; \ + ast_mutex_lock(&localuser_lock); \ + u = localusers; \ + while(u) { \ + ast_softhangup(u->chan, AST_SOFTHANGUP_APPUNLOAD); \ + ul = u; \ + u = u->next; \ + free(ul); \ + } \ + localusecnt=0; \ + ast_mutex_unlock(&localuser_lock); \ + ast_update_use_count(); \ +} /*! * \brief Set the specfied integer to the current usecount. @@ -379,131 +396,10 @@ void ast_hangup_localusers(struct ast_module_lock *m); * } * \endcode */ -#define STANDARD_USECOUNT(res) do { res = me.usecnt; } while (0) - -/* - * XXX The following macro is deprecated, and only used by modules - * in codecs/ and a few other places which do their own manipulation - * of the usecount variable. - * Its use is supposed to be gradually phased away as those modules - * are updated to use the standard mechanism. - */ -#define OLD_STANDARD_USECOUNT(res) do { res = localusecnt; } while (0) - -/*! - * \brief The following is part of the new module management code. - * - * All modules must implement the module API (load, unload...) - * whose functions are exported through fields of a "struct module_symbol"; - * - * Modules exporting extra symbols (data or functions), should list - * them into an array of struct symbol_entry: - * struct symbol_entry exported_symbols[] - * of symbols, with a NULL name on the last entry - * Functions should be added with MOD_FUNC(name), - * data structures with MOD_DATA(_name). - * The array in turn is referenced by struct module_symbol. - * (Typically, a module will export only a single symbol, which points - * to a record containing all the methods. This is the API of the module, - * and should be known to the module's clients as well. - * - * Modules that require symbols supplied by other modules should - * provide an array - * struct symbol_entry required_symbols[] - * of symbols, with a NULL name on the last entry, containing the - * name of the desired symbol. - * For good measure, we also provide the size in both caller and calle - * to figure out if there is a mismatch (not terribly useful because most - * objects are a single word, but still... ) - * The symbol can be added to the array with MOD_WANT(symbol) macro. - * required_symbols is also pointed by through struct module_symbol. - * - * Typically, the whole interface exported by a module should be - * in a single structure named after the module, as follows. - * Say the module high level name is 'foo', then we should have - * - in include/asterisk/foo.h - * struct foo_interface { - * int (*f)(int, char *); -- first function exported - * const char (*g)(int); -- second function exported - * char *buf; - * ... -- other fields - * } - * - in the module exporting the interface, e.g. res/res_foo.c - * static int f(int, char *); - * static const char *g(int); - * const char buf[BUFSZ]; - * struct foo_interface foo = { - * .f = f, - * .g = g, - * .buf = buf, - * } - * - * NOTE: symbol names are 'global' in this module namespace, so it - * will be wiser to name exported symbols with a prefix indicating the module - * supplying it, e.g. foo_f, foo_g, foo_buf. Internally to the module, - * symbols are still static so they can keep short and meaningful names. - * The macros MOD_FIELD and METHOD_BASE() below help setting these entries. - * - * MOD_FIELD(f1), -- field and function name are the same - * METHOD_BASE(foo_, f1), -- field and function name differ by a prefix - * .f1 = function_name, -- generic case - * } - * - * Note that the loader requires that no fields of exported_symbols - * are NULL, because that is used as an indication of the end of the array. - */ - -struct symbol_entry { - const char *name; - void *value; - int size; - struct module *src; /* module sourcing it, filled by loader */ -}; - -/* - * Constructors for symbol_entry values - */ -#define MOD_FUNC(f) { .name = #f, .value = f, .size = sizeof(f) } -#define MOD_DATA(d) { .name = #d, .value = &d, .size = sizeof(_name) } -#define MOD_WANT(s) { .name = #s, .value = &s, 0 } /* required symbols */ - -/* - * Constructors for fields of foo_interface - */ -#define MOD_FIELD(f) . ## f = f -#define METHOD_BASE(_base, _name) . ## _name = _base ## _name - - -struct module_symbols { - int (*load_module)(void); - int (*unload_module)(void); - int (*usecount)(void); - char *(*description)(void); - char *(*key)(void); - int (*reload)(void); - - enum module_type { - MOD_0, /* old module style */ - MOD_1, /* old style, but symbols here */ - MOD_2, /* new style, exported symbols */ - } type; - struct symbol_entry *exported_symbols; - struct symbol_entry *required_symbols; -}; - -#define STD_MOD(t, exp, req) \ -struct module_symbols mod_data = { \ - .load_module = load_module, \ - .unload_module = unload_module, \ - .description = description, \ - .key = key, \ - .reload = reload, \ - .usecount = usecount, \ - .type = t, \ - .exported_symbols = exp, \ - .required_symbols = req \ -}; - +#define STANDARD_USECOUNT(res) { \ + res = localusecnt; \ +} + #if defined(__cplusplus) || defined(c_plusplus) } #endif diff --git a/loader.c b/loader.c index d9908e5f5e..2639b98c57 100644 --- a/loader.c +++ b/loader.c @@ -33,7 +33,6 @@ ASTERISK_FILE_VERSION(__FILE__, "$Revision$") -#include "asterisk/linkedlists.h" #include "asterisk/module.h" #include "asterisk/options.h" #include "asterisk/config.h" @@ -57,29 +56,13 @@ ASTERISK_FILE_VERSION(__FILE__, "$Revision$") #define RTLD_NOW 0 #endif + static int modlistver = 0; /* increase whenever the list changes, to protect reload */ static unsigned char expected_key[] = { 0x8e, 0x93, 0x22, 0x83, 0xf5, 0xc3, 0xc0, 0x75, 0xff, 0x8b, 0xa9, 0xbe, 0x7c, 0x43, 0x74, 0x63 }; -/* - * Modules can be in a number of different states, as below: - * MS_FAILED attempt to load failed. This is final. - * MS_NEW just added to the list, symbols unresolved. - * MS_RESOLVED all symbols resolved, but supplier modules not active yet. - * MS_CANLOAD all symbols resolved and suppliers are all active - * (or we are in a cyclic dependency and we are breaking a loop) - * MS_ACTIVE load() returned successfully. - */ -enum st_t { /* possible states of a module */ - MS_FAILED = 0, /* cannot load */ - MS_NEW = 1, /* nothing known */ - MS_RESOLVED = 2, /* all required resolved */ - MS_CANLOAD = 3, /* as above, plus cyclic depend.*/ - MS_ACTIVE = 4, /* all done */ -}; - /* * All module symbols are in module_symbols. * Modules are then linked in a list of struct module, @@ -90,18 +73,21 @@ enum st_t { /* possible states of a module */ * * A second lock, reloadlock, is used to prevent concurrent reloads */ + +struct module_symbols { + int (*load_module)(void); + int (*unload_module)(void); + int (*usecount)(void); + char *(*description)(void); + char *(*key)(void); + int (*reload)(void); +}; + struct module { AST_LIST_ENTRY(module) next; struct module_symbols cb; void *lib; /* the shared lib */ char resource[256]; - - enum st_t state; - int export_refcount; /* how many users of exported symbols */ - - ast_mutex_t mtx; /* for future use */ - struct localuser *lu; - int localusecnt; }; @@ -114,340 +100,6 @@ static AST_LIST_HEAD_STATIC(module_list, module); static AST_LIST_HEAD_STATIC(updaters, loadupdate); AST_MUTEX_DEFINE_STATIC(reloadlock); -/* - * helper localuser routines. - * All of these routines are extremely expensive, so the use of - * macros is totally unnecessary from the point of view of performance: - * the extra function call will be totally negligible in all cases. - */ - -struct localuser *ast_localuser_add(struct ast_module_lock *m, - struct ast_channel *chan) -{ - struct localuser *u = ast_calloc(1, sizeof(*u)); - if (u == NULL) - return NULL; - u->chan = chan; - ast_mutex_lock(&m->lock); - AST_LIST_INSERT_HEAD(&m->u, u, next); - m->usecnt++; - ast_mutex_unlock(&m->lock); - ast_update_use_count(); - return u; -} - -void ast_localuser_remove(struct ast_module_lock *m, struct localuser *u) -{ - ast_mutex_lock(&m->lock); - AST_LIST_REMOVE(&m->u, u, next); - m->usecnt--; - free(u); - ast_mutex_unlock(&m->lock); - ast_update_use_count(); -} - -void ast_hangup_localusers(struct ast_module_lock *m) -{ - struct localuser *u; - ast_mutex_lock(&m->lock); - AST_LIST_TRAVERSE_SAFE_BEGIN(&m->u, u, next) { - ast_softhangup(u->chan, AST_SOFTHANGUP_APPUNLOAD); - free(u); - AST_LIST_REMOVE_CURRENT(&m->u, next); - } - AST_LIST_TRAVERSE_SAFE_END - m->usecnt = 0; - ast_mutex_unlock(&m->lock); - ast_update_use_count(); -} - -/*--- new-style loader routines ---*/ - -/* - * For backward compatibility, we have 3 types of loadable modules: - * - * MOD_0 these are the 'old style' modules, which export a number - * of callbacks, and their full interface, as globally visible - * symbols. The module needs to be loaded with RTLD_LAZY and - * RTLD_GLOBAL to make symbols visible to other modules, and - * to avoid load failures due to cross dependencies. - * - * MOD_1 almost as above, but the generic callbacks are all into a - * a structure, mod_data. Same load requirements as above. - * - * MOD_2 this is the 'new style' format for modules. The module must - * explictly declare which simbols are exported and which - * symbols from other modules are used, and the code in this - * loader will implement appropriate checks to load the modules - * in the correct order. Also this allows to load modules - * with RTLD_NOW and RTLD_LOCAL so there is no chance of run-time - * bugs due to unresolved symbols or name conflicts. - */ - -/* - * helper routine to print the symbolic name associated to a state - */ -static const char *st_name(enum st_t state) -{ - /* try to resolve required symbols */ - const char *st; - switch (state) { -#define ST(x) case x: st = # x; break; - ST(MS_NEW); - ST(MS_FAILED); - ST(MS_RESOLVED); - ST(MS_ACTIVE); - ST(MS_CANLOAD); - default: - st = "unknown"; - } - return st; -#undef ST -} - -/*! \brief - * Fetch/release an exported symbol - modify export_refcount by delta - * \param delta 1 to fetch a symbol, -1 to release it. - * on success, return symbol value. - * Note, modules in MS_FAIL will never match in a 'get' request. - * If src is non-NULL, on exit *src points to the source module. - * - * Must be called with the lock held. - */ -static void *module_symbol_helper(const char *name, - int delta, struct module **src) -{ - void *ret = NULL; - struct module *m; - - AST_LIST_TRAVERSE(&module_list, m, next) { - struct symbol_entry *es; - if (delta > 0 && m->state == MS_FAILED) - continue; /* cannot 'get' a symbol from a failed module */ - for (es = m->cb.exported_symbols; ret == NULL && es && es->name; es++) { - if (!strcmp(es->name, name)) { - ret = es->value; - m->export_refcount += delta; - if (src) - *src = m; - break; - } - } - if (ret) - break; - } - if (ret == NULL) - ast_log(LOG_WARNING, "symbol %s not found\n", name); - return ret; -} - -static void *release_module_symbol(const char *name) -{ - return module_symbol_helper(name, -1, NULL); -} - -static void *get_module_symbol(const char *name, struct module **src) -{ - return module_symbol_helper(name, +1, src); -} - -/*! - * \brief Release refcounts to all imported symbols, - * and change module state to MS_FAILED. - */ -static void release_module(struct module *m) -{ - struct symbol_entry *s; - - for (s = m->cb.required_symbols; s && s->name != NULL; s++) { - if (s->value != NULL) { - release_module_symbol(s->name); - s->value = NULL; - } - } - m->state = MS_FAILED; -} - -/*! \brief check that no NULL symbols are exported - the algorithms rely on that. */ -static int check_exported(struct module *m) -{ - struct symbol_entry *es = m->cb.exported_symbols; - int errors = 0; - - if (es == NULL) - return 0; - ast_log(LOG_WARNING, "module %s exports the following symbols\n", - es->name); - for (; es->name; es++) { - void **p = es->value; - int i; - - ast_log(LOG_WARNING, "\taddr %p size %8d %s\n", - es->value, es->size, es->name); - for (i = 0; i < es->size / sizeof(void *); i++, p++) { - if (*p == NULL) { - ast_log(LOG_WARNING, "\t *** null field at offset %d\n", i); - errors++; - } - } - } - return errors; -} - -/*! - * \brief Resolve symbols and change state accordingly. - * Return 1 if state changed, 0 otherwise. - * If MS_FAILED, MS_ACTIVE or MS_CANLOAD there is nothing to do. - * If a symbol cannot be resolved (no supplier or supplier in MS_FAIL), - * move to MS_FAIL and release all symbols; - * If all suppliers are MS_ACTIVE, move to MS_CANLOAD - * otherwise move to MS_RESOLVED. - */ -static int resolve(struct module *m) -{ - struct symbol_entry *s; - - if (m->state == MS_FAILED || m->state == MS_ACTIVE || m->state == MS_CANLOAD) - return 0; /* already decided what to do */ - /* now it's either MS_NEW or MS_RESOLVED. - * Be optimistic and put it in MS_CANLOAD, then try to - * resolve and verify symbols, and downgrade as appropriate. - */ - m->state = MS_CANLOAD; - for (s = m->cb.required_symbols; s && s->name != NULL; s++) { - void **p = (void **)(s->value); - - if (*p == NULL) /* symbol not resolved yet */ - *p = get_module_symbol(s->name, &s->src); - if (*p == NULL || s->src->state == MS_FAILED) { /* fail */ - ast_log(LOG_WARNING, - "Unresolved symbol %s for module %s\n", - s->name, m->resource); - release_module(m); /* and set to MS_FAILED */ - break; - } - if (s->src->state != MS_ACTIVE) - m->state = MS_RESOLVED; /* downgrade */ - } - return 1; -} - -/* - * Fixup references and load modules according to their dependency order. - * Called when new modules are added to the list. - * The algorithm is as follows: - * - all modules MS_FAILED are changed to MS_NEW, in case something - * happened that could help them. - * - first try to resolve symbols. If successful, change the - * module's state to MS_RESOLVED otherwise to MS_FAILED - * - repeat on all modules until there is progress: - * . if it is MS_ACTIVE or MS_FAILED, continue (no progress) - * . if one has all required modules in MS_ACTIVE, try to load it. - * If successful it becomes MS_ACTIVE itself, otherwise - * MS_FAILED and releases all symbols. - * In any case, we have progress. - * . if one of the dependencies is MS_FAILED, release and set to - * MS_FAILED here too. We have progress. - * - if we have no progress there is a cyclic dependency. - * Take first and change to MS_CANLOAD, i.e. as if all required are - * MS_ACTIVE. we have progress, so repeat. - * NOTE: - * must be called with lock held - * recursive calls simply return success. - */ -static int fixup(const char *caller) -{ - struct module *m; - int total = 0, new = 0, cycle = 0; - static int in_fixup = 0; /* disable recursive calls */ - - if (in_fixup) - return 0; - in_fixup++; - AST_LIST_TRAVERSE(&module_list, m, next) { - total++; - if (m->state == MS_FAILED) - m->state = MS_NEW; - if (m->state == MS_NEW) - new++; - /* print some debugging info for new modules */ - if (m->state == MS_NEW && - (m->cb.exported_symbols || m->cb.required_symbols)) - ast_log(LOG_WARNING, - "module %-30s exports %p requires %p state %s(%d)\n", - m->resource, m->cb.exported_symbols, - m->cb.required_symbols, - st_name(m->state), m->state); - } - ast_log(LOG_WARNING, "---- fixup (%s): %d modules, %d new ---\n", - caller, total, new); - for (;;cycle++) { - int again = 0; /* set if we need another round */ - - ast_log(LOG_WARNING, "---- fixup: cycle %d ---\n", cycle); - AST_LIST_TRAVERSE(&module_list, m, next) { - if (resolve(m)) - again = 1; /* something changed */ - if (m->state != MS_CANLOAD) /* for now, done with this module */ - continue; - /* try to run the load routine */ - if (m->cb.load_module()) { /* error */ - ast_log(LOG_WARNING, "load_module %s fail\n", - m->resource); - release_module(m); /* and set to MS_FAIL */ - } else { - ast_log(LOG_WARNING, "load_module %s success\n", - m->resource); - m->state = MS_ACTIVE; - } - again = 1; /* something has changed */ - } - /* Modules in MS_RESOLVED mean a possible cyclic dependency. - * Break the indecision by setting one to CANLOAD, and repeat. - */ - AST_LIST_TRAVERSE(&module_list, m, next) { - if (m->state == MS_RESOLVED) { - m->state = MS_CANLOAD; - again = 1; - break; - } - } - if (!again) /* we are done */ - break; - } - ast_log(LOG_WARNING, "---- fixup complete ---\n"); - in_fixup--; - return 0; -} - -/* test routines to see which modules depend on global symbols - * exported by other modules. - */ -static void check_symbols(void) -{ - struct dirent *d; - DIR *mods = opendir(ast_config_AST_MODULE_DIR); - void *lib; - char buf[1024]; - - ast_log(LOG_WARNING, "module dir <%s>\n", ast_config_AST_MODULE_DIR); - if (!mods) - return; - while((d = readdir(mods))) { - int ld = strlen(d->d_name); - /* Must end in .so to load it. */ - if (ld <= 3 || strcasecmp(d->d_name + ld - 3, ".so")) - continue; - snprintf(buf, sizeof(buf), "%s/%s", ast_config_AST_MODULE_DIR, d->d_name); - lib = dlopen(buf, RTLD_NOW | RTLD_LOCAL); - if (lib == NULL) { - ast_log(LOG_WARNING, "module %s error %s\n", d->d_name, dlerror()); - } - dlclose(lib); - } -} -/*--- end new-style routines ---*/ - /* * In addition to modules, the reload command handles some extra keywords * which are listed here together with the corresponding handlers. @@ -530,7 +182,6 @@ int ast_unload_resource(const char *resource_name, int force) } else ast_log(LOG_WARNING, "** Dangerous **: Unloading resource anyway, at user request\n"); } - release_module(cur); /* bookkeeping */ AST_LIST_REMOVE_CURRENT(&module_list, next); dlclose(cur->lib); free(cur); @@ -571,24 +222,6 @@ char *ast_module_helper(const char *line, const char *word, int pos, int state, return ret; } -/*! - * \brief Given a function address, find the corresponding module. - * This is required as a workaround to the fact that we do not - * have a module argument to the load_module() function. - * Hopefully the performance implications are small. - */ -struct module *ast_find_module(int (*load_fn)(void)) -{ - struct module *cur; - AST_LIST_LOCK(&module_list); - AST_LIST_TRAVERSE(&module_list, cur, next) { - if (cur->cb.load_module == load_fn) - break; - } - AST_LIST_UNLOCK(&module_list); - return cur; -} - int ast_module_reload(const char *name) { struct module *cur; @@ -672,14 +305,13 @@ static void *find_symbol(struct module *m, const char *name, int verbose) } /* XXX cfg is only used for !res_* and #ifdef RTLD_GLOBAL */ -static struct module * __load_resource(const char *resource_name, - const struct ast_config *cfg) +static int __load_resource(const char *resource_name, const struct ast_config *cfg) { static char fn[256]; int errors=0; int res; struct module *cur; - struct module_symbols *m, *m1; + struct module_symbols *m; int flags=RTLD_NOW; unsigned char *key; char tmp[80]; @@ -707,11 +339,11 @@ static struct module * __load_resource(const char *resource_name, if (resource_exists(resource_name, 0)) { ast_log(LOG_WARNING, "Module '%s' already exists\n", resource_name); AST_LIST_UNLOCK(&module_list); - return NULL; + return -1; } if (!(cur = ast_calloc(1, sizeof(*cur)))) { AST_LIST_UNLOCK(&module_list); - return NULL; + return -1; } m = &cur->cb; ast_copy_string(cur->resource, resource_name, sizeof(cur->resource)); @@ -719,45 +351,29 @@ static struct module * __load_resource(const char *resource_name, ast_copy_string(fn, resource_name, sizeof(fn)); else snprintf(fn, sizeof(fn), "%s/%s", ast_config_AST_MODULE_DIR, resource_name); - /* first, open in a sane way */ - cur->lib = dlopen(fn, RTLD_NOW | RTLD_LOCAL); - if (cur->lib == NULL) { - ast_log(LOG_WARNING, "test %s\n", dlerror()); - } else - dlclose(cur->lib); - cur->lib = dlopen(fn, flags); if (!cur->lib) { ast_log(LOG_WARNING, "%s\n", dlerror()); free(cur); AST_LIST_UNLOCK(&module_list); - return NULL; - } - m1 = find_symbol(cur, "mod_data", 0); - if (m1 != NULL) { /* new style module */ - errors = check_exported(cur); - *m = *m1; - if (m->type == MOD_2) - ast_log(LOG_WARNING, "new style %s, should unload and reload with RTLD_LOCAL\n", resource_name); - } else { - m->type = MOD_0; - m->load_module = find_symbol(cur, "load_module", 1); - m->unload_module = find_symbol(cur, "unload_module", 1); - m->usecount = find_symbol(cur, "usecount", 1); - m->description = find_symbol(cur, "description", 1); - m->key = find_symbol(cur, "key", 1); - m->reload = find_symbol(cur, "reload", 0); + return -1; } + m->load_module = find_symbol(cur, "load_module", 1); if (!m->load_module) errors++; + m->unload_module = find_symbol(cur, "unload_module", 1); if (!m->unload_module) errors++; + m->usecount = find_symbol(cur, "usecount", 1); if (!m->usecount) errors++; + m->description = find_symbol(cur, "description", 1); if (!m->description) errors++; + m->key = find_symbol(cur, "key", 1); if (!m->key) errors++; + m->reload = find_symbol(cur, "reload", 0); if (!m->key || !(key = (unsigned char *) m->key())) { ast_log(LOG_WARNING, "Key routine returned NULL in module %s\n", fn); key = NULL; @@ -772,7 +388,7 @@ static struct module * __load_resource(const char *resource_name, dlclose(cur->lib); free(cur); AST_LIST_UNLOCK(&module_list); - return NULL; + return -1; } if (!ast_fully_booted) { if (option_verbose) @@ -789,64 +405,30 @@ static struct module * __load_resource(const char *resource_name, so reload commands will be issued in same order modules were loaded */ modlistver++; - if (m->type == MOD_2) { - ast_log(LOG_WARNING, "new-style module %s, deferring load()\n", - resource_name); - cur->state = MS_NEW; - } else - cur->state = MS_CANLOAD; - /* XXX TODO: make sure the usecount is 1 before releasing the lock */ AST_LIST_UNLOCK(&module_list); - - if (cur->state == MS_CANLOAD && (res = m->load_module())) { + if ((res = m->load_module())) { ast_log(LOG_WARNING, "%s: load_module failed, returning %d\n", resource_name, res); ast_unload_resource(resource_name, 0); - return NULL; + return -1; } - cur->state = MS_ACTIVE; ast_update_use_count(); - return cur; + return 0; } -/* - * load a single module (API call). - * (recursive calls from load_module() succeed. - * Returns 0 on success, -1 on error. - */ int ast_load_resource(const char *resource_name) { - int o = option_verbose; + int res, o = option_verbose; struct ast_config *cfg = NULL; - struct module *m; option_verbose = 0; /* Keep the module file parsing silent */ cfg = ast_config_load(AST_MODULE_CONFIG); option_verbose = o; /* restore verbosity */ - m = __load_resource(resource_name, cfg); + res = __load_resource(resource_name, cfg); if (cfg) ast_config_destroy(cfg); - return m ? 0 : -1; + return res; } -#if 0 -/* - * load a single module (API call). - * (recursive calls from load_module() succeed. - */ -int ast_load_resource(const char *resource_name) -{ - struct module *m; - int ret; - - ast_mutex_lock(&modlock); - m = __load_resource(resource_name, 0); - fixup(resource_name); - ret = (m->state == MS_FAILED) ? -1 : 0; - ast_mutex_unlock(&modlock); - return ret; -} -#endif - /* if enabled, log and output on console the module's name, and try load it */ static int print_and_load(const char *s, struct ast_config *cfg) { @@ -859,7 +441,7 @@ static int print_and_load(const char *s, struct ast_config *cfg) term_color(tmp, s, COLOR_BRWHITE, 0, sizeof(tmp))); fflush(stdout); } - if (__load_resource(s, cfg)) + if (!__load_resource(s, cfg)) return 0; /* success */ ast_log(LOG_WARNING, "Loading module %s failed!\n", s); return -1; @@ -876,6 +458,7 @@ static const char *loadorder[] = int load_modules(const int preload_only) { struct ast_config *cfg; + struct ast_variable *v; int x; if (option_verbose) { @@ -884,13 +467,9 @@ int load_modules(const int preload_only) "Asterisk Dynamic Loader Starting:\n"); } - check_symbols(); - cfg = ast_config_load(AST_MODULE_CONFIG); - if (cfg) { const char *cmd = preload_only ? "preload" : "load"; - struct ast_variable *v; /* Load explicitly defined modules */ for (v = ast_variable_browse(cfg, "modules"); v; v = v->next) { if (strcasecmp(v->name, cmd)) /* not what we are looking for */ @@ -902,12 +481,16 @@ int load_modules(const int preload_only) } } - if (preload_only) - goto done; + if (preload_only) { + ast_config_destroy(cfg); + return 0; + } - if (cfg && !ast_true(ast_variable_retrieve(cfg, "modules", "autoload"))) + if (cfg && !ast_true(ast_variable_retrieve(cfg, "modules", "autoload"))) { /* no autoload */ - goto done; + ast_config_destroy(cfg); + return 0; + } /* * Load all modules. To help resolving dependencies, we load modules * in the order defined by loadorder[], with the final step for @@ -934,10 +517,9 @@ int load_modules(const int preload_only) !strcasecmp(d->d_name + ld - 3, ".so") && !resource_exists(d->d_name, 1)) { /* It's a shared library, check if we are allowed to load it - * (very inefficient, but oh well). + * (very inefficient, but oh well. */ if (cfg) { - struct ast_variable *v; for (v = ast_variable_browse(cfg, "modules"); v; v = v->next) { if (!strcasecmp(v->name, "noload") && !strcasecmp(v->value, d->d_name)) @@ -961,8 +543,6 @@ int load_modules(const int preload_only) } closedir(mods); } -done: - fixup("load_modules"); ast_config_destroy(cfg); return 0; } @@ -977,6 +557,7 @@ void ast_update_use_count(void) AST_LIST_TRAVERSE(&updaters, m, next) m->updater(); AST_LIST_UNLOCK(&module_list); + } int ast_update_module_list(int (*modentry)(const char *module, const char *description, int usecnt, const char *like), diff --git a/res/res_smdi.c b/res/res_smdi.c index 8adab88d10..e8607ebe12 100644 --- a/res/res_smdi.c +++ b/res/res_smdi.c @@ -59,7 +59,8 @@ static int smdi_load(int reload); /* Use count stuff */ -STANDARD_USECOUNT_DECL; +AST_MUTEX_DEFINE_STATIC(localuser_lock); +static int localusecnt = 0; /*! \brief SMDI interface container. */ struct ast_smdi_interface_container { @@ -504,7 +505,10 @@ void ast_smdi_interface_destroy(struct ast_smdi_interface *iface) ASTOBJ_CONTAINER_DESTROY(&iface->mwi_q); free(iface); - STANDARD_DECREMENT_USECOUNT; + ast_mutex_lock(&localuser_lock); + localusecnt--; + ast_mutex_unlock(&localuser_lock); + ast_update_use_count(); } /*! @@ -688,7 +692,10 @@ static int smdi_load(int reload) ASTOBJ_CONTAINER_LINK(&smdi_ifaces, iface); ASTOBJ_UNREF(iface, ast_smdi_interface_destroy); - STANDARD_INCREMENT_USECOUNT; + ast_mutex_lock(&localuser_lock); + localusecnt++; + ast_mutex_unlock(&localuser_lock); + ast_update_use_count(); } else { ast_log(LOG_NOTICE, "Ignoring unknown option %s in %s\n", v->name, config_file); }