revert loader changes that have clearly not undergone adequate testing before commit
authorKevin P. Fleming <kpfleming@digium.com>
Sat, 25 Mar 2006 23:22:44 +0000 (23:22 +0000)
committerKevin P. Fleming <kpfleming@digium.com>
Sat, 25 Mar 2006 23:22:44 +0000 (23:22 +0000)
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@14952 65c4cc65-6c06-0410-ace0-fbb531ad65f3

14 files changed:
asterisk.c
codecs/codec_a_mu.c
codecs/codec_adpcm.c
codecs/codec_alaw.c
codecs/codec_g723_1.c
codecs/codec_g726.c
codecs/codec_gsm.c
codecs/codec_ilbc.c
codecs/codec_lpc10.c
codecs/codec_speex.c
codecs/codec_ulaw.c
include/asterisk/module.h
loader.c
res/res_smdi.c

index d5394ca..e26e6a5 100644 (file)
@@ -1,7 +1,7 @@
 /*
  * Asterisk -- An open source telephony toolkit.
  *
- * Copyright (C) 1999 - 2005, Digium, Inc.
+ * Copyright (C) 1999 - 2006, Digium, Inc.
  *
  * Mark Spencer <markster@digium.com>
  *
@@ -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());
index f03612b..c21b26c 100644 (file)
@@ -316,7 +316,7 @@ char *description(void)
 int usecount(void)
 {
        int res;
-       OLD_STANDARD_USECOUNT(res);
+       STANDARD_USECOUNT(res);
        return res;
 }
 
index 19970a5..19fd33c 100644 (file)
@@ -616,7 +616,7 @@ char *description(void)
 int usecount(void)
 {
        int res;
-       OLD_STANDARD_USECOUNT(res);
+       STANDARD_USECOUNT(res);
        return res;
 }
 
index 480b92c..a56e42a 100644 (file)
@@ -416,7 +416,7 @@ char *description(void)
 int usecount(void)
 {
        int res;
-       OLD_STANDARD_USECOUNT(res);
+       STANDARD_USECOUNT(res);
        return res;
 }
 
index c226bb0..fc508ff 100644 (file)
@@ -407,7 +407,7 @@ char *description(void)
 int usecount(void)
 {
        int res;
-       OLD_STANDARD_USECOUNT(res);
+       STANDARD_USECOUNT(res);
        return res;
 }
 
index 6a33d85..2a39e90 100644 (file)
@@ -1078,7 +1078,7 @@ int
 usecount (void)
 {
   int res;
-  OLD_STANDARD_USECOUNT (res);
+  STANDARD_USECOUNT (res);
   return res;
 }
 
index 59ce77f..ee28e85 100644 (file)
@@ -347,7 +347,7 @@ char *description(void)
 int usecount(void)
 {
        int res;
-       OLD_STANDARD_USECOUNT(res);
+       STANDARD_USECOUNT(res);
        return res;
 }
 
index fb042cf..8c928fb 100644 (file)
@@ -307,7 +307,7 @@ char *description(void)
 int usecount(void)
 {
        int res;
-       OLD_STANDARD_USECOUNT(res);
+       STANDARD_USECOUNT(res);
        return res;
 }
 
index f9157cd..fe37383 100644 (file)
@@ -420,7 +420,7 @@ char *description(void)
 int usecount(void)
 {
        int res;
-       OLD_STANDARD_USECOUNT(res);
+       STANDARD_USECOUNT(res);
        return res;
 }
 
index fc9b22b..7d7871e 100644 (file)
@@ -602,7 +602,7 @@ char *description(void)
 int usecount(void)
 {
        int res;
-       OLD_STANDARD_USECOUNT(res);
+       STANDARD_USECOUNT(res);
        return res;
 }
 
index 4f38a02..3833201 100644 (file)
@@ -418,7 +418,7 @@ char *description(void)
 int usecount(void)
 {
        int res;
-       OLD_STANDARD_USECOUNT(res);
+       STANDARD_USECOUNT(res);
        return res;
 }
 
index 1c01d48..e159642 100644 (file)
 
 #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.
  *
  * <b>Sample Usage:</b>
  * \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
index d9908e5..2639b98 100644 (file)
--- 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,6 +56,7 @@ 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[] =
@@ -64,23 +64,6 @@ static unsigned char expected_key[] =
   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,
  * whereas updaters are in a list of struct loadupdate.
@@ -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;
 };
 
 
@@ -115,340 +101,6 @@ 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.
  * This table is also used by the command completion code.
@@ -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),
index 8adab88..e8607eb 100644 (file)
@@ -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);
                }