X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=src%2Fmodules%2Fmodules.c;h=0f39d63904f5a7b63bb5b7629b643d7688527f89;hb=7a0f1546bb8661f9983dae865c7429f495270c48;hp=ba5a072dd1049e5f8adcb6a2ab100062f8c685be;hpb=6962020b256671f0d54793afbbd2e63d7a0e5d0b;p=vlc

diff --git a/src/modules/modules.c b/src/modules/modules.c
index ba5a072dd1..0f39d63904 100644
--- a/src/modules/modules.c
+++ b/src/modules/modules.c
@@ -28,7 +28,8 @@
 # include "config.h"
 #endif
 
-#include <vlc/vlc.h>
+#include <vlc_common.h>
+#include <vlc_plugin.h>
 #include "libvlc.h"
 
 /* Some faulty libcs have a broken struct dirent when _FILE_OFFSET_BITS
@@ -84,10 +85,14 @@
 #include "config/configuration.h"
 
 #include "vlc_charset.h"
+#include "vlc_arrays.h"
 
 #include "modules/modules.h"
 #include "modules/builtin.h"
 
+static module_bank_t *p_module_bank = NULL;
+static vlc_mutex_t module_lock = VLC_STATIC_MUTEX;
+
 /*****************************************************************************
  * Local prototypes
  *****************************************************************************/
@@ -98,14 +103,12 @@ static int  AllocatePluginFile  ( vlc_object_t *, char *, int64_t, int64_t );
 static module_t * AllocatePlugin( vlc_object_t *, char * );
 #endif
 static int  AllocateBuiltinModule( vlc_object_t *, int ( * ) ( module_t * ) );
-static int  DeleteModule ( module_t *, vlc_bool_t );
+static void DeleteModule ( module_bank_t *, module_t * );
 #ifdef HAVE_DYNAMIC_PLUGINS
 static void   DupModule        ( module_t * );
 static void   UndupModule      ( module_t * );
 #endif
 
-static void module_LoadMain( vlc_object_t *p_this );
-
 /**
  * Init bank
  *
@@ -117,37 +120,32 @@ static void module_LoadMain( vlc_object_t *p_this );
 void __module_InitBank( vlc_object_t *p_this )
 {
     module_bank_t *p_bank = NULL;
-    vlc_value_t  lockval;
-    libvlc_global_data_t *p_libvlc_global = vlc_global();
 
-    var_Create( p_libvlc_global, "libvlc", VLC_VAR_MUTEX );
-    var_Get( p_libvlc_global, "libvlc", &lockval );
-    vlc_mutex_lock( lockval.p_address );
-    if( p_libvlc_global->p_module_bank )
+    vlc_mutex_lock( &module_lock );
+
+    if( p_module_bank == NULL )
     {
-        p_libvlc_global->p_module_bank->i_usage++;
-        vlc_mutex_unlock( lockval.p_address );
-        var_Destroy( p_libvlc_global, "libvlc" );
-        return;
+        p_bank = calloc (1, sizeof(*p_bank));
+        p_bank->i_usage = 1;
+        p_bank->i_cache = p_bank->i_loaded_cache = 0;
+        p_bank->pp_cache = p_bank->pp_loaded_cache = NULL;
+        p_bank->b_cache = p_bank->b_cache_dirty = false;
+        p_bank->head = NULL;
+
+        /* Everything worked, attach the object */
+        p_module_bank = p_bank;
+
+        /* Fills the module bank structure with the main module infos.
+         * This is very useful as it will allow us to consider the main
+         * library just as another module, and for instance the configuration
+         * options of main will be available in the module bank structure just
+         * as for every other module. */
+        AllocateBuiltinModule( p_this, vlc_entry__main );
     }
-    vlc_mutex_unlock( lockval.p_address );
-    var_Destroy( p_libvlc_global, "libvlc" );
+    else
+        p_module_bank->i_usage++;
 
-    p_bank = vlc_object_create( p_this, sizeof(module_bank_t) );
-    if( !p_bank )
-        return;
-    p_bank->psz_object_name = "module bank";
-    p_bank->i_usage = 1;
-    p_bank->i_cache = p_bank->i_loaded_cache = 0;
-    p_bank->pp_cache = p_bank->pp_loaded_cache = NULL;
-    p_bank->b_cache = p_bank->b_cache_dirty =
-        p_bank->b_cache_delete = VLC_FALSE;
-
-    /* Everything worked, attach the object */
-    p_libvlc_global->p_module_bank = p_bank;
-    vlc_object_attach( p_bank, p_libvlc_global );
-
-    module_LoadMain( p_this );
+    vlc_mutex_unlock( &module_lock );
 }
 
 
@@ -161,41 +159,31 @@ void __module_InitBank( vlc_object_t *p_this )
  */
 void __module_EndBank( vlc_object_t *p_this )
 {
-    module_t * p_next = NULL;
-    vlc_value_t lockval;
-    libvlc_global_data_t *p_libvlc_global = vlc_global();
-
-    var_Create( p_libvlc_global, "libvlc", VLC_VAR_MUTEX );
-    var_Get( p_libvlc_global, "libvlc", &lockval );
-    vlc_mutex_lock( lockval.p_address );
-    if( !p_libvlc_global->p_module_bank )
-    {
-        vlc_mutex_unlock( lockval.p_address );
-        var_Destroy( p_libvlc_global, "libvlc" );
-        return;
-    }
-    if( --p_libvlc_global->p_module_bank->i_usage )
-    {
-        vlc_mutex_unlock( lockval.p_address );
-        var_Destroy( p_libvlc_global, "libvlc" );
-        return;
-    }
-    vlc_mutex_unlock( lockval.p_address );
-    var_Destroy( p_libvlc_global, "libvlc" );
+    module_bank_t *p_bank;
 
     /* Save the configuration */
     config_AutoSaveConfigFile( p_this );
 
+    vlc_mutex_lock( &module_lock );
+    p_bank = p_module_bank;
+    assert (p_bank != NULL);
+    if( --p_bank->i_usage > 0 )
+    {
+        vlc_mutex_unlock( &module_lock );
+        return;
+    }
+    p_module_bank = NULL;
+    vlc_mutex_unlock( &module_lock );
+
 #ifdef HAVE_DYNAMIC_PLUGINS
-# define p_bank p_libvlc_global->p_module_bank
-    if( p_bank->b_cache ) CacheSave( p_this );
+    if( p_bank->b_cache )
+        CacheSave( p_this, p_bank );
     while( p_bank->i_loaded_cache-- )
     {
         if( p_bank->pp_loaded_cache[p_bank->i_loaded_cache] )
         {
-            DeleteModule(
-                    p_bank->pp_loaded_cache[p_bank->i_loaded_cache]->p_module,
-                    p_bank->pp_loaded_cache[p_bank->i_loaded_cache]->b_used );
+            DeleteModule( p_bank,
+                    p_bank->pp_loaded_cache[p_bank->i_loaded_cache]->p_module );
             free( p_bank->pp_loaded_cache[p_bank->i_loaded_cache]->psz_file );
             free( p_bank->pp_loaded_cache[p_bank->i_loaded_cache] );
             p_bank->pp_loaded_cache[p_bank->i_loaded_cache] = NULL;
@@ -217,60 +205,12 @@ void __module_EndBank( vlc_object_t *p_this )
         free( p_bank->pp_cache );
         p_bank->pp_cache = NULL;
     }
-# undef p_bank
 #endif
 
-    vlc_object_detach( p_libvlc_global->p_module_bank );
-
-    while( p_libvlc_global->p_module_bank->i_children )
-    {
-        p_next = (module_t *)p_libvlc_global->p_module_bank->pp_children[0];
-
-        if( DeleteModule( p_next, VLC_TRUE ) )
-        {
-            /* Module deletion failed */
-            msg_Err( p_this, "module \"%s\" can't be removed, trying harder",
-                     p_next->psz_object_name );
-
-            /* We just free the module by hand. Niahahahahaha. */
-            vlc_object_detach( p_next );
-            vlc_object_release( p_next );
-        }
-    }
-
-    vlc_object_release( p_libvlc_global->p_module_bank );
-    p_libvlc_global->p_module_bank = NULL;
-}
-
-/**
- * Load the main program info into the module bank.
- *
- * Fills the module bank structure with the main module infos.
- * This is very useful as it will allow us to consider the main program just
- * as another module, and for instance the configuration options of main will
- * be available in the module bank structure just as for every other module.
- * \param p_this vlc object structure
- * \return nothing
- */
-static void module_LoadMain( vlc_object_t *p_this )
-{
-    vlc_value_t lockval;
-    libvlc_global_data_t *p_libvlc_global = vlc_global();
-
-    var_Create( p_libvlc_global, "libvlc", VLC_VAR_MUTEX );
-    var_Get( p_libvlc_global, "libvlc", &lockval );
-    vlc_mutex_lock( lockval.p_address );
-    if( p_libvlc_global->p_module_bank->b_main )
-    {
-        vlc_mutex_unlock( lockval.p_address );
-        var_Destroy( p_libvlc_global, "libvlc" );
-        return;
-    }
-    p_libvlc_global->p_module_bank->b_main = VLC_TRUE;
-    vlc_mutex_unlock( lockval.p_address );
-    var_Destroy( p_libvlc_global, "libvlc" );
+    while( p_bank->head != NULL )
+        DeleteModule( p_bank, p_bank->head );
 
-    AllocateBuiltinModule( p_this, vlc_entry__main );
+    free( p_bank );
 }
 
 /**
@@ -282,26 +222,21 @@ static void module_LoadMain( vlc_object_t *p_this )
  */
 void __module_LoadBuiltins( vlc_object_t * p_this )
 {
-    vlc_value_t lockval;
-    libvlc_global_data_t *p_libvlc_global = vlc_global();
-
-    var_Create( p_libvlc_global, "libvlc", VLC_VAR_MUTEX );
-    var_Get( p_libvlc_global, "libvlc", &lockval );
-    vlc_mutex_lock( lockval.p_address );
-    if( p_libvlc_global->p_module_bank->b_builtins )
+    vlc_mutex_lock( &module_lock );
+    if( p_module_bank->b_builtins )
     {
-        vlc_mutex_unlock( lockval.p_address );
-        var_Destroy( p_libvlc_global, "libvlc" );
+        vlc_mutex_unlock( &module_lock );
         return;
     }
-    p_libvlc_global->p_module_bank->b_builtins = VLC_TRUE;
-    vlc_mutex_unlock( lockval.p_address );
-    var_Destroy( p_libvlc_global, "libvlc" );
+    p_module_bank->b_builtins = true;
+    vlc_mutex_unlock( &module_lock );
 
     msg_Dbg( p_this, "checking builtin modules" );
+    /* FIXME: race here - do this under the lock!! */
     ALLOCATE_ALL_BUILTINS();
 }
 
+#undef module_LoadPlugins
 /**
  * Load all plugins
  *
@@ -310,33 +245,25 @@ void __module_LoadBuiltins( vlc_object_t * p_this )
  * \param p_this vlc object structure
  * \return nothing
  */
-void __module_LoadPlugins( vlc_object_t * p_this )
+void module_LoadPlugins( vlc_object_t * p_this, bool b_cache_delete )
 {
 #ifdef HAVE_DYNAMIC_PLUGINS
-    vlc_value_t lockval;
-    libvlc_global_data_t *p_libvlc_global = vlc_global();
-
-    var_Create( p_libvlc_global, "libvlc", VLC_VAR_MUTEX );
-    var_Get( p_libvlc_global, "libvlc", &lockval );
-    vlc_mutex_lock( lockval.p_address );
-    if( p_libvlc_global->p_module_bank->b_plugins )
+    vlc_mutex_lock( &module_lock );
+    if( p_module_bank->b_plugins )
     {
-        vlc_mutex_unlock( lockval.p_address );
-        var_Destroy( p_libvlc_global, "libvlc" );
+        vlc_mutex_unlock( &module_lock );
         return;
     }
-    p_libvlc_global->p_module_bank->b_plugins = VLC_TRUE;
-    vlc_mutex_unlock( lockval.p_address );
-    var_Destroy( p_libvlc_global, "libvlc" );
+    p_module_bank->b_plugins = true;
+    vlc_mutex_unlock( &module_lock );
 
     msg_Dbg( p_this, "checking plugin modules" );
+    p_module_bank->b_cache = config_GetInt( p_this, "plugins-cache" ) > 0;
 
-    if( config_GetInt( p_this, "plugins-cache" ) )
-        p_libvlc_global->p_module_bank->b_cache = VLC_TRUE;
-
-    if( p_libvlc_global->p_module_bank->b_cache ||
-        p_libvlc_global->p_module_bank->b_cache_delete ) CacheLoad( p_this );
+    if( p_module_bank->b_cache || b_cache_delete )
+        CacheLoad( p_this, p_module_bank, b_cache_delete );
 
+    /* FIXME: race - do this under the lock */
     AllocateAllPlugins( p_this );
 #endif
 }
@@ -348,7 +275,7 @@ void __module_LoadPlugins( vlc_object_t * p_this )
  * \param cap the capability to check
  * \return TRUE if the module have the capability
  */
-vlc_bool_t module_IsCapable( const module_t *m, const char *cap )
+bool module_provides( const module_t *m, const char *cap )
 {
     return !strcmp( m->psz_capability, cap );
 }
@@ -359,7 +286,7 @@ vlc_bool_t module_IsCapable( const module_t *m, const char *cap )
  * \param m the module
  * \return the module name
  */
-const char *module_GetObjName( const module_t *m )
+const char *module_get_object( const module_t *m )
 {
     return m->psz_object_name;
 }
@@ -371,7 +298,7 @@ const char *module_GetObjName( const module_t *m )
  * \param long_name TRUE to have the long name of the module
  * \return the short or long name of the module
  */
-const char *module_GetName( const module_t *m, vlc_bool_t long_name )
+const char *module_get_name( const module_t *m, bool long_name )
 {
     if( long_name && ( m->psz_longname != NULL) )
         return m->psz_longname;
@@ -385,54 +312,119 @@ const char *module_GetName( const module_t *m, vlc_bool_t long_name )
  * \param m the module
  * \return the help
  */
-const char *module_GetHelp( const module_t *m )
+const char *module_get_help( const module_t *m )
 {
     return m->psz_help;
 }
 
+module_t *module_hold (module_t *m)
+{
+    vlc_hold (&m->vlc_gc_data);
+    return m;
+}
+
+void module_release (module_t *m)
+{
+    vlc_release (&m->vlc_gc_data);
+}
+
+/**
+ * Frees the flat list of VLC modules.
+ * @param list list obtained by module_list_get()
+ * @param length number of items on the list
+ * @return nothing.
+ */
+void module_list_free (module_t **list)
+{
+    if (list == NULL)
+        return;
+
+    for (size_t i = 0; list[i] != NULL; i++)
+         module_release (list[i]);
+    free (list);
+}
+
+/**
+ * Gets the flat list of VLC modules.
+ * @param n [OUT] pointer to the number of modules or NULL
+ * @return NULL-terminated table of module pointers
+ *         (release with module_list_free()), or NULL in case of error.
+ */
+module_t **module_list_get (size_t *n)
+{
+    /* TODO: this whole module lookup is quite inefficient */
+    /* Remove this and improve module_need */
+    module_t **tab = NULL;
+    size_t i = 0;
+
+    assert (p_module_bank);
+    for (module_t *mod = p_module_bank->head; mod; mod = mod->next)
+    {
+         module_t **nt;
+         nt  = realloc (tab, (i + 2 + mod->submodule_count) * sizeof (*tab));
+         if (nt == NULL)
+         {
+             module_list_free (tab);
+             return NULL;
+         }
+
+         tab = nt;
+         tab[i++] = module_hold (mod);
+         for (module_t *subm = mod->submodule; subm; subm = subm->next)
+             tab[i++] = module_hold (subm);
+         tab[i] = NULL;
+    }
+    if (n != NULL)
+        *n = i;
+    return tab;
+}
+
+typedef struct module_list_t
+{
+    module_t *p_module;
+    int16_t  i_score;
+    bool     b_force;
+} module_list_t;
+
+static int modulecmp (const void *a, const void *b)
+{
+    const module_list_t *la = a, *lb = b;
+    /* Note that qsort() uses _ascending_ order,
+     * so the smallest module is the one with the biggest score. */
+    return lb->i_score - la->i_score;
+}
+
 /**
  * module Need
  *
  * Return the best module function, given a capability list.
+ *
+ * If the p_this object doesn't have it's psz_object_name set, then
+ * psz_object_name will be set to the module's name, unless the user
+ * provided an alias using the "module name@alias" syntax in which case
+ * psz_object_name will be set to the alias.
+ *
  * \param p_this the vlc object
  * \param psz_capability list of capabilities needed
  * \param psz_name name of the module asked
  * \param b_strict TRUE yto use the strict mode
  * \return the module or NULL in case of a failure
  */
-module_t * __module_Need( vlc_object_t *p_this, const char *psz_capability,
-                          const char *psz_name, vlc_bool_t b_strict )
+module_t * __module_need( vlc_object_t *p_this, const char *psz_capability,
+                          const char *psz_name, bool b_strict )
 {
-    typedef struct module_list_t module_list_t;
-
-    struct module_list_t
-    {
-        module_t *p_module;
-        int i_score;
-        vlc_bool_t b_force;
-        module_list_t *p_next;
-    };
-
-    module_list_t *p_list, *p_first, *p_tmp;
-    vlc_list_t *p_all;
-
-    int i_which_module, i_index = 0;
+    stats_TimerStart( p_this, "module_need()", STATS_TIMER_MODULE_NEED );
 
+    module_list_t *p_list;
     module_t *p_module;
-
-    int   i_shortcuts = 0;
+    int i_shortcuts = 0;
     char *psz_shortcuts = NULL, *psz_var = NULL, *psz_alias = NULL;
-    vlc_bool_t b_force_backup = p_this->b_force;
-
+    bool b_force_backup = p_this->b_force;
 
     /* Deal with variables */
     if( psz_name && psz_name[0] == '$' )
     {
-        vlc_value_t val;
-        var_Create( p_this, psz_name + 1, VLC_VAR_MODULE | VLC_VAR_DOINHERIT );
-        var_Get( p_this, psz_name + 1, &val );
-        psz_var = val.psz_string;
-        psz_name = psz_var;
+        psz_name = psz_var = var_CreateGetString( p_this, psz_name + 1 );
     }
 
     /* Count how many different shortcuts were asked for */
@@ -444,6 +436,9 @@ module_t * __module_Need( vlc_object_t *p_this, const char *psz_capability,
         if( !strcmp( psz_name, "none" ) )
         {
             free( psz_var );
+            stats_TimerStop( p_this, STATS_TIMER_MODULE_NEED );
+            stats_TimerDump( p_this, STATS_TIMER_MODULE_NEED );
+            stats_TimerClean( p_this, STATS_TIMER_MODULE_NEED );
             return NULL;
         }
 
@@ -465,54 +460,41 @@ module_t * __module_Need( vlc_object_t *p_this, const char *psz_capability,
         {
             if( !strcmp(psz_last_shortcut, "none") )
             {
-                b_strict = VLC_TRUE;
+                b_strict = true;
                 i_shortcuts--;
             }
             else if( !strcmp(psz_last_shortcut, "any") )
             {
-                b_strict = VLC_FALSE;
+                b_strict = false;
                 i_shortcuts--;
             }
         }
     }
 
     /* Sort the modules and test them */
-    p_all = vlc_list_find( p_this, VLC_OBJECT_MODULE, FIND_ANYWHERE );
-    p_list = malloc( p_all->i_count * sizeof( module_list_t ) );
-    p_first = NULL;
+    size_t count;
+    module_t **p_all = module_list_get (&count);
+    p_list = malloc( count * sizeof( module_list_t ) );
     unsigned i_cpu = vlc_CPU();
 
     /* Parse the module list for capabilities and probe each of them */
-    for( i_which_module = 0; i_which_module < p_all->i_count; i_which_module++ )
+    count = 0;
+    for (size_t i = 0; (p_module = p_all[i]) != NULL; i++)
     {
-        int i_shortcut_bonus = 0;
-
-        p_module = (module_t *)p_all->p_values[i_which_module].p_object;
+        bool b_shortcut_bonus = false;
 
         /* Test that this module can do what we need */
-        if( !module_IsCapable( p_module, psz_capability ) )
-        {
-            /* Don't recurse through the sub-modules because vlc_list_find()
-             * will list them anyway. */
+        if( !module_provides( p_module, psz_capability ) )
             continue;
-        }
-
         /* Test if we have the required CPU */
         if( (p_module->i_cpu & i_cpu) != p_module->i_cpu )
-        {
             continue;
-        }
 
         /* If we required a shortcut, check this plugin provides it. */
         if( i_shortcuts > 0 )
         {
-            vlc_bool_t b_trash;
             const char *psz_name = psz_shortcuts;
 
-            /* Let's drop modules with a <= 0 score (unless they are
-             * explicitly requested) */
-            b_trash = p_module->i_score <= 0;
-
             for( unsigned i_short = i_shortcuts; i_short > 0; i_short-- )
             {
                 for( unsigned i = 0; p_module->pp_shortcuts[i]; i++ )
@@ -526,7 +508,7 @@ module_t * __module_Need( vlc_object_t *p_this, const char *psz_capability,
                         /* Found it */
                         if( c && c[1] )
                             psz_alias = c+1;
-                        i_shortcut_bonus = i_short * 10000;
+                        b_shortcut_bonus = true;
                         goto found_shortcut;
                     }
                 }
@@ -548,110 +530,61 @@ module_t * __module_Need( vlc_object_t *p_this, const char *psz_capability,
         }
 
 found_shortcut:
-
         /* Store this new module */
-        p_list[ i_index ].p_module = p_module;
-        p_list[ i_index ].i_score = p_module->i_score + i_shortcut_bonus;
-        p_list[ i_index ].b_force = i_shortcut_bonus && b_strict;
-
-        /* Add it to the modules-to-probe list */
-        if( i_index == 0 )
-        {
-            p_list[ 0 ].p_next = NULL;
-            p_first = p_list;
-        }
-        else
-        {
-            /* Ok, so at school you learned that quicksort is quick, and
-             * bubble sort sucks raw eggs. But that's when dealing with
-             * thousands of items. Here we have barely 50. */
-            module_list_t *p_newlist = p_first;
-
-            if( p_first->i_score < p_list[ i_index ].i_score )
-            {
-                p_list[ i_index ].p_next = p_first;
-                p_first = &p_list[ i_index ];
-            }
-            else
-            {
-                while( p_newlist->p_next != NULL &&
-                    p_newlist->p_next->i_score >= p_list[ i_index ].i_score )
-                {
-                    p_newlist = p_newlist->p_next;
-                }
-
-                p_list[ i_index ].p_next = p_newlist->p_next;
-                p_newlist->p_next = &p_list[ i_index ];
-            }
-        }
-
-        i_index++;
+        p_list[count].p_module = module_hold (p_module);
+        p_list[count].i_score = p_module->i_score;
+        if( b_shortcut_bonus )
+            p_list[count].i_score += 10000;
+        p_list[count].b_force = b_shortcut_bonus && b_strict;
+        count++;
     }
 
-    msg_Dbg( p_this, "looking for %s module: %i candidate%s", psz_capability,
-                                            i_index, i_index == 1 ? "" : "s" );
-
-    /* Lock all candidate modules */
-    p_tmp = p_first;
-    while( p_tmp != NULL )
-    {
-        vlc_object_yield( p_tmp->p_module );
-        p_tmp = p_tmp->p_next;
-    }
+    /* We can release the list, interesting modules are held */
+    module_list_free (p_all);
 
-    /* We can release the list, interesting modules were yielded */
-    vlc_list_release( p_all );
+    /* Sort candidates by descending score */
+    qsort (p_list, count, sizeof (p_list[0]), modulecmp);
+#ifdef WIN32
+    /* FIXME: Remove this hack after finding a general solution for %z's */
+    msg_Dbg( p_this, "looking for %s module: %u candidate%s", psz_capability,
+             count, count == 1 ? "" : "s" );
+#else
+    msg_Dbg( p_this, "looking for %s module: %zu candidate%s", psz_capability,
+             count, count == 1 ? "" : "s" );
+#endif
 
     /* Parse the linked list and use the first successful module */
-    p_tmp = p_first;
-    while( p_tmp != NULL )
+    p_module = NULL;
+    for (size_t i = 0; (i < count) && (p_module == NULL); i++)
     {
+        module_t *p_cand = p_list[i].p_module;
 #ifdef HAVE_DYNAMIC_PLUGINS
         /* Make sure the module is loaded in mem */
-        module_t *p_module = p_tmp->p_module;
-        if( p_module->b_submodule )
-            p_module = (module_t *)p_module->p_parent;
+        module_t *p_real = p_cand->b_submodule ? p_cand->parent : p_cand;
 
-        if( !p_module->b_builtin && !p_module->b_loaded )
+        if( !p_real->b_builtin && !p_real->b_loaded )
         {
             module_t *p_new_module =
-                AllocatePlugin( p_this, p_module->psz_filename );
+                AllocatePlugin( p_this, p_real->psz_filename );
             if( p_new_module )
             {
-                CacheMerge( p_this, p_module, p_new_module );
-                vlc_object_attach( p_new_module, p_module );
-                DeleteModule( p_new_module, VLC_TRUE );
+                CacheMerge( p_this, p_real, p_new_module );
+                DeleteModule( p_module_bank, p_new_module );
             }
         }
 #endif
 
-        p_this->b_force = p_tmp->b_force;
-        if( p_tmp->p_module->pf_activate
-             && p_tmp->p_module->pf_activate( p_this ) == VLC_SUCCESS )
+        p_this->b_force = p_list[i].b_force;
+        if( p_cand->pf_activate
+         && p_cand->pf_activate( p_this ) == VLC_SUCCESS )
         {
-            break;
+            p_module = p_cand;
+            /* Release the remaining modules */
+            while (++i < count)
+                module_release (p_list[i].p_module);
         }
-
-        vlc_object_release( p_tmp->p_module );
-        p_tmp = p_tmp->p_next;
-    }
-
-    /* Store the locked module value */
-    if( p_tmp != NULL )
-    {
-        p_module = p_tmp->p_module;
-        p_tmp = p_tmp->p_next;
-    }
-    else
-    {
-        p_module = NULL;
-    }
-
-    /* Unlock the remaining modules */
-    while( p_tmp != NULL )
-    {
-        vlc_object_release( p_tmp->p_module );
-        p_tmp = p_tmp->p_next;
+        else
+            module_release( p_cand );
     }
 
     free( p_list );
@@ -661,13 +594,25 @@ found_shortcut:
     {
         msg_Dbg( p_this, "using %s module \"%s\"",
                  psz_capability, p_module->psz_object_name );
+        if( !p_this->psz_object_name )
+        {
+            /* This assumes that p_this is the object which will be using the
+             * module. That's not always the case ... but it is in most cases.
+             */
+            if( psz_alias )
+                p_this->psz_object_name = strdup( psz_alias );
+            else
+                p_this->psz_object_name = strdup( p_module->psz_object_name );
+        }
     }
-    else if( p_first == NULL )
+    else if( count == 0 )
     {
-        if( !strcmp( psz_capability, "access_demux" ) )
+        if( !strcmp( psz_capability, "access_demux" )
+         || !strcmp( psz_capability, "stream_filter" )
+         || !strcmp( psz_capability, "vout_window" ) )
         {
-            msg_Warn( p_this, "no %s module matched \"%s\"",
-                 psz_capability, (psz_name && *psz_name) ? psz_name : "any" );
+            msg_Dbg( p_this, "no %s module matched \"%s\"",
+                psz_capability, (psz_name && *psz_name) ? psz_name : "any" );
         }
         else
         {
@@ -686,17 +631,13 @@ found_shortcut:
     else
         msg_StackSet( VLC_EGENERIC, "no suitable %s module", psz_capability );
 
-    if( p_module && !p_this->psz_object_name )
-    {
-        /* This assumes that p_this is the object which will be using the
-         * module. That's not always the case ... but it is in most cases.
-         */
-        p_this->psz_object_name = p_module->psz_object_name;
-    }
-
     free( psz_shortcuts );
     free( psz_var );
 
+    stats_TimerStop( p_this, STATS_TIMER_MODULE_NEED );
+    stats_TimerDump( p_this, STATS_TIMER_MODULE_NEED );
+    stats_TimerClean( p_this, STATS_TIMER_MODULE_NEED );
+
     /* Don't forget that the module is still locked */
     return p_module;
 }
@@ -704,13 +645,13 @@ found_shortcut:
 /**
  * Module unneed
  *
- * This function must be called by the thread that called module_Need, to
+ * This function must be called by the thread that called module_need, to
  * decrease the reference count and allow for hiding of modules.
  * \param p_this vlc object structure
  * \param p_module the module structure
  * \return nothing
  */
-void __module_Unneed( vlc_object_t * p_this, module_t * p_module )
+void __module_unneed( vlc_object_t * p_this, module_t * p_module )
 {
     /* Use the close method */
     if( p_module->pf_deactivate )
@@ -720,9 +661,7 @@ void __module_Unneed( vlc_object_t * p_this, module_t * p_module )
 
     msg_Dbg( p_this, "removing module \"%s\"", p_module->psz_object_name );
 
-    vlc_object_release( p_module );
-
-    return;
+    module_release( p_module );
 }
 
 /**
@@ -732,40 +671,28 @@ void __module_Unneed( vlc_object_t * p_this, module_t * p_module )
  * \param psz_name the name of the module
  * \return a pointer to the module or NULL in case of a failure
  */
-module_t *__module_Find( vlc_object_t *p_this, const char * psz_name )
+module_t *module_find( const char * psz_name )
 {
-    vlc_list_t *p_list;
-    int i;
-    p_list = vlc_list_find( p_this, VLC_OBJECT_MODULE, FIND_ANYWHERE );
-    for( i = 0 ; i < p_list->i_count; i++)
+    module_t **list, *module;
+
+    list = module_list_get (NULL);
+    if (!list)
+        return NULL;
+
+    for (size_t i = 0; (module = list[i]) != NULL; i++)
     {
-        module_t *p_module = ((module_t *) p_list->p_values[i].p_object);
-        const char *psz_module_name = p_module->psz_object_name;
+        const char *psz_module_name = module->psz_object_name;
+
         if( psz_module_name && !strcmp( psz_module_name, psz_name ) )
         {
-            /* We can release the list, and return yes */
-            vlc_object_yield( p_module );
-            vlc_list_release( p_list );
-            return p_module;
+            module_hold (module);
+            break;
         }
     }
-    vlc_list_release( p_list );
-    return NULL;
-}
-
-
-/**
- * Release a module_t pointer from module_Find().
- *
- * \param module the module to release
- * \return nothing
- */
-void module_Put( module_t *module )
-{
-    vlc_object_release( module );
+    module_list_free (list);
+    return module;
 }
 
-
 /**
  * Tell if a module exists and release it in thic case
  *
@@ -773,18 +700,12 @@ void module_Put( module_t *module )
  * \param psz_name th name of the module
  * \return TRUE if the module exists
  */
-vlc_bool_t __module_Exists( vlc_object_t *p_this, const char * psz_name )
+bool module_exists (const char * psz_name)
 {
-    module_t *p_module = __module_Find( p_this, psz_name );
+    module_t *p_module = module_find (psz_name);
     if( p_module )
-    {
-        module_Put( p_module );
-        return VLC_TRUE;
-    }
-    else
-    {
-        return VLC_FALSE;
-    }
+        module_release (p_module);
+    return p_module != NULL;
 }
 
 /**
@@ -793,26 +714,25 @@ vlc_bool_t __module_Exists( vlc_object_t *p_this, const char * psz_name )
  * Return a NULL terminated array with the names of the modules
  * that have a certain capability.
  * Free after uses both the string and the table.
- * \param p_this vlc object structure
  * \param psz_capability the capability asked
  * \param pppsz_longname an pointer to an array of string to contain
     the long names of the modules. If set to NULL the function don't use it.
  * \return the NULL terminated array
  */
-char ** __module_GetModulesNamesForCapability( vlc_object_t *p_this,
-                                               const char *psz_capability,
-                                               char ***pppsz_longname )
+char ** module_GetModulesNamesForCapability( const char *psz_capability,
+                                             char ***pppsz_longname )
 {
-    vlc_list_t *p_list;
-    int i, j, count = 0;
+    size_t count = 0;
     char **psz_ret;
 
+    module_t **list = module_list_get (NULL);
+
     /* Do it in two passes : count the number of modules before */
-    p_list = vlc_list_find( p_this, VLC_OBJECT_MODULE, FIND_ANYWHERE );
-    for( i = 0 ; i < p_list->i_count; i++)
+    for (size_t i = 0; list[i]; i++)
     {
-        module_t *p_module = ((module_t *) p_list->p_values[i].p_object);
+        module_t *p_module = list[i];
         const char *psz_module_capability = p_module->psz_capability;
+
         if( psz_module_capability && !strcmp( psz_module_capability, psz_capability ) )
             count++;
     }
@@ -823,17 +743,20 @@ char ** __module_GetModulesNamesForCapability( vlc_object_t *p_this,
     if( !psz_ret || ( pppsz_longname && *pppsz_longname == NULL ) )
     {
         free( psz_ret );
-        free( *pppsz_longname );
-        *pppsz_longname = NULL;
-        vlc_list_release( p_list );
+        if( pppsz_longname )
+        {
+            free( *pppsz_longname );
+            *pppsz_longname = NULL;
+        }
+        module_list_free (list);
         return NULL;
     }
 
-    j = 0;
-    for( i = 0 ; i < p_list->i_count; i++)
+    for (size_t i = 0, j = 0; list[i]; i++)
     {
-        module_t *p_module = ((module_t *) p_list->p_values[i].p_object);
+        module_t *p_module = list[i];
         const char *psz_module_capability = p_module->psz_capability;
+
         if( psz_module_capability && !strcmp( psz_module_capability, psz_capability ) )
         {
             int k = -1; /* hack to handle submodules properly */
@@ -845,13 +768,13 @@ char ** __module_GetModulesNamesForCapability( vlc_object_t *p_this,
             psz_ret[j] = strdup( k>=0?p_module->pp_shortcuts[k]
                                      :p_module->psz_object_name );
             if( pppsz_longname )
-                (*pppsz_longname)[j] = strdup( module_GetName( p_module, VLC_TRUE ) );
+                (*pppsz_longname)[j] = strdup( module_get_name( p_module, true ) );
             j++;
         }
     }
     psz_ret[count] = NULL;
 
-    vlc_list_release( p_list );
+    module_list_free (list);
 
     return psz_ret;
 }
@@ -863,7 +786,7 @@ char ** __module_GetModulesNamesForCapability( vlc_object_t *p_this,
  * \param psize the size of the configuration returned
  * \return the configuration as an array
  */
-module_config_t *module_GetConfig( const module_t *module, unsigned *restrict psize )
+module_config_t *module_config_get( const module_t *module, unsigned *restrict psize )
 {
     unsigned i,j;
     unsigned size = module->confsize;
@@ -897,7 +820,7 @@ module_config_t *module_GetConfig( const module_t *module, unsigned *restrict ps
  * \param the configuration
  * \return nothing
  */
-void module_PutConfig( module_config_t *config )
+void module_config_free( module_config_t *config )
 {
     free( config );
 }
@@ -913,29 +836,37 @@ void module_PutConfig( module_config_t *config )
 static char * copy_next_paths_token( char * paths, char ** remaining_paths )
 {
     char * path;
-    int i;
+    int i, done;
     bool escaped = false;
 
     assert( paths );
 
     /* Alloc a buffer to store the path */
-    path = malloc( strlen( paths ) );
+    path = malloc( strlen( paths ) + 1 );
     if( !path ) return NULL;
 
     /* Look for PATH_SEP_CHAR (a ':' or a ';') */
-    for( i = 0; paths[i]; i++ ) {
+    for( i = 0, done = 0 ; paths[i]; i++ )
+    {
         /* Take care of \\ and \: or \; escapement */
-        if( escaped ) {
+        if( escaped )
+        {
             escaped = false;
-            path[i] = paths[i];
+            path[done++] = paths[i];
         }
+#ifdef WIN32
+        else if( paths[i] == '/' )
+            escaped = true;
+#else
         else if( paths[i] == '\\' )
             escaped = true;
+#endif
         else if( paths[i] == PATH_SEP_CHAR )
             break;
         else
-            path[i] = paths[i];
+            path[done++] = paths[i];
     }
+    path[done++] = 0;
 
     /* Return the remaining paths */
     if( remaining_paths ) {
@@ -945,74 +876,58 @@ static char * copy_next_paths_token( char * paths, char ** remaining_paths )
     return path;
 }
 
+char *psz_vlcpath = NULL;
+
 /*****************************************************************************
  * AllocateAllPlugins: load all plugin modules we can find.
  *****************************************************************************/
 #ifdef HAVE_DYNAMIC_PLUGINS
 static void AllocateAllPlugins( vlc_object_t *p_this )
 {
-    char *paths, *path, *paths_iter;
+    const char *vlcpath = psz_vlcpath;
+    int count,i;
+    char * path;
+    vlc_array_t *arraypaths = vlc_array_new();
 
-#if defined( WIN32 ) || defined( UNDER_CE )
-    const char * extra_path = "";
-#else
-    const char * extra_path = ":" PLUGIN_PATH;
+    /* Contruct the special search path for system that have a relocatable
+     * executable. Set it to <vlc path>/modules and <vlc path>/plugins. */
+
+    if( vlcpath && asprintf( &path, "%s" DIR_SEP "modules", vlcpath ) != -1 )
+        vlc_array_append( arraypaths, path );
+    if( vlcpath && asprintf( &path, "%s" DIR_SEP "plugins", vlcpath ) != -1 )
+        vlc_array_append( arraypaths, path );
+#ifndef WIN32
+    vlc_array_append( arraypaths, strdup( PLUGIN_PATH ) );
 #endif
 
     /* If the user provided a plugin path, we add it to the list */
-    char * userpaths = config_GetPsz( p_this, "plugin-path" );
+    char *userpaths = config_GetPsz( p_this, "plugin-path" );
+    char *paths_iter;
 
-    if( asprintf( &paths, "modules%s:plugins:%s", extra_path, userpaths ) < 0 )
+    for( paths_iter = userpaths; paths_iter; )
     {
-        msg_Err( p_this, "Not enough memory" );
-        free( userpaths );
-        return;
+        path = copy_next_paths_token( paths_iter, &paths_iter );
+        if( path )
+            vlc_array_append( arraypaths, path );
     }
 
-    /* Free plugin-path */
-    free( userpaths );
-
-    for( paths_iter = paths; paths_iter; )
+    count = vlc_array_count( arraypaths );
+    for( i = 0 ; i < count ; i++ )
     {
-        char *psz_fullpath;
- 
-        path = copy_next_paths_token( paths_iter, &paths_iter );
+        path = vlc_array_item_at_index( arraypaths, i );
         if( !path )
-        {
-            msg_Err( p_this, "Not enough memory" );
-            return;
-        }
-
-#if defined( SYS_BEOS ) || defined( __APPLE__ ) || defined( WIN32 )
-
-        /* Handle relative as well as absolute paths */
-#ifdef WIN32
-        if( path[0] != '\\' && path[0] != '/' && path[0] != ':' )
-#else
-        if( path[0] != '/' )
-#endif
-        {
-            if( 0>= asprintf( &psz_fullpath, "%s"DIR_SEP"%s",
-                              vlc_global()->psz_vlcpath, path) )
-                psz_fullpath = NULL;
-        }
-        else
-#endif
-            psz_fullpath = strdup( path );
-
-        if( psz_fullpath == NULL )
             continue;
 
-        msg_Dbg( p_this, "recursively browsing `%s'", psz_fullpath );
+        msg_Dbg( p_this, "recursively browsing `%s'", path );
 
         /* Don't go deeper than 5 subdirectories */
-        AllocatePluginDir( p_this, psz_fullpath, 5 );
+        AllocatePluginDir( p_this, path, 5 );
 
-        free( psz_fullpath );
         free( path );
     }
 
-    free( paths );
+    vlc_array_destroy( arraypaths );
+    free( userpaths );
 }
 
 /*****************************************************************************
@@ -1199,8 +1114,8 @@ static void AllocatePluginDir( vlc_object_t *p_this, const char *psz_dir,
  * AllocatePluginFile: load a module into memory and initialize it.
  *****************************************************************************
  * This function loads a dynamically loadable module and allocates a structure
- * for its information data. The module can then be handled by module_Need
- * and module_Unneed. It can be removed by DeleteModule.
+ * for its information data. The module can then be handled by module_need
+ * and module_unneed. It can be removed by DeleteModule.
  *****************************************************************************/
 static int AllocatePluginFile( vlc_object_t * p_this, char * psz_file,
                                int64_t i_file_time, int64_t i_file_size )
@@ -1212,7 +1127,7 @@ static int AllocatePluginFile( vlc_object_t * p_this, char * psz_file,
      * Check our plugins cache first then load plugin if needed
      */
     p_cache_entry =
-        CacheFind( psz_file, i_file_time, i_file_size );
+        CacheFind( p_module_bank, psz_file, i_file_time, i_file_size );
 
     if( !p_cache_entry )
     {
@@ -1230,7 +1145,7 @@ static int AllocatePluginFile( vlc_object_t * p_this, char * psz_file,
             module_config_t *p_item = NULL, *p_end = NULL;
 
             p_module = p_cache_entry->p_module;
-            p_module->b_loaded = VLC_FALSE;
+            p_module->b_loaded = false;
 
             /* For now we force loading if the module's config contains
              * callbacks or actions.
@@ -1245,27 +1160,25 @@ static int AllocatePluginFile( vlc_object_t * p_this, char * psz_file,
                 }
             }
             if( p_module == p_cache_entry->p_module )
-                p_cache_entry->b_used = VLC_TRUE;
+                p_cache_entry->b_used = true;
         }
     }
 
     if( p_module )
     {
-        libvlc_global_data_t *p_libvlc_global = vlc_global();
-
         /* Everything worked fine !
          * The module is ready to be added to the list. */
-        p_module->b_builtin = VLC_FALSE;
+        p_module->b_builtin = false;
 
         /* msg_Dbg( p_this, "plugin \"%s\", %s",
                     p_module->psz_object_name, p_module->psz_longname ); */
+        p_module->next = p_module_bank->head;
+        p_module_bank->head = p_module;
 
-        vlc_object_attach( p_module, p_libvlc_global->p_module_bank );
-
-        if( !p_libvlc_global->p_module_bank->b_cache )
+        if( !p_module_bank->b_cache )
             return 0;
 
-#define p_bank p_libvlc_global->p_module_bank
+#define p_bank p_module_bank
         /* Add entry to cache */
         p_bank->pp_cache =
             realloc( p_bank->pp_cache, (p_bank->i_cache + 1) * sizeof(void *) );
@@ -1276,9 +1189,10 @@ static int AllocatePluginFile( vlc_object_t * p_this, char * psz_file,
         p_bank->pp_cache[p_bank->i_cache]->i_time = i_file_time;
         p_bank->pp_cache[p_bank->i_cache]->i_size = i_file_size;
         p_bank->pp_cache[p_bank->i_cache]->b_junk = p_module ? 0 : 1;
-        p_bank->pp_cache[p_bank->i_cache]->b_used = VLC_TRUE;
+        p_bank->pp_cache[p_bank->i_cache]->b_used = true;
         p_bank->pp_cache[p_bank->i_cache]->p_module = p_module;
         p_bank->i_cache++;
+#undef p_bank
     }
 
     return p_module ? 0 : -1;
@@ -1288,8 +1202,8 @@ static int AllocatePluginFile( vlc_object_t * p_this, char * psz_file,
  * AllocatePlugin: load a module into memory and initialize it.
  *****************************************************************************
  * This function loads a dynamically loadable module and allocates a structure
- * for its information data. The module can then be handled by module_Need
- * and module_Unneed. It can be removed by DeleteModule.
+ * for its information data. The module can then be handled by module_need
+ * and module_unneed. It can be removed by DeleteModule.
  *****************************************************************************/
 static module_t * AllocatePlugin( vlc_object_t * p_this, char * psz_file )
 {
@@ -1304,7 +1218,6 @@ static module_t * AllocatePlugin( vlc_object_t * p_this, char * psz_file )
     p_module = vlc_module_create( p_this );
     if( p_module == NULL )
     {
-        msg_Err( p_this, "out of memory" );
         module_Unload( handle );
         return NULL;
     }
@@ -1312,13 +1225,13 @@ static module_t * AllocatePlugin( vlc_object_t * p_this, char * psz_file )
     /* We need to fill these since they may be needed by module_Call() */
     p_module->psz_filename = psz_file;
     p_module->handle = handle;
-    p_module->b_loaded = VLC_TRUE;
+    p_module->b_loaded = true;
 
     /* Initialize the module: fill p_module, default config */
-    if( module_Call( p_module ) != 0 )
+    if( module_Call( p_this, p_module ) != 0 )
     {
         /* We couldn't call module_init() */
-        vlc_object_release( p_module );
+        module_release( p_module );
         module_Unload( handle );
         return NULL;
     }
@@ -1327,7 +1240,7 @@ static module_t * AllocatePlugin( vlc_object_t * p_this, char * psz_file )
     p_module->psz_filename = strdup( p_module->psz_filename );
 
     /* Everything worked fine ! The module is ready to be added to the list. */
-    p_module->b_builtin = VLC_FALSE;
+    p_module->b_builtin = false;
 
     return p_module;
 }
@@ -1340,8 +1253,7 @@ static module_t * AllocatePlugin( vlc_object_t * p_this, char * psz_file )
  *****************************************************************************/
 static void DupModule( module_t *p_module )
 {
-    const char **pp_shortcut;
-    int i_submodule;
+    char **pp_shortcut;
 
     for( pp_shortcut = p_module->pp_shortcuts ; *pp_shortcut ; pp_shortcut++ )
     {
@@ -1350,7 +1262,6 @@ static void DupModule( module_t *p_module )
 
     /* We strdup() these entries so that they are still valid when the
      * module is unloaded. */
-    p_module->psz_object_name = strdup( p_module->psz_object_name );
     p_module->psz_capability = strdup( p_module->psz_capability );
     p_module->psz_shortname = p_module->psz_shortname ?
                                  strdup( p_module->psz_shortname ) : NULL;
@@ -1358,10 +1269,8 @@ static void DupModule( module_t *p_module )
     p_module->psz_help = p_module->psz_help ? strdup( p_module->psz_help )
                                             : NULL;
 
-    for( i_submodule = 0; i_submodule < p_module->i_children; i_submodule++ )
-    {
-        DupModule( (module_t*)p_module->pp_children[ i_submodule ] );
-    }
+    for (module_t *subm = p_module->submodule; subm; subm = subm->next)
+        DupModule (subm);
 }
 
 /*****************************************************************************
@@ -1371,24 +1280,20 @@ static void DupModule( module_t *p_module )
  *****************************************************************************/
 static void UndupModule( module_t *p_module )
 {
-    const char **pp_shortcut;
-    int i_submodule;
+    char **pp_shortcut;
 
-    for( i_submodule = 0; i_submodule < p_module->i_children; i_submodule++ )
-    {
-        UndupModule( (module_t*)p_module->pp_children[ i_submodule ] );
-    }
+    for (module_t *subm = p_module->submodule; subm; subm = subm->next)
+        UndupModule (subm);
 
     for( pp_shortcut = p_module->pp_shortcuts ; *pp_shortcut ; pp_shortcut++ )
     {
-        free( (void*)*pp_shortcut );
+        free( *pp_shortcut );
     }
 
-    free( (void*)p_module->psz_object_name );
     free( p_module->psz_capability );
-    free( (void*)p_module->psz_shortname );
-    free( (void*)p_module->psz_longname );
-    free( (void*)p_module->psz_help );
+    FREENULL( p_module->psz_shortname );
+    free( p_module->psz_longname );
+    FREENULL( p_module->psz_help );
 }
 
 #endif /* HAVE_DYNAMIC_PLUGINS */
@@ -1397,8 +1302,8 @@ static void UndupModule( module_t *p_module )
  * AllocateBuiltinModule: initialize a builtin module.
  *****************************************************************************
  * This function registers a builtin module and allocates a structure
- * for its information data. The module can then be handled by module_Need
- * and module_Unneed. It can be removed by DeleteModule.
+ * for its information data. The module can then be handled by module_need
+ * and module_unneed. It can be removed by DeleteModule.
  *****************************************************************************/
 static int AllocateBuiltinModule( vlc_object_t * p_this,
                                   int ( *pf_entry ) ( module_t * ) )
@@ -1409,10 +1314,7 @@ static int AllocateBuiltinModule( vlc_object_t * p_this,
      * allocate a structure for it */
     p_module = vlc_module_create( p_this );
     if( p_module == NULL )
-    {
-        msg_Err( p_this, "out of memory" );
         return -1;
-    }
 
     /* Initialize the module : fill p_module->psz_object_name, etc. */
     if( pf_entry( p_module ) != 0 )
@@ -1420,18 +1322,20 @@ static int AllocateBuiltinModule( vlc_object_t * p_this,
         /* With a well-written module we shouldn't have to print an
          * additional error message here, but just make sure. */
         msg_Err( p_this, "failed calling entry point in builtin module" );
-        vlc_object_release( p_module );
+        module_release( p_module );
         return -1;
     }
 
     /* Everything worked fine ! The module is ready to be added to the list. */
-    p_module->b_builtin = VLC_TRUE;
+    p_module->b_builtin = true;
+    /* LOCK */
+    p_module->next = p_module_bank->head;
+    p_module_bank->head = p_module;
+    /* UNLOCK */
 
     /* msg_Dbg( p_this, "builtin \"%s\", %s",
                 p_module->psz_object_name, p_module->psz_longname ); */
 
-    vlc_object_attach( p_module, vlc_global()->p_module_bank );
-
     return 0;
 }
 
@@ -1440,11 +1344,16 @@ static int AllocateBuiltinModule( vlc_object_t * p_this,
  *****************************************************************************
  * This function can only be called if the module isn't being used.
  *****************************************************************************/
-static int DeleteModule( module_t * p_module, vlc_bool_t b_detach )
+static void DeleteModule( module_bank_t *p_bank, module_t * p_module )
 {
-    if( !p_module ) return VLC_EGENERIC;
-    if( b_detach )
-        vlc_object_detach( p_module );
+    assert( p_module );
+
+    /* Unlist the module (if it is in the list) */
+    module_t **pp_self = &p_bank->head;
+    while (*pp_self != NULL && *pp_self != p_module)
+        pp_self = &((*pp_self)->next);
+    if (*pp_self)
+        *pp_self = p_module->next;
 
     /* We free the structures that we strdup()ed in Allocate*Module(). */
 #ifdef HAVE_DYNAMIC_PLUGINS
@@ -1460,15 +1369,13 @@ static int DeleteModule( module_t * p_module, vlc_bool_t b_detach )
 #endif
 
     /* Free and detach the object's children */
-    while( p_module->i_children )
+    while (p_module->submodule)
     {
-        vlc_object_t *p_this = p_module->pp_children[0];
-        vlc_object_detach( p_this );
-        vlc_object_release( p_this );
+        module_t *submodule = p_module->submodule;
+        p_module->submodule = submodule->next;
+        module_release (submodule);
     }
 
     config_Free( p_module );
-    vlc_object_release( p_module );
-    p_module = NULL;
-    return 0;
+    module_release( p_module );
 }