Changeset 2842

Timestamp:

Oct 30, 2006, 1:49:15 AM (19 years ago)

Author:

bird

Message:

toplevel load api code is done.

Location:

trunk/kLdr

Files:

• kLdr.h (modified) (2 diffs)
• kLdrDyld.c (modified) (14 diffs)
• kLdrDyldMod.c (modified) (1 diff)
• kLdrHlp.c (modified) (1 diff)
• kLdrInternal.h (modified) (8 diffs)
• tg/KLDRSTATE.txvstc (modified) (1 diff)
• tg/kLdr.tpr (modified) (1 diff)

trunk/kLdr/kLdr.h

@@ -545 +545 @@
 /** Returns ALL kinds of symbols. The default is to only return public/exported symbols. */
 #define KLDRMOD_ENUM_SYMBOL_FLAGS_ALL       0x00000001
+/** Do a recursive initialization calls instead of defering them to the outermost call. */
+#define KLDRDYLD_LOAD_FLAGS_RECURSIVE_INIT  0x00000002
 /** @} */
 
@@ -734 +736 @@
 
 /** Invalid parameter to a kLdr API. */
-#define KLDR_ERR_INVALID_PARAMETER      (KLDR_ERR_BASE + 32)
+#define KLDR_ERR_INVALID_PARAMETER                          (KLDR_ERR_BASE + 32)
 /** Invalid handle parameter to a kLdr API. */
-#define KLDR_ERR_INVALID_HANDLE         (KLDR_ERR_BASE + 33)
+#define KLDR_ERR_INVALID_HANDLE                             (KLDR_ERR_BASE + 33)
+/** The module wasn't loaded dynamically. */
+#define KLDR_ERR_NOT_LOADED_DYNAMICALLY                     (KLDR_ERR_BASE + 34)
 /** The module wasn't found. */
-#define KLDR_ERR_MODULE_NOT_FOUND                   (KLDR_ERR_BASE + 34)
+#define KLDR_ERR_MODULE_NOT_FOUND                           (KLDR_ERR_BASE + 35)
 /** A prerequisit module wasn't found. */
-#define KLDR_ERR_PREREQUISITE_MODULE_NOT_FOUND      (KLDR_ERR_BASE + 35)
+#define KLDR_ERR_PREREQUISITE_MODULE_NOT_FOUND              (KLDR_ERR_BASE + 36)
 /** The module is being terminated and can therefore not be loaded. */
-#define KLDR_ERR_MODULE_TERMINATING                 (KLDR_ERR_BASE + 36)
+#define KLDR_ERR_MODULE_TERMINATING                         (KLDR_ERR_BASE + 37)
 /** A prerequisit module is being terminated and can therefore not be loaded. */
-#define KLDR_ERR_PREREQUISITE_MODULE_TERMINATING    (KLDR_ERR_BASE + 37)
-/** An allocation failed. */
-#define KLDR_ERR_NO_MEMORY                          (KLDR_ERR_BASE + 38)
+#define KLDR_ERR_PREREQUISITE_MODULE_TERMINATING            (KLDR_ERR_BASE + 38)
+/** The module initialization failed. */
+#define KLDR_ERR_MODULE_INIT_FAILED                         (KLDR_ERR_BASE + 39)
+/** The initialization of a prerequisite module failed. */
+#define KLDR_ERR_PREREQUISITE_MODULE_INIT_FAILED            (KLDR_ERR_BASE + 40)
+/** The module has already failed initialization and can't be attempted reloaded until
+ * after we've finished garbage collection. */
+#define KLDR_ERR_MODULE_INIT_FAILED_ALREADY                 (KLDR_ERR_BASE + 41)
+/** A prerequisite module has already failed initialization and can't be attempted
+ * reloaded until after we've finished garbage collection. */
+#define KLDR_ERR_PREREQUISITE_MODULE_INIT_FAILED_ALREADY    (KLDR_ERR_BASE + 42)
+/** Prerequisite recursed too deeply. */
+#define KLDR_ERR_PREREQUISITE_RECURSED_TOO_DEEPLY           (KLDR_ERR_BASE + 43)
 
 
 /** Encountered a bad fixup. */
-#define KLDR_ERR_BAD_FIXUP              (KLDR_ERR_BASE + 48)
+#define KLDR_ERR_BAD_FIXUP                                  (KLDR_ERR_BASE + 48)
+
+/** A memory allocation failed. */
+#define KLDR_ERR_NO_MEMORY                                  (KLDR_ERR_BASE + 64)
 
 /** @} */

trunk/kLdr/kLdrDyld.c

@@ -49 +49 @@
 # define KLDRDYLD_ASSERT(expr)  do {} while (0)
 #endif
+
+
+/*******************************************************************************
+*   Structures and Typedefs                                                    *
+*******************************************************************************/
 
 
@@ -60 +65 @@
  * (This is exported, so no prefix.) */
 PKLDRDYLDMOD    kLdrDyldTail = NULL;
+/** Pointer to the head module of the initialization list.
+ * The outermost load call will pop elements from this list in LIFO order (i.e.
+ * from the tail). The list is only used during non-recursive initialization
+ * and may therefore share the pNext/pPrev members with the termination list
+ * since we don't push a module onto the termination list untill it has been
+ * successfully initialized. */
+PKLDRDYLDMOD    g_pkLdrDyldInitHead;
+/** Pointer to the tail module of the initalization list. */
+PKLDRDYLDMOD    g_pkLdrDyldInitTail;
 /** Pointer to the head module of the termination order list. */
 PKLDRDYLDMOD    g_pkLdrDyldTermHead;
@@ -98 +112 @@
 /** Number of active unload calls. */
 static uint32_t         g_cActiveUnloadCalls;
+/** Total number of load calls. */
+static uint32_t         g_cTotalLoadCalls;
+/** Total mumber of unload calls. */
+static uint32_t         g_cTotalUnloadCalls;
 /** Boolean flag indicating that GC is active. */
 static uint32_t         g_fActiveGC;
-
 
 /** The global error buffer. */
@@ -115 +132 @@
 *   Internal Functions                                                         *
 *******************************************************************************/
+/** @name API worker routines.
+ * @internal
+ * @{ */
 static int kldrDyldDoLoad(const char *pszDll, const char *pszDefPrefix, const char *pszDefSuffix, KLDRDYLDSEARCH enmSearch,
                           unsigned fFlags, PPKLDRDYLDMOD ppMod, char *pszErr, size_t cchErr);
+static int kldrDyldDoLoadPrerequisites(PKLDRDYLDMOD pMod, const char *pszDefPrefix, const char *pszDefSuffix,
+                                       KLDRDYLDSEARCH enmSearch, unsigned fFlags);
 static int kldrDyldDoUnload(PKLDRDYLDMOD pMod);
 static int kldrDyldDoFindByName(const char *pszDll, const char *pszDefPrefix, const char *pszDefSuffix, KLDRDYLDSEARCH enmSearch,
@@ -124 +146 @@
 static int kldrDyldDoGetFilename(PKLDRDYLDMOD pMod, char *pszFilename, size_t cchFilename);
 static int kldrDyldDoQuerySymbol(PKLDRDYLDMOD pMod, uint32_t uSymbolOrdinal, const char *pszSymbolName, uintptr_t *pValue, uint32_t *pfKind);
-
-static void     kldrDyldDoModuleTerminationAndGarabageCollection(void);
-
-static uint32_t kldrDyldStackNewFrame(void);
-int     kldrDyldStackPushModule(PKLDRDYLDMOD pMod);
-static int      kldrDyldStackFrameCompleted(void);
-static void     kldrDyldStackDropFrame(uint32_t iStackTop, uint32_t iStackBottom, int rc);
-
-static int      kldrDyldCopyError(int rc, char *pszErr, size_t cchErr);
+/** @} */
+
+/** @name Misc load/unload workers
+ * @internal
+ * @{
+ */
+static void         kldrDyldDoModuleTerminationAndGarabageCollection(void);
+/** @} */
+
+/** @name The load stack.
+ * @internal
+ * @{ */
+static uint32_t     kldrDyldStackNewFrame(PKLDRDYLDMOD pMod);
+static int          kldrDyldStackAddModule(PKLDRDYLDMOD pMod);
+static int          kldrDyldStackFrameCompleted(void);
+static void         kldrDyldStackDropFrame(uint32_t iLoad1st, uint32_t iLoadEnd, int rc);
+/** @} */
+
+static int          kldrDyldCopyError(int rc, char *pszErr, size_t cchErr);
 
 
@@ -192 +224 @@
     {
         PKLDRDYLDMOD pMod = NULL;
+        g_cTotalLoadCalls++;
         g_cActiveLoadCalls++;
         rc = kldrDyldDoLoad(pszDll, pszDefPrefix, pszDefSuffix, enmSearch, fFlags, phMod, pszErr, cchErr);
@@ -220 +253 @@
     if (!rc)
     {
+        g_cTotalUnloadCalls++;
         g_cActiveUnloadCalls++;
         rc = kldrDyldDoUnload(hMod);
@@ -404 +438 @@
 
 /**
+ * Worker for kLdrDyldLoad() and helper for kLdrDyldLoadExe().
+ * @internal
+ */
+static int kldrDyldDoLoad(const char *pszDll, const char *pszDefPrefix, const char *pszDefSuffix, KLDRDYLDSEARCH enmSearch,
+                          unsigned fFlags, PPKLDRDYLDMOD ppMod, char *pszErr, size_t cchErr)
+{
+    int rc;
+
+    /*
+     * Try find the module among the ones that's already loaded.
+     */
+    rc = kldrDyldFindExistingModule(pszDll, pszDefPrefix, pszDefSuffix, enmSearch, fFlags, ppMod);
+    if (!rc)
+    {
+        switch ((*ppMod)->enmState)
+        {
+            /*
+             * Prerequisites are ok, so nothing to do really.
+             */
+            case KLDRSTATE_GOOD:
+            case KLDRSTATE_INITIALIZING:
+                return kldrDyldModDynamicLoad(*ppMod);
+
+            /*
+             * The module can't be loaded because it failed to initialize.
+             */
+            case KLDRSTATE_INITIALIZATION_FAILED:
+                return KLDR_ERR_MODULE_INIT_FAILED_ALREADY;
+
+            /*
+             * Prerequisites needs loading / reattaching and the module
+             * (may depending on fFlags) needs to be initialized.
+             */
+            case KLDRSTATE_PENDING_INITIALIZATION:
+                break;
+
+            /*
+             * Prerequisites needs to be loaded again
+             */
+            case KLDRSTATE_PENDING_TERMINATION:
+                break;
+
+            /*
+             * The module has been terminated so it need to be reloaded, have it's
+             * prereqs loaded, fixed up and initialized before we can use it again.
+             */
+            case KLDRSTATE_PENDING_GC:
+                rc = kldrDyldModReload(*ppMod);
+                if (rc)
+                    return kldrDyldCopyError(rc, pszErr, cchErr);
+                break;
+
+            /*
+             * Forget it, we don't know how to deal with re-initialization here.
+             */
+            case KLDRSTATE_TERMINATING:
+                KLDRDYLD_ASSERT(!"KLDR_ERR_MODULE_TERMINATING");
+                return KLDR_ERR_MODULE_TERMINATING;
+
+            /*
+             * Invalid state.
+             */
+            default:
+                KLDRDYLD_ASSERT(!"invalid state");
+                break;
+        }
+    }
+    else
+    {
+        /*
+         * We'll have to load it from file.
+         */
+        rc = kldrDyldFindNewModule(pszDll, pszDefPrefix, pszDefSuffix, enmSearch, fFlags, ppMod);
+        if (rc)
+            return kldrDyldCopyError(rc, pszErr, cchErr);
+        rc = kldrDyldModMap(*ppMod);
+    }
+
+    if (!rc)
+    {
+        /*
+         * Load prerequisites.
+         */
+        uint32_t i;
+        uint32_t iLoadEnd;
+        uint32_t iLoad1st = kldrDyldStackNewFrame(*ppMod);
+        rc = kldrDyldDoLoadPrerequisites(*ppMod, pszDefPrefix, pszDefSuffix, enmSearch, fFlags);
+        iLoadEnd = kldrDyldStackFrameCompleted();
+
+        /*
+         * Apply fixups.
+         */
+        for (i = iLoad1st; !rc && i < iLoadEnd; i++)
+        {
+            PKLDRDYLDMOD pMod = g_papStackMods[i];
+            if (    pMod->enmState == KLDRSTATE_LOADED_PREREQUISITES
+                ||  pMod->enmState == KLDRSTATE_RELOADED_LOADED_PREREQUISITES)
+                rc = kldrDyldModFixup(pMod);
+        }
+
+        /*
+         * Advance fixed up module onto initialization.
+         */
+        for (i = iLoad1st; !rc && i < iLoadEnd; i++)
+        {
+            PKLDRDYLDMOD pMod = g_papStackMods[i];
+            if (    pMod->enmState == KLDRSTATE_FIXED_UP
+                ||  pMod->enmState == KLDRSTATE_RELOADED_FIXED_UP)
+                pMod->enmState = KLDRSTATE_PENDING_INITIALIZATION;
+            KLDRDYLD_ASSERT(    pMod->enmState == KLDRSTATE_PENDING_INITIALIZATION
+                            ||  pMod->enmState == KLDRSTATE_GOOD);
+        }
+
+        /*
+         * Call the initializers if we're loading in recursive mode or
+         * if we're the outermost load call.
+         */
+        if (fFlags & KLDRDYLD_LOAD_FLAGS_RECURSIVE_INIT)
+        {
+            for (i = iLoad1st; !rc && i < iLoadEnd; i++)
+            {
+                PKLDRDYLDMOD pMod = g_papStackMods[i];
+                if (pMod->enmState == KLDRSTATE_PENDING_INITIALIZATION)
+                    rc = kldrDyldModCallInit(pMod);
+                else if (pMod->enmState == KLDRSTATE_INITIALIZATION_FAILED)
+                    rc = KLDR_ERR_PREREQUISITE_MODULE_INIT_FAILED_ALREADY;
+                else
+                    KLDRDYLD_ASSERT(g_papStackMods[i]->enmState == KLDRSTATE_GOOD);
+            }
+#ifdef KLDRDYLD_STRICT
+            for (i = iLoad1st; !rc && i < iLoadEnd; i++)
+                KLDRDYLD_ASSERT(g_papStackMods[i]->enmState == KLDRSTATE_GOOD);
+#endif
+        }
+        else if (g_cActiveLoadCalls <= 1)
+        {
+            while (!rc && g_pkLdrDyldInitHead)
+            {
+                PKLDRDYLDMOD pMod = g_pkLdrDyldInitHead;
+                g_pkLdrDyldInitHead = pMod->InitTerm.pNext;
+                if (pMod->InitTerm.pNext)
+                    pMod->InitTerm.pNext->InitTerm.pPrev = NULL;
+                rc = kldrDyldModCallInit(pMod);
+            }
+        }
+
+        /*
+         * Complete the load by incrementing the dynamic load count of the
+         * requested module (return handle is already set).
+         */
+        if (!rc)
+        {
+            rc = kldrDyldModDynamicLoad(*ppMod);
+            if (!rc)
+            {
+                kldrDyldStackDropFrame(iLoad1st, iLoadEnd, rc);
+                kldrDyldModDeref(*ppMod);
+                return rc;
+            }
+        }
+        kldrDyldStackDropFrame(iLoad1st, iLoadEnd, rc);
+    }
+    else
+    {
+        /* If the reference count is 0 do a quick ref/deref to trigger destruction. */
+        kldrDyldModAddRef(*ppMod);
+        kldrDyldModDeref(*ppMod);
+    }
+
+    /*
+     * We've failed, copy/create error string.
+     */
+    return kldrDyldCopyError(rc, pszErr, cchErr);
+}
+
+
+/**
+ * kldrDyldDoLoad() helper which will load prerequisites and
+ * build the initialization array / list.
+ *
+ * @returns 0 on success, non-zero error code on failure.
+ * @param   pMod            The module to start at.
+ * @param   pszDefPrefix    Prefix to use when searching.
+ * @param   pszDefSuffix    Suffix to use when searching.
+ * @param   enmSearch       Method to use when locating the module and any modules it may depend on.
+ * @param   fFlags          Flags, a combintation of the KLDRYDLD_LOAD_FLAGS_* \#defines.
+ */
+static int kldrDyldDoLoadPrerequisites(PKLDRDYLDMOD pMod, const char *pszDefPrefix, const char *pszDefSuffix,
+                                       KLDRDYLDSEARCH enmSearch, unsigned fFlags)
+{
+    static struct
+    {
+        /** The module. */
+        PKLDRDYLDMOD    pMod;
+        /** The number of prerequisite modules left to process.
+         * This starts at ~0U to inidicate that we need to load/check prerequisistes. */
+        unsigned        cLeft;
+    }               s_aEntries[64];
+    unsigned        cEntries;
+    int             rc = 0;
+
+    /* push the first entry. */
+    s_aEntries[0].pMod = pMod;
+    s_aEntries[0].cLeft = ~0U;
+    cEntries = 1;
+
+    /*
+     * The recursion loop.
+     */
+    while (!rc && cEntries > 0)
+    {
+        const unsigned i = cEntries - 1;
+        pMod = s_aEntries[i].pMod;
+        if (s_aEntries[i].cLeft == ~0U)
+        {
+            /*
+             * Load prerequisite modules.
+             */
+            switch (pMod->enmState)
+            {
+                /*
+                 * Load immediate prerequisite modules and push the ones needing
+                 * attention onto the stack.
+                 */
+                case KLDRSTATE_MAPPED:
+                case KLDRSTATE_RELOADED:
+                case KLDRSTATE_PENDING_TERMINATION:
+                    rc = kldrDyldModLoadPrerequisites(pMod, pszDefPrefix, pszDefSuffix, enmSearch, fFlags);
+                    KLDRDYLD_ASSERT(    pMod->enmState == KLDRSTATE_GOOD
+                                    ||  pMod->enmState == KLDRSTATE_RELOADED_LOADED_PREREQUISITES
+                                    ||  pMod->enmState == KLDRSTATE_LOADED_PREREQUISITES
+                                    ||  rc);
+                    if (!rc)
+                        s_aEntries[i].cLeft = pMod->cPrereqs;
+                    break;
+
+                /*
+                 * Check its prerequisite modules the first time around.
+                 */
+                case KLDRSTATE_PENDING_INITIALIZATION:
+                    if (pMod->fAlreadySeen)
+                        break;
+                    pMod->fAlreadySeen = 1;
+                    s_aEntries[i].cLeft = pMod->cPrereqs;
+                    break;
+
+                /*
+                 * These are ok.
+                 */
+                case KLDRSTATE_LOADED_PREREQUISITES:
+                case KLDRSTATE_RELOADED_LOADED_PREREQUISITES:
+                case KLDRSTATE_INITIALIZING:
+                case KLDRSTATE_GOOD:
+                    s_aEntries[i].cLeft = 0;
+                    break;
+
+                /*
+                 * All other stats are invalid.
+                 */
+                default:
+                    KLDRDYLD_ASSERT(!"invalid state");
+                    break;
+            }
+        }
+        else if (s_aEntries[i].cLeft > 0)
+        {
+            /*
+             * Recurse down into the next prereq.
+             */
+            KLDRDYLD_ASSERT(s_aEntries[i].cLeft <= pMod->cPrereqs);
+            if (cEntries < sizeof(s_aEntries) / sizeof(s_aEntries[0]))
+            {
+                s_aEntries[cEntries++].pMod = pMod->papPrereqs[pMod->cPrereqs - s_aEntries[i].cLeft];
+                s_aEntries[i].cLeft--;
+            }
+            else
+                rc = KLDR_ERR_PREREQUISITE_RECURSED_TOO_DEEPLY;
+        }
+        else
+        {
+            /*
+             * We're done with this module, record it for init/cleanup.
+             */
+            cEntries--;
+            if (pMod->enmState != KLDRSTATE_GOOD)
+            {
+                kldrDyldStackAddModule(pMod);
+                if  (   !(fFlags & KLDRDYLD_LOAD_FLAGS_RECURSIVE_INIT)
+                     && !pMod->fInitList)
+                {
+                    pMod->fInitList = 1;
+                    pMod->InitTerm.pNext = NULL;
+                    pMod->InitTerm.pPrev = g_pkLdrDyldInitTail;
+                    if (g_pkLdrDyldInitTail)
+                        g_pkLdrDyldInitTail->InitTerm.pNext = pMod;
+                    else
+                        g_pkLdrDyldInitHead = pMod;
+                    g_pkLdrDyldInitTail = pMod;
+                }
+            }
+        }
+    }
+
+    return rc;
+}
+
+
+/**
  * Gets prerequisite module.
  *
@@ -421 +763 @@
                             unsigned fFlags, PKLDRDYLDMOD pDep, PPKLDRDYLDMOD ppMod)
 {
-    int rc;
+    int             rc;
+    PKLDRDYLDMOD    pMod;
 
     *ppMod = NULL;
@@ -427 +770 @@
     /*
      * Try find the module among the ones that's already loaded.
-     */
-    rc = kldrDyldFindExistingModule(pszDll, pszDefPrefix, pszDefSuffix, enmSearch, fFlags, ppMod);
+     *
+     * This is very similar to the kldrDyldDoLoad code, except it has to deal with
+     * a couple of additional states and occurs only during prerequisite loading
+     * and the action taken is a little bit different.
+     */
+    rc = kldrDyldFindExistingModule(pszDll, pszDefPrefix, pszDefSuffix, enmSearch, fFlags, &pMod);
     if (!rc)
     {
-        /*
-         * See if the module should go on the stack and if it needs
-         * some work before that.
-         */
-        switch ((*ppMod)->enmState)
-        {
-            /*
-             * The module is good, just add the dependency.
-             */
+        switch (pMod->enmState)
+        {
+            /*
+             * These are good.
+             */
+            case KLDRSTATE_MAPPED:
+            case KLDRSTATE_RELOADED:
+            case KLDRSTATE_LOADED_PREREQUISITES:
+            case KLDRSTATE_RELOADED_LOADED_PREREQUISITES:
+            case KLDRSTATE_PENDING_INITIALIZATION:
+            case KLDRSTATE_INITIALIZING:
             case KLDRSTATE_GOOD:
-            case KLDRSTATE_INITIALIZING:
-                return kldrDyldModAddDep(*ppMod, pDep);
-
-            /*
-             * Prerequisites needs checking.
-             */
-            case KLDRSTATE_PENDING_INITIALIZATION:
-                (*ppMod)->fAlreadySeen = 0;
             case KLDRSTATE_PENDING_TERMINATION:
                 break;
@@ -457 +798 @@
              */
             case KLDRSTATE_PENDING_GC:
-                rc = kldrDyldModReload(*ppMod);
-                if (rc)
-                    return rc;
-                break;
-
-            /*
-             * It's just been loaded or reloaded in this session, we will push it
-             * onto the stack even so to get a consisten init order with the other
-             * states.
-             */
-            case KLDRSTATE_MAPPED:
-            case KLDRSTATE_RELOADED:
-                break;
-
-            /*
-             * Forget it, we don't know how to deal with re-initialization here.
+                rc = kldrDyldModReload(pMod);
+                break;
+
+            /*
+             * The module can't be loaded because it failed to initialize already.
+             */
+            case KLDRSTATE_INITIALIZATION_FAILED:
+                rc = KLDR_ERR_PREREQUISITE_MODULE_INIT_FAILED;
+                break;
+
+            /*
+             * Forget it, no idea how to deal with re-initialization.
              */
             case KLDRSTATE_TERMINATING:
-                KLDRDYLD_ASSERT(!"KLDR_ERR_PREREQUISITE_MODULE_TERMINATING");
                 return KLDR_ERR_PREREQUISITE_MODULE_TERMINATING;
 
@@ -493 +829 @@
         rc = kldrDyldFindNewModule(pszDll, pszDefPrefix, pszDefSuffix, enmSearch, fFlags, ppMod);
         if (!rc)
-            rc = kldrDyldModMap(*ppMod);
-    }
-
-    /*
-     * Push it onto the stack and add the dependency.
+            rc = kldrDyldModMap(pMod);
+    }
+
+    /*
+     * On success add dependency.
      */
     if (!rc)
-        rc = kldrDyldStackPushModule(*ppMod);
+    {
+        rc = kldrDyldModAddDep(pMod, pDep);
+        if (!rc)
+            *ppMod = pMod;
+    }
+    return rc;
+}
+
+
+/**
+ * Starts a new load stack frame.
+ *
+ * @returns Where the new stack frame starts.
+ * @param   pLoadMod        The module being loaded (only used for asserting).
+ */
+static uint32_t kldrDyldStackNewFrame(PKLDRDYLDMOD pLoadMod)
+{
+    /*
+     * Clear the fAlreadySeen flags.
+     */
+    PKLDRDYLDMOD pMod = kLdrDyldHead;
+    while (pMod)
+    {
+        pMod->fAlreadySeen = 0;
+
+#ifdef KLDRDYLD_ASSERT
+        switch (pMod->enmState)
+        {
+            case KLDRSTATE_MAPPED:
+            case KLDRSTATE_RELOADED:
+                /* only the just loaded module can be in this state. */
+                KLDRDYLD_ASSERT(pMod == pLoadMod);
+                break;
+
+            case KLDRSTATE_PENDING_INITIALIZATION:
+            case KLDRSTATE_INITIALIZING:
+            case KLDRSTATE_PENDING_TERMINATION:
+            case KLDRSTATE_PENDING_GC:
+            case KLDRSTATE_TERMINATING:
+            case KLDRSTATE_INITIALIZATION_FAILED:
+            case KLDRSTATE_PENDING_DESTROY:
+                /* requires recursion. */
+                KLDRDYLD_ASSERT(g_cActiveLoadCalls + g_cActiveLoadCalls + g_fActiveGC > 1);
+                break;
+
+            case KLDRSTATE_GOOD:
+                /* requires nothing. */
+                break;
+
+            default:
+                KLDRDYLD_ASSERT(!"Invalid state");
+                break;
+        }
+#endif
+
+        /* next */
+        pMod = pMod->Load.pNext;
+    }
+    return g_cStackMods;
+}
+
+
+/**
+ * Records the module.
+ *
+ * @return 0 on success, KLDR_ERR_NO_MEMORY if we can't expand the table.
+ * @param   pMod        The module to record.
+ */
+static int kldrDyldStackAddModule(PKLDRDYLDMOD pMod)
+{
+    int rc;
+
+    /*
+     * Grow the stack if necessary.
+     */
+    if (g_cStackMods + 1 > g_cStackModsAllocated)
+    {
+        uint32_t cNew = g_cStackModsAllocated ? g_cStackModsAllocated * 2 : 128;
+        void *pvOld = g_papStackMods;
+        void *pvNew = kldrHlpAlloc(cNew * sizeof(g_papStackMods[0]));
+        if (!pvNew)
+            return KLDR_ERR_NO_MEMORY;
+        kLdrHlpMemCopy(pvNew, pvOld, g_cStackMods * sizeof(g_papStackMods[0]));
+        g_papStackMods = (PPKLDRDYLDMOD)pvNew;
+        kldrHlpFree(pvOld);
+    }
+
+    /*
+     * Add a reference and push the module onto the stack.
+     */
+    rc = kldrDyldModAddRef(pMod);
     if (!rc)
-        rc = kldrDyldModAddDep(*ppMod, pDep);
+        g_papStackMods[g_cStackMods++] = pMod;
     return rc;
 }
@@ -508 +934 @@
 
 /**
- * Worker for kLdrDyldLoad() and helper for kLdrDyldLoadExe().
- * @internal
- */
-static int kldrDyldDoLoad(const char *pszDll, const char *pszDefPrefix, const char *pszDefSuffix, KLDRDYLDSEARCH enmSearch,
-                          unsigned fFlags, PPKLDRDYLDMOD ppMod, char *pszErr, size_t cchErr)
-{
-    int         rc;
-
-    /*
-     * Try find the module among the ones that's already loaded.
-     */
-    rc = kldrDyldFindExistingModule(pszDll, pszDefPrefix, pszDefSuffix, enmSearch, fFlags, ppMod);
-    if (!rc)
+ * The frame has been completed.
+ *
+ * @returns Where the frame ends.
+ */
+static int kldrDyldStackFrameCompleted(void)
+{
+    return g_cStackMods;
+}
+
+
+/**
+ * Done with the stack frame, dereference all the modules in it.
+ *
+ * @param   iLoad1st        The start of the stack frame.
+ * @param   iLoadEnd        The end of the stack frame.
+ * @param   rc              Used for state verification.
+ */
+static void kldrDyldStackDropFrame(uint32_t iLoad1st, uint32_t iLoadEnd, int rc)
+{
+    uint32_t iStack;
+    KLDRDYLD_ASSERT(iLoadEnd <= g_cStackMods);
+    KLDRDYLD_ASSERT(iLoad1st == g_cStackMods);
+
+    /*
+     * First pass: Do all the cleanups we can, but don't destroy anything just yet.
+     */
+    for (iStack = iLoadEnd; iStack < iLoad1st; iStack++)
+    {
+        PKLDRDYLDMOD pMod = g_papStackMods[--iLoad1st];
+        switch (pMod->enmState)
+        {
+            /*
+             * Just push it along to the PENDING_DESTROY state.
+             */
+            case KLDRSTATE_MAPPED:
+                KLDRDYLD_ASSERT(rc);
+                kldrDyldModUnmap(pMod);
+                KLDRDYLD_ASSERT(pMod->enmState == KLDRSTATE_PENDING_DESTROY);
+                break;
+
+            /*
+             * Move back to PENDING_GC.
+             */
+            case KLDRSTATE_RELOADED:
+                KLDRDYLD_ASSERT(rc);
+                pMod->enmState = KLDRSTATE_PENDING_GC;
+                break;
+
+            /*
+             * Unload prerequisites and unmap the modules.
+             */
+            case KLDRSTATE_LOADED_PREREQUISITES:
+            case KLDRSTATE_FIXED_UP:
+                KLDRDYLD_ASSERT(rc);
+                kldrDyldModUnloadPrerequisites(pMod);
+                KLDRDYLD_ASSERT(pMod->enmState == KLDRSTATE_PENDING_DESTROY);
+                kldrDyldModUnmap(pMod);
+                KLDRDYLD_ASSERT(pMod->enmState == KLDRSTATE_PENDING_DESTROY);
+                break;
+
+            /*
+             * Unload prerequisites and push it back to PENDING_GC.
+             */
+            case KLDRSTATE_RELOADED_LOADED_PREREQUISITES:
+            case KLDRSTATE_RELOADED_FIXED_UP:
+                kldrDyldModUnloadPrerequisites(pMod);
+                KLDRDYLD_ASSERT(pMod->enmState == KLDRSTATE_PENDING_GC);
+                break;
+
+            /*
+             * Nothing to do, just asserting sanity.
+             */
+            case KLDRSTATE_INITIALIZING:
+                /* Implies there is another load going on. */
+                KLDRDYLD_ASSERT(g_cActiveLoadCalls > 1);
+                break;
+            case KLDRSTATE_TERMINATING:
+                /* GC in progress. */
+                KLDRDYLD_ASSERT(g_fActiveGC);
+                break;
+            case KLDRSTATE_PENDING_TERMINATION:
+            case KLDRSTATE_PENDING_INITIALIZATION:
+            case KLDRSTATE_PENDING_GC:
+            case KLDRSTATE_PENDING_DESTROY:
+                KLDRDYLD_ASSERT(rc);
+                break;
+            case KLDRSTATE_GOOD:
+                break;
+
+            /*
+             * Bad states.
+             */
+            default:
+                KLDRDYLD_ASSERT(!"drop frame bad state (a)");
+                break;
+        }
+    }
+
+    /*
+     * Second pass: Release the references so modules pending destruction
+     *              can be completely removed.
+     */
+    while (iLoad1st > iLoadEnd)
     {
         /*
-         * Because of initialization and termination routines this
-         * get's kind of complicated. Even if the module is loaded,
-         * we might end up having to resolve all dependencies to check
-         * whether reloading or/and initialization is required.
+         * Pop a module.
          */
-        switch ((*ppMod)->enmState)
-        {
-            /*
-             * Prerequisites are ok, so nothing to do really.
-             */
+        PKLDRDYLDMOD pMod = g_papStackMods[--iLoad1st];
+        g_cStackMods = iLoad1st;
+
+        /*
+         * Revalidate the module state.
+         */
+        switch (pMod->enmState)
+        {
+            case KLDRSTATE_INITIALIZING:
+            case KLDRSTATE_TERMINATING:
+            case KLDRSTATE_PENDING_TERMINATION:
+            case KLDRSTATE_PENDING_INITIALIZATION:
+            case KLDRSTATE_PENDING_GC:
+            case KLDRSTATE_PENDING_DESTROY:
             case KLDRSTATE_GOOD:
-            case KLDRSTATE_INITIALIZING:
-                return kldrDyldModDynamicLoad(*ppMod);
-
-            /*
-             * Prerequisites needs checking.
-             */
-            case KLDRSTATE_PENDING_INITIALIZATION:
-                (*ppMod)->fAlreadySeen = 0;
-            case KLDRSTATE_PENDING_TERMINATION:
-                break;
-
-            /*
-             * The module has been terminated so it need to be reloaded, have it's
-             * prereqs loaded, fixed up and initialized before we can use it again.
-             */
-            case KLDRSTATE_PENDING_GC:
-                rc = kldrDyldModReload(*ppMod);
-                if (rc)
-                    return kldrDyldCopyError(rc, pszErr, cchErr);
-                break;
-
-            /*
-             * Forget it, we don't know how to deal with re-initialization here.
-             */
-            case KLDRSTATE_TERMINATING:
-                KLDRDYLD_ASSERT(!"KLDR_ERR_MODULE_TERMINATING");
-                return KLDR_ERR_MODULE_TERMINATING;
-
-            /*
-             * Invalid state.
-             */
+                break;
             default:
-                KLDRDYLD_ASSERT(!"invalid state");
-                break;
-        }
-    }
-    else
-    {
+                KLDRDYLD_ASSERT(!"drop frame bad state (b)");
+                break;
+        }
+
         /*
-         * We'll have to load it from file.
+         * Release it.
          */
-        rc = kldrDyldFindNewModule(pszDll, pszDefPrefix, pszDefSuffix, enmSearch, fFlags, ppMod);
-        if (rc)
-            return kldrDyldCopyError(rc, pszErr, cchErr);
-        rc = kldrDyldModMap(*ppMod);
-    }
-
-    if (!rc)
+        kldrDyldModDeref(pMod);
+    }
+}
+
+
+/**
+ * Do garbage collection.
+ *
+ * This isn't doing anything unless it's called from the last
+ * load or unload call.
+ */
+static void kldrDyldDoModuleTerminationAndGarabageCollection(void)
+{
+    PKLDRDYLDMOD pMod;
+
+    /*
+     * We don't do anything until we're got rid of all recursive calls.
+     * This will ensure that we get the most optimal termination order and
+     * that we don't unload anything too early.
+     */
+    if (g_cActiveLoadCalls || g_cActiveUnloadCalls || g_fActiveGC)
+        return;
+    g_fActiveGC = 1;
+
+    do
     {
         /*
-         * Create the stack frame of modules by resolving module prerequisites.
+         * 1. Release prerequisites for any left over modules.
          */
-        uint32_t iStackBottom = kldrDyldStackNewFrame();
-        uint32_t iStack = iStackBottom;
-        uint32_t iStackTop;
-        rc = kldrDyldStackPushModule(*ppMod);
-        while (!rc && iStack < g_cStackMods /* changes while we're in the loop */)
-        {
-            PKLDRDYLDMOD pMod = g_papStackMods[iStack];
+        for (pMod = kLdrDyldHead; pMod; pMod = pMod->Load.pNext);
+        {
+            kldrDyldModAddRef(pMod);
+
             switch (pMod->enmState)
             {
-                /*
-                 * Load immediate prerequisite modules and push the ones needing
-                 * attention onto the stack.
-                 */
-                case KLDRSTATE_MAPPED:
-                case KLDRSTATE_RELOADED:
-                    rc = kldrDyldModLoadPrerequisites(pMod, pszDll, pszDefPrefix, pszDefSuffix, enmSearch, fFlags);
+                case KLDRSTATE_GOOD:
+                case KLDRSTATE_PENDING_GC:
                     break;
 
-                /*
-                 * Check dependencies.
-                 */
+                case KLDRSTATE_INITIALIZATION_FAILED: /* just in case */
+                case KLDRSTATE_PENDING_INITIALIZATION:
                 case KLDRSTATE_PENDING_TERMINATION:
-                    rc = kldrDyldModCheckPrerequisites(pMod);
+                    kldrDyldModUnloadPrerequisites(pMod);
                     break;
 
-                /*
-                 * Check its prerequisite modules the first time around.
-                 */
-                case KLDRSTATE_PENDING_INITIALIZATION:
-                    if (!pMod->fAlreadySeen)
-                    {
-                        pMod->fAlreadySeen = 1;
-                        rc = kldrDyldModCheckPrerequisites(pMod);
-                    }
-                    break;
-
-                /*
-                 * These are ok.
-                 */
-                case KLDRSTATE_LOADED_PREREQUISITES:
-                case KLDRSTATE_INITIALIZING:
-                case KLDRSTATE_GOOD:
-                    break;
-
-                /*
-                 * All other stats are invalid.
-                 */
                 default:
-                    KLDRDYLD_ASSERT(!"invalid state");
+                    KLDRDYLD_ASSERT(!"invalid GC state (a)");
                     break;
             }
 
-            /* next */
-            iStack++;
-        }
-        iStackTop = kldrDyldStackFrameCompleted();
+            kldrDyldModDeref(pMod);
+        }
 
         /*
-         * Apply fixups.
+         * 2. Do init calls until we encounter somebody calling load/unload.
          */
-        for (iStack = iStackBottom; !rc && iStack < iStackTop; iStack++)
-        {
-            PKLDRDYLDMOD pMod = g_papStackMods[iStack];
-            if (pMod->enmState == KLDRSTATE_LOADED_PREREQUISITES)
-                rc = kldrDyldModFixup(pMod);
-
-        }
-#ifdef KLDRDYLD_STRICT
-        if (!rc)
-            for (iStack = iStackBottom; !rc && iStack < iStackTop; iStack++)
-                KLDRDYLD_ASSERT(g_papStackMods[iStack]->enmState >= KLDRSTATE_FIXED_UP);
-#endif
-
-        /*
-         * Call the initializers (LIFO order).
-         */
-        iStack = iStackBottom;
-        while (!rc && iStack-- > iStackTop)
-        {
-            PKLDRDYLDMOD pMod = g_papStackMods[iStack];
-            if (pMod->enmState == KLDRSTATE_PENDING_INITIALIZATION)
-                rc = kldrDyldModCallInit(pMod);
-        }
-#ifdef KLDRDYLD_STRICT
-        if (!rc)
-            for (iStack = iStackBottom; !rc && iStack < iStackTop; iStack++)
-                KLDRDYLD_ASSERT(g_papStackMods[iStack]->enmState == KLDRSTATE_GOOD);
-#endif
-
-        /*
-         * Complete the load by incrementing the dynamic load count of the
-         * requested module (return handle is already set).
-         */
-        if (!rc)
-        {
-            rc = kldrDyldModDynamicLoad(*ppMod);
-            if (!rc)
+        for (pMod = g_pkLdrDyldTermHead; pMod; pMod = pMod->InitTerm.pNext)
+        {
+            int fRestart = 0;
+            kldrDyldModAddRef(pMod);
+
+            switch (pMod->enmState)
             {
-                kldrDyldStackDropFrame(iStackTop, iStackBottom, rc);
-                kldrDyldModDeref(*ppMod);
-                return rc;
+                case KLDRSTATE_GOOD:
+                case KLDRSTATE_PENDING_GC:
+                    break;
+
+                case KLDRSTATE_PENDING_TERMINATION:
+                {
+                    const uint32_t cTotalLoadCalls = g_cTotalLoadCalls;
+                    const uint32_t cTotalUnloadCalls = g_cTotalUnloadCalls;
+                    kldrDyldModCallTerm(pMod);
+                    fRestart = cTotalLoadCalls != g_cTotalLoadCalls
+                            || cTotalUnloadCalls != g_cTotalUnloadCalls;
+                    break;
+                }
+
+                default:
+                    KLDRDYLD_ASSERT(!"invalid GC state (b)");
+                    break;
             }
-        }
-        kldrDyldStackDropFrame(iStackTop, iStackBottom, rc);
-    }
-    else
-    {
-        /* If the reference count is 0 do a quick ref/deref to trigger destruction. */
-        kldrDyldModAddRef(*ppMod);
-        kldrDyldModDeref(*ppMod);
-    }
-
-    /*
-     * We've failed, copy/create error string.
-     */
-    return kldrDyldCopyError(rc, pszErr, cchErr);
+
+            kldrDyldModDeref(pMod);
+            if (fRestart)
+                break;
+        }
+    } while (pMod);
+
+    /*
+     * Unmap and destroy modules pending for GC.
+     */
+    pMod = kLdrDyldHead;
+    while (pMod)
+    {
+        PKLDRDYLDMOD pNext = pMod->Load.pNext;
+        switch (pMod->enmState)
+        {
+            case KLDRSTATE_INITIALIZATION_FAILED:
+            case KLDRSTATE_PENDING_GC:
+                KLDRDYLD_ASSERT(pMod->cRefs == 0); /* ??? */
+                pMod->enmState = KLDRSTATE_GC;
+                kldrDyldModUnmap(pMod);
+                kldrDyldModDestroy(pMod);
+                break;
+
+            case KLDRSTATE_GOOD:
+                break;
+            default:
+                KLDRDYLD_ASSERT(!"invalid GC state (c)");
+                break;
+        }
+
+        /* next */
+        pMod = pNext;
+    }
+
+    g_fActiveGC = 0;
 }
 
@@ -876 +1356 @@
 
 /**
- * Do garbage collection.
- *
- * This isn't doing anything unless it's called from the last
- * load or unload call.
- */
-static void kldrDyldDoModuleTerminationAndGarabageCollection(void)
-{
-    PKLDRDYLDMOD pMod;
-
-    /*
-     * We don't do anything untill we're got rid of all re-entrant calls.
-     * This will ensure that we get the most optimal termination order and
-     * that we don't unload anything too early.
-     */
-    if (g_cActiveLoadCalls || g_cActiveUnloadCalls || g_fActiveGC)
-        return;
-    g_fActiveGC = 1;
-
-    /*
-     * Release prerequisites to maximize the number of term calls pending.
-     */
-    for (pMod = kLdrDyldHead; pMod; pMod = pMod->Load.pNext);
-    {
-        kldrDyldModAddRef(pMod);
-
-        switch (pMod->enmState)
-        {
-            case KLDRSTATE_GOOD:
-            case KLDRSTATE_PENDING_GC:
-                break;
-
-            case KLDRSTATE_PENDING_INITIALIZATION:
-            case KLDRSTATE_PENDING_TERMINATION:
-                kldrDyldModUnloadPrerequisites(pMod);
-                break;
-
-            default:
-                KLDRDYLD_ASSERT(!"invalid GC state (a)");
-                break;
-        }
-
-        kldrDyldModDeref(pMod);
-    }
-
-    /*
-     * Do termination calls (FIFO order) process new unloads.
-     * The current algorithm here is a bit sluggish, but it ensure correct order.
-     */
-    do
-    {
-        for (pMod = g_pkLdrDyldTermHead; pMod; pMod = pMod->Term.pNext)
-        {
-            int fRestart = 0;
-            kldrDyldModAddRef(pMod);
-
-            switch (pMod->enmState)
-            {
-                case KLDRSTATE_GOOD:
-                case KLDRSTATE_PENDING_GC:
-                    break;
-
-                case KLDRSTATE_PENDING_TERMINATION:
-                    kldrDyldModUnloadPrerequisites(pMod);
-                    kldrDyldModCallTerm(pMod);
-                    fRestart = 1;
-                    break;
-
-                case KLDRSTATE_PENDING_INITIALIZATION:
-                    kldrDyldModUnloadPrerequisites(pMod);
-                    break;
-
-                default:
-                    KLDRDYLD_ASSERT(!"invalid GC state (b)");
-                    break;
-            }
-
-            kldrDyldModDeref(pMod);
-            if (fRestart)
-                break;
-        }
-    } while (pMod);
-
-    /*
-     * Unmap and destroy modules pending for GC.
-     */
-    pMod = kLdrDyldHead;
-    while (pMod)
-    {
-        PKLDRDYLDMOD pNext = pMod->Load.pNext;
-        switch (pMod->enmState)
-        {
-            case KLDRSTATE_PENDING_GC:
-                kldrDyldModAddRef(pMod);
-                KLDRDYLD_ASSERT(pMod->cRefs == 1);
-
-                pMod->enmState = KLDRSTATE_GC;
-                kldrDyldModUnmap(pMod);
-
-                KLDRDYLD_ASSERT(pMod->enmState == KLDRSTATE_PENDING_DESTROY);
-                kldrDyldModDeref(pMod);
-                break;
-
-            /* the only other state that's valid at this point. */
-            case KLDRSTATE_GOOD:
-                break;
-
-            /* all other stats are invalid. */
-            default:
-                KLDRDYLD_ASSERT(!"invalid GC state (c)");
-                break;
-        }
-
-        /* next */
-        pMod = pNext;
-    }
-
-    g_fActiveGC = 0;
-}
-
-
-
-/**
- * Starts loading a new module and its dependencies.
- * @returns Where the new stack frame starts.
- */
-static uint32_t kldrDyldStackNewFrame(void)
-{
-#ifdef KLDRDYLD_STRICT
-    /* check that all modules are in the correct state */
-    PKLDRDYLDMOD pMod = kLdrDyldHead;
-    while (pMod)
-    {
-        //KLDRDYLD_ASSERT(pMod->enmState == KLDRSTATE_LOADED);
-
-        /* next */
-        pMod = pMod->Load.pNext;
-    }
-#endif
-    return g_cStackMods;
-}
-
-
-/**
- * Records the module.
- *
- * @return 0 on success, KLDR_ERR_NO_MEMORY if we can't expand the table.
- * @param   pMod        The module to record.
- */
-int kldrDyldStackPushModule(PKLDRDYLDMOD pMod)
-{
-    int rc;
-
-    /*
-     * Grow the stack if necessary.
-     */
-    if (g_cStackMods + 1 > g_cStackModsAllocated)
-    {
-        uint32_t cNew = g_cStackModsAllocated ? g_cStackModsAllocated * 2 : 128;
-        void *pvOld = g_papStackMods;
-        void *pvNew = kldrHlpAlloc(cNew * sizeof(g_papStackMods[0]));
-        if (!pvNew)
-            return KLDR_ERR_NO_MEMORY;
-        kLdrHlpMemCopy(pvNew, pvOld, g_cStackMods * sizeof(g_papStackMods[0]));
-        g_papStackMods = (PPKLDRDYLDMOD)pvNew;
-        kldrHlpFree(pvOld);
-    }
-
-    /*
-     * Add a reference and push the module onto the stack.
-     */
-    rc = kldrDyldModAddRef(pMod);
-    if (!rc)
-        g_papStackMods[g_cStackMods++] = pMod;
-    return rc;
-}
-
-
-/**
- * The frame has been completed.
- *
- * @returns Where the frame ends.
- */
-static int kldrDyldStackFrameCompleted(void)
-{
-    return g_cStackMods;
-}
-
-
-/**
- * Done with the stack frame, dereference all the module in it.
- *
- * @param   iStackTop       The top of the stack frame.
- * @param   iStackBottom    The bottom of the stack frame.
- * @param   rc              Used for state verification.
- */
-static void kldrDyldStackDropFrame(uint32_t iStackTop, uint32_t iStackBottom, int rc)
-{
-    uint32_t iStack;
-    KLDRDYLD_ASSERT(iStackBottom <= g_cStackMods);
-    KLDRDYLD_ASSERT(iStackTop == g_cStackMods);
-
-    /*
-     * First pass, cleanup modules in an obvious 'failed' state so we don't
-     * leave any of the non-reentrant states behind.
-     */
-    for (iStack = iStackBottom; iStack < iStackTop; iStack++)
-    {
-        PKLDRDYLDMOD pMod = g_papStackMods[--iStackTop];
-        switch (pMod->enmState)
-        {
-            /*
-             * Unmap freshly mapped so it can be destroyed.
-             */
-            case KLDRSTATE_MAPPED:
-                KLDRDYLD_ASSERT(rc);
-                kldrDyldModUnmap(pMod);
-                KLDRDYLD_ASSERT(pMod->enmState == KLDRSTATE_PENDING_DESTROY);
-                break;
-
-            /*
-             * Reload is reverted to it's old state.
-             */
-            case KLDRSTATE_RELOADED:
-                KLDRDYLD_ASSERT(rc);
-                pMod->enmState = KLDRSTATE_PENDING_GC;
-                break;
-
-            /*
-             * Unload prerequisites and unmap modules loaded in this frame.
-             */
-            case KLDRSTATE_LOADED_PREREQUISITES:
-            case KLDRSTATE_FIXED_UP: /** @todo fix reload state mess. */
-                KLDRDYLD_ASSERT(rc);
-                kldrDyldModUnloadPrerequisites(pMod);
-                KLDRDYLD_ASSERT(pMod->enmState == KLDRSTATE_PENDING_GC);
-                kldrDyldModUnmap(pMod);
-                KLDRDYLD_ASSERT(pMod->enmState == KLDRSTATE_PENDING_DESTROY);
-                break;
-
-            /*
-             * Ok states.
-             */
-            case KLDRSTATE_INITIALIZING:
-                KLDRDYLD_ASSERT(g_cActiveLoadCalls > 0);
-                break;
-            case KLDRSTATE_TERMINATING:
-                KLDRDYLD_ASSERT(rc);
-                KLDRDYLD_ASSERT(g_fActiveGC);
-                break;
-            case KLDRSTATE_PENDING_TERMINATION:
-            case KLDRSTATE_PENDING_INITIALIZATION:
-            case KLDRSTATE_PENDING_GC:
-            case KLDRSTATE_PENDING_DESTROY:
-                KLDRDYLD_ASSERT(rc);
-                break;
-            case KLDRSTATE_GOOD:
-                break;
-
-            /*
-             * Bad states.
-             */
-            default:
-                KLDRDYLD_ASSERT(!"drop frame bad state (a)");
-                break;
-        }
-    }
-
-    /*
-     * Second pass, release the references to the modules on the stack.
-     */
-    while (iStackTop > iStackBottom)
-    {
-        /*
-         * Pop a module.
-         */
-        PKLDRDYLDMOD pMod = g_papStackMods[--iStackTop];
-        g_cStackMods = iStackTop;
-
-        /*
-         * Validate the state.
-         */
-        switch (pMod->enmState)
-        {
-            /*
-             * Ok states
-             */
-            case KLDRSTATE_INITIALIZING:
-                KLDRDYLD_ASSERT(g_cActiveLoadCalls > 0);
-                break;
-            case KLDRSTATE_TERMINATING:
-                KLDRDYLD_ASSERT(rc);
-                KLDRDYLD_ASSERT(g_fActiveGC);
-                break;
-            case KLDRSTATE_PENDING_INITIALIZATION:
-            case KLDRSTATE_PENDING_TERMINATION:
-            case KLDRSTATE_PENDING_GC:
-            case KLDRSTATE_PENDING_DESTROY:
-                KLDRDYLD_ASSERT(rc);
-                break;
-            case KLDRSTATE_GOOD:
-                break;
-
-            /*
-             * Bad states.
-             */
-            default:
-                KLDRDYLD_ASSERT(!"drop frame bad state (b)");
-                break;
-        }
-
-        /*
-         * Release it.
-         */
-        kldrDyldModDeref(pMod);
-    }
-}
-
-
-/**
  * Panic / failure
  *

trunk/kLdr/kLdrDyldMod.c

@@ -49 +49 @@
 
 
-
+/**
+ * Decrement the dynamic load count of the module and unload the module
+ * if the total reference count reaches zero.
+ *
+ * This may cause a cascade of unloading to occure. See kldrDyldModUnloadPrerequisites().
+ *
+ * @returns status code.
+ * @retval  0 on success.
+ * @retval  KLDR_ERR_NOT_LOADED_DYNAMICALLY if the module wasn't loaded dynamically.
+ * @param   pMod        The module to unload.
+ */
+int kldrDyldModDynamicUnload(PKLDRDYLDMOD pMod)
+{
+    if (pMod->cDynRefs == 0)
+        return KLDR_ERR_NOT_LOADED_DYNAMICALLY;
+    KLDRDYLDMOD_ASSERT(pMod->cDynRefs <= pMod->cRefs);
+    KLDRDYLDMOD_ASSERT(pMod->enmState == KLDRSTATE_GOOD);
+
+    pMod->cRefs--;
+    pMod->cDynRefs--;
+    if (pMod->cRefs > 0)
+        return 0;
+
+    /*
+     * The module should be unloaded.
+     */
+    kldrDyldModUnloadPrerequisites(pMod);
+    return 0;
+}
+
+
+/**
+ * Worker for kldrDyldModUnloadPrerequisites.
+ *
+ * @returns The number of modules that now can be unloaded.
+ * @param   pMod    The module in  question.
+ */
+static uint32_t kldrDyldModUnloadPrerequisitesOne(PKLDRDYLDMOD pMod)
+{
+    PKLDRDYLDMOD    pMod2;
+    uint32_t        cToUnload = 0;
+    uint32_t        i;
+
+    KLDRDYLDMOD_ASSERT(pMod->papPrereqs);
+
+    /*
+     * Release the one in this module.
+     */
+    for (i = 0; i < pMod->cPrereqs; i++)
+    {
+        pMod2 = pMod->papPrereqs[i];
+        if (pMod2)
+        {
+            /* do the derefering ourselves or we'll end up in a recursive loop here. */
+            KLDRDYLDMOD_ASSERT(pMod2->cDepRefs > 0);
+            KLDRDYLDMOD_ASSERT(pMod2->cRefs >= pMod2->cDepRefs);
+            pMod2->cDepRefs--;
+            pMod2->cRefs--;
+            cToUnload += !pMod2->cRefs;
+        }
+    }
+
+    /*
+     * Change the state
+     */
+    switch (pMod->enmState)
+    {
+        case KLDRSTATE_LOADED_PREREQUISITES:
+        case KLDRSTATE_FIXED_UP:
+            pMod->enmState = KLDRSTATE_PENDING_DESTROY;
+            kldrDyldModUnlink(pMod);
+            break;
+
+        case KLDRSTATE_PENDING_INITIALIZATION:
+            pMod->enmState = KLDRSTATE_PENDING_GC;
+            break;
+
+        case KLDRSTATE_RELOADED_FIXED_UP:
+        case KLDRSTATE_RELOADED_LOADED_PREREQUISITES:
+        case KLDRSTATE_GOOD:
+            pMod->enmState = KLDRSTATE_PENDING_TERMINATION;
+            break;
+
+        case KLDRSTATE_INITIALIZATION_FAILED:
+            break;
+
+        default:
+            KLDRDYLDMOD_ASSERT(!"invalid state");
+            break;
+    }
+
+    return cToUnload;
+}
+
+
+/**
+ * This is the heart of the unload code.
+ *
+ * It will recursivly (using the load list) initiate module unloading
+ * of all affected modules.
+ *
+ * This function will cause a state transition ot PENDING_DESTROY, PENDING_GC
+ * or PENDING_TERMINATION depending on the module state. There is one exception
+ * to this, and that's INITIALIZATION_FAILED, where the state will not be changed.
+ *
+ * @param   pMod        The module which prerequisites should be unloaded.
+ */
 void kldrDyldModUnloadPrerequisites(PKLDRDYLDMOD pMod)
 {
-
-}
+    uint32_t        cToUnload;
+
+    /* sanity */
+#ifdef KLDRDYLD_STRICT
+    {
+    PKLDRDYLDMOD pMod2;
+    for (pMod2 = kLdrDyldHead; pMod2; pMod2 = pMod2->Load.pNext)
+        KLDRDYLDMOD_ASSERT(pMod2->enmState != KLDRSTATE_GOOD || pMod2->cRefs);
+    }
+#endif
+    KLDRDYLDMOD_ASSERT(pMod->papPrereqs);
+
+    /*
+     * Unload prereqs of the module we're called on first.
+     */
+    cToUnload = kldrDyldModUnloadPrerequisitesOne(pMod);
+
+    /*
+     * Iterate the load list in a cyclic manner until there are no more
+     * modules that can be pushed on into unloading.
+     */
+    while (cToUnload)
+    {
+        cToUnload = 0;
+        for (pMod = kLdrDyldHead; pMod; pMod = pMod->Load.pNext)
+        {
+            if (    pMod->cRefs
+                ||  pMod->enmState >= KLDRSTATE_PENDING_TERMINATION
+                ||  pMod->enmState < KLDRSTATE_LOADED_PREREQUISITES)
+                continue;
+            cToUnload += kldrDyldModUnloadPrerequisitesOne(pMod);
+        }
+    }
+}
+
+
+
 
 

trunk/kLdr/kLdrHlp.c

@@ -555 +555 @@
     ULONG       cbWritten;
     const char *pszNl = kLdrHlpStrChr(pszMsg, '\n');
-    while (pszNl || *pszMsg)
+    while (pszNl)
     {
         cbWritten = pszNl - pszMsg;

trunk/kLdr/kLdrInternal.h

@@ -164 +164 @@
     /** Pending termination, reference count is 0.
      * While the module is in this state the loader is in reentrant mode.
+     * Prerequisite modules are dropped when a module enters this state.
      *
      * Prev state: GOOD
@@ -179 +180 @@
 
     /** Pending garbage collection.
+     * Prerequisite modules are dropped when a module enters this state (if not done already).
      *
      * Prev state: TERMINATING, PENDING_INITIALIZATION, INITIALIZATION_FAILED
@@ -238 +240 @@
     /** Whether the module contains bindable symbols in the global unix namespace. */
     uint32_t            fBindable : 1;
+    /** Set if linked into the global init list. */
+    uint32_t            fInitList : 1;
+    /** Already loaded or checked prerequisites.
+     * This flag is used when loading prerequisites, when set it means that
+     * this module is already seen and shouldn't be processed again. */
+    uint32_t            fAlreadySeen : 1;
     /** Reserved for future use. */
-    uint32_t            fReserved : 28;
-    /** Already checked dependencies.
-     * This is flag used when resolving module dependencies during a load, it
-     * deals with modules in the KLDRSTATE_PENDING_INITIALIZATION state. */
-    uint32_t            fAlreadySeen : 1;
+    uint32_t            fReserved : 27;
     /** The load list linkage. */
     struct
@@ -252 +256 @@
         struct KLDRDYLDMOD *pPrev;
     } Load;
-    /** The termination list linkage.
+    /** The initialization and termination list linkage.
+     * If non-recursive initialization is used, the module will be pushed on
+     * the initialization list.
      * A module will be linked into the termination list upon a successful
      * return from module initialization. */
@@ -261 +267 @@
         /** The prev module in the list. */
         struct KLDRDYLDMOD *pPrev;
-    } Term;
+    } InitTerm;
     /** The bind order list linkage.
      * The module is not in this list when fBindable is clear. */
@@ -271 +277 @@
         struct KLDRDYLDMOD *pPrev;
     } Bind;
+
+    /** The number of prerequisite modules in the prereq array. */
+    uint32_t            cPrereqs;
+    /** Pointer to an array of prerequisite module pointers.
+     * This array is only filled when in the states starting with
+     * KLDRSTATE_LOADED_PREREQUISITES thru KLDRSTATE_GOOD.
+     */
+    struct KLDRDYLDMOD **papPrereqs;
+
     /** Magic number. */
     uint32_t            u32MagicTail;
@@ -312 +327 @@
 int kldrDyldModMap(PKLDRDYLDMOD pMod);
 int kldrDyldModUnmap(PKLDRDYLDMOD pMod);
-int kldrDyldModLoadPrerequisites(PKLDRDYLDMOD pMod, const char *pszName, const char *pszDefPrefix, const char *pszDefSuffix,
+int kldrDyldModLoadPrerequisites(PKLDRDYLDMOD pMod, const char *pszDefPrefix, const char *pszDefSuffix,
                                  KLDRDYLDSEARCH enmSearch, unsigned fFlags);
 int kldrDyldModCheckPrerequisites(PKLDRDYLDMOD pMod);
@@ -333 +348 @@
 
 
-/** Pointer to the head module of the load list (the executable). */
-extern PKLDRDYLDMOD     kLdrDyldModuleHead;
-/** Pointer to the tail module of the load list. */
-extern PKLDRDYLDMOD     kLdrDyldModuleTail;
+/** Pointer to the head module (the executable).
+ * (This is exported, so no prefix.) */
+extern PKLDRDYLDMOD     kLdrDyldHead;
+/** Pointer to the tail module.
+ * (This is exported, so no prefix.) */
+extern PKLDRDYLDMOD     kLdrDyldTail;
 /** Pointer to the head module of the termination order list. */
 extern PKLDRDYLDMOD     g_pkLdrDyldTermHead;

trunk/kLdr/tg/KLDRSTATE.txvstc

@@ -463 +463 @@
         </link>
         <link uin="id83t9setug73fpetug74ah.nodeidswftetug73fpetugfwd3.linkid7ockpetuqdc66etuqdq4c">
-            <property name="$metaclass" value="Transition"/>
             <participant role="Supplier" referencedUin="design:node:::id83t9setug73fpetug74ah.nodeid8048etug73fpetugfpwv"/>
             <participant role="Client" referencedUin="design:node:::id83t9setug73fpetug74ah.nodeidswftetug73fpetugfwd3"/>
+            <property name="$metaclass" value="Transition"/>
             <property name="$event_name" value="Loaded again"/>
         </link>

trunk/kLdr/tg/kLdr.tpr

@@ -14 +14 @@
 Developer.DebugWorkspace={{0,2,-1,0,0,0,0,0,0,1,0,50,75,25,-1,-1,-1,-1}${0,1,-1,0,0,0,0,1,0,1,1,50,75,25,-1,-1,-1,-1}${0,3,-1,0,0,0,0,0,0,1,0,50,50,25,-1,-1,-1,-1}${0,3,-1,0,0,0,0,0,0,1,0,50,50,25,-1,-1,-1,-1}${0,-1,-1,0,0,0,0,0,0,1,0,5,5,5,-1,-1,-1,-1}${0,4,-1,0,0,0,0,0,0,1,0,50,50,25,-1,-1,-1,-1}${0,0,-1,0,0,0,0,1,0,1,0,75,5,5,-1,-1,-1,-1}${0,7,-1,0,0,0,0,0,0,1,0,50,50,75,-1,-1,-1,-1}}
 Developer.DesignWorkspace={{0,2,-1,0,0,0,0,1,0,1,0,50,75,22,-1,-1,-1,-1}${0,1,-1,0,0,0,0,0,0,1,0,50,75,22,-1,-1,-1,-1}${0,3,-1,0,0,0,0,1,0,1,0,50,50,22,-1,-1,-1,-1}${0,3,-1,0,0,0,0,1,0,1,0,50,50,22,-1,-1,-1,-1}${0,-1,-1,0,0,0,0,0,0,1,0,5,5,5,-1,-1,-1,-1}${0,4,-1,0,0,0,0,1,0,1,1,50,50,22,-1,-1,-1,-1}${0,0,-1,0,0,0,0,0,0,1,0,75,5,5,-1,-1,-1,-1}${0,7,-1,0,0,0,0,0,0,1,0,50,50,75,-1,-1,-1,-1}}
-Developer.kLdr={{0,2,-1,0,0,0,0,1,0,1,0,50,75,25,-1,-1,-1,-1}${0,1,-1,0,0,0,0,0,0,1,0,50,75,25,-1,-1,-1,-1}${0,3,-1,0,0,0,0,1,0,1,1,50,50,25,-1,-1,-1,-1}${0,3,-1,0,0,0,0,1,0,1,1,50,50,25,-1,-1,-1,-1}${0,-1,-1,0,0,0,0,0,0,1,0,5,5,5,-1,-1,-1,-1}${0,4,-1,0,0,0,0,1,0,1,0,50,50,25,-1,-1,-1,-1}${0,0,-1,0,0,0,0,0,0,1,0,75,5,5,-1,-1,-1,-1}${0,7,-1,0,0,0,0,0,0,1,0,50,50,75,-1,-1,-1,-1}}
+Developer.kLdr={{0,2,-1,0,0,0,0,1,0,1,1,50,75,22,-1,-1,-1,-1}${0,1,-1,0,0,0,0,0,0,1,0,50,75,22,-1,-1,-1,-1}${0,3,-1,0,0,0,0,1,0,1,0,50,50,22,-1,-1,-1,-1}${0,3,-1,0,0,0,0,1,0,1,0,50,50,22,-1,-1,-1,-1}${0,-1,-1,0,0,0,0,0,0,1,0,5,5,5,-1,-1,-1,-1}${0,4,-1,0,0,0,0,1,0,1,0,50,50,22,-1,-1,-1,-1}${0,0,-1,0,0,0,0,0,0,1,0,75,5,5,-1,-1,-1,-1}${0,7,-1,0,0,0,0,0,0,1,0,50,50,75,-1,-1,-1,-1}}
 names.Developer={kLdr,DesignWorkspace,CodingWorkspace,DebugWorkspace}
 [vcs]