Changeset 2845

Timestamp:

Nov 1, 2006, 2:39:03 AM (19 years ago)

Author:

bird

Message:

kldrDyldMod* in progress.

Location:

trunk/kLdr

Files:

• kLdr.h (modified) (1 diff)
• kLdrDyld.c (modified) (11 diffs)
• kLdrDyldMod.c (modified) (5 diffs)
• kLdrInternal.h (modified) (5 diffs)

trunk/kLdr/kLdr.h

@@ -557 +557 @@
 
 int     kLdrModOpen(const char *pszFilename, PPKLDRMOD ppMod);
+int     kLdrModOpenFromRdr(PKLDRRDR pRdr, PPKLDRMOD ppMod);
+int     kLdrModOpenNative(const char *pszFilename, PPKLDRMOD ppMod);
 int     kLdrModClose(PKLDRMOD pMod);
 int     kLdrModGetSymbol(PKLDRMOD pMod, const void *pvBits, uintmax_t BaseAddress, const char *pszSymbol, uintmax_t *pValue, uint32_t *pfKind);

trunk/kLdr/kLdrDyld.c

@@ -168 +168 @@
 static int          kldrDyldStackAddModule(PKLDRDYLDMOD pMod);
 static int          kldrDyldStackFrameCompleted(void);
+static void         kldrDyldStackCleanupOne(PKLDRDYLDMOD pMod, int rc);
 static void         kldrDyldStackDropFrame(uint32_t iLoad1st, uint32_t iLoadEnd, int rc);
 /** @} */
@@ -627 +628 @@
         rc = kldrDyldDoLoad2(*ppMod, pszPrefix, pszSuffix, enmSearch, fFlags);
     else
-    {
-        /** @todo this is probably not quite right. */
-        /* If the reference count is 0 do a quick ref/deref to trigger destruction. */
-        kldrDyldModAddRef(*ppMod);
-        kldrDyldModDeref(*ppMod);
-    }
+        kldrDyldStackCleanupOne(*ppMod, rc);
 
     /*
@@ -656 +652 @@
     int rc = kldrDyldDoLoadPrerequisites(pLoadedMod, pszPrefix, pszSuffix, enmSearch, fFlags);
     uint32_t iLoadEnd = kldrDyldStackFrameCompleted();
+    if (rc)
+        kldrDyldStackCleanupOne(pLoadedMod, rc); /* in case it didn't get pushed onto the stack. */
 
     /*
@@ -954 +952 @@
     if (!rc)
     {
-        rc = kldrDyldModAddDep(pMod, pDep);
-        if (!rc)
-            *ppMod = pMod;
+        kldrDyldModAddDep(pMod, pDep);
+        *ppMod = pMod;
     }
     return rc;
@@ -1023 +1020 @@
 static int kldrDyldStackAddModule(PKLDRDYLDMOD pMod)
 {
-    int rc;
-
     /*
      * Grow the stack if necessary.
@@ -1043 +1038 @@
      * Add a reference and push the module onto the stack.
      */
-    rc = kldrDyldModAddRef(pMod);
-    if (!rc)
-        g_papStackMods[g_cStackMods++] = pMod;
-    return rc;
+    kldrDyldModAddRef(pMod);
+    g_papStackMods[g_cStackMods++] = pMod;
+    return 0;
 }
 
@@ -1058 +1052 @@
 {
     return g_cStackMods;
+}
+
+
+/**
+ * Worker routine for kldrDyldStackDropFrame() and kldrDyldDoLoad().
+ *
+ * @param   pMod            The module to perform cleanups on.
+ * @param   rc              Used for state verification.
+ */
+static void kldrDyldStackCleanupOne(PKLDRDYLDMOD pMod, int rc)
+{
+    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;
+    }
 }
 
@@ -1080 +1152 @@
     {
         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;
-        }
+        kldrDyldStackCleanupOne(pMod, rc);
     }
 
@@ -1277 +1283 @@
     {
         PKLDRDYLDMOD pNext = pMod->Load.pNext;
+        kldrDyldModAddRef(pMod);
+
         switch (pMod->enmState)
         {
@@ -1284 +1292 @@
                 pMod->enmState = KLDRSTATE_GC;
                 kldrDyldModUnmap(pMod);
+                KLDRDYLD_ASSERT(pMod->enmState == KLDRSTATE_PENDING_DESTROY);
                 kldrDyldModDestroy(pMod);
+                KLDRDYLD_ASSERT(pMod->enmState == KLDRSTATE_DESTROYED);
                 break;
 
@@ -1293 +1303 @@
                 break;
         }
+
+        kldrDyldModDeref(pMod);
 
         /* next */

trunk/kLdr/kLdrDyldMod.c

@@ -38 +38 @@
 *   Defined Constants And Macros                                               *
 *******************************************************************************/
+/** @def KLDRDYLDMOD_STRICT
+ * Define KLDRDYLDMOD_STRICT to enabled strict checks in kLdrDyld. */
+#define KLDRDYLDMOD_STRICT 1
+
 /** @def KLDRDYLDMOD_ASSERT
  * Assert that an expression is true when KLDRDYLD_STRICT is defined.
  */
-#ifdef KLDRDYLD_STRICT
+#ifdef KLDRDYLDMOD_STRICT
 # define KLDRDYLDMOD_ASSERT(expr)  kldrHlpAssert(expr)
 #else
@@ -50 +54 @@
 
 /**
+ * Creates a module from the specified file provider instance.
+ *
+ * @returns 0 on success and *ppMod pointing to the new instance.
+ *          On failure a non-zero kLdr status code is returned.
+ * @param   pRdr    The file provider instance.
+ * @param   ppMod   Where to put the pointer to the new module on success.
+ */
+int kldrDyldModCreate(PKLDRRDR pRdr, PPKLDRDYLDMOD ppMod)
+{
+    PKLDRDYLDMOD pMod;
+    PKLDRMOD pRawMod;
+    int rc;
+
+    *ppMod = NULL;
+
+    /*
+     * Try open an module interpreter.
+     */
+    rc = kLdrModOpenFromRdr(pRdr, &pRawMod);
+    if (rc)
+        return kldrDyldFailure(rc, "%s: %rc", kLdrRdrName(pRdr), rc);
+
+    /*
+     * Allocate a new dyld module.
+     */
+    pMod = (PKLDRDYLDMOD)kldrHlpAlloc(sizeof(*pMod));
+    if (pMod)
+    {
+        pMod->enmState = KLDRSTATE_OPEN;
+        pMod->pMod = pRawMod;
+        pMod->hMod = pMod;
+        pMod->cDepRefs = pMod->cDynRefs = pMod->cRefs = 0;
+        pMod->fExecutable = 0;
+        switch (pRawMod->enmType)
+        {
+            case KLDRTYPE_EXECUTABLE_FIXED:
+            case KLDRTYPE_EXECUTABLE_RELOCATABLE:
+            case KLDRTYPE_EXECUTABLE_PIC:
+                pMod->fExecutable = 1;
+                break;
+        }
+        pMod->fGlobalOrSpecific = 0;
+        pMod->fBindable = 0;
+        pMod->fInitList = 0;
+        pMod->fAlreadySeen = 0;
+        pMod->fMapped = 0;
+        pMod->f26Reserved = 0;
+        pMod->InitTerm.pNext = NULL;
+        pMod->InitTerm.pPrev = NULL;
+        pMod->Bind.pNext = NULL;
+        pMod->Bind.pPrev = NULL;
+        pMod->cPrereqs = 0;
+        pMod->papPrereqs = NULL;
+        pMod->u32MagicHead = KLDRDYMOD_MAGIC;
+        pMod->u32MagicTail = KLDRDYMOD_MAGIC;
+
+        /* it. */
+        pMod->Load.pNext = NULL;
+        pMod->Load.pPrev = kLdrDyldTail;
+        if (kLdrDyldTail)
+            kLdrDyldTail->Load.pNext = pMod;
+        else
+            kLdrDyldHead = pMod;
+        kLdrDyldTail = pMod;
+
+        /* we're good. */
+        *ppMod = pMod;
+        rc = 0;
+    }
+    else
+    {
+        kLdrModClose(pRawMod);
+        rc = KLDR_ERR_NO_MEMORY;
+    }
+    return rc;
+}
+
+
+/**
+ * Creates a module for a native module.
+ *
+ * @returns 0 on success and *ppMod pointing to the new instance.
+ *          On failure a non-zero kLdr status code is returned.
+ * @param   hNativeModule   The native handle.
+ * @param   ppMod           Where to put the pointer to the new module on success.
+ * @remark  This function ain't finalized yet.
+ */
+int kldrDyldModCreateNative(uintptr_t hNativeModule)
+{
+#if 0
+    /*
+     * Check if this module is already loaded by the native OS loader.
+     */
+    rc = kld
+    {
+#ifdef __OS2__
+    HMODULE hmod = NULLHANDLE;
+    APIRET rc = DosQueryModuleHandle(kLdrRdrName(pRdr), &hmod);
+    if (!rc)
+
+#elif defined(__WIN__)
+    HMODULE hmod = NULL;
+    if (GetModuleHandle(kLdrRdrName(pRdr))
+
+#else
+# error "Port me"
+#endif
+    }
+#endif
+    return -1;
+}
+
+
+/**
+ * Destroys a module pending destruction.
+ *
+ * @param   pMod        The module in question.
+ */
+void kldrDyldModDestroy(PKLDRDYLDMOD pMod)
+{
+    /*
+     * Validate the state.
+     */
+    switch (pMod->enmState)
+    {
+        case KLDRSTATE_PENDING_DESTROY:
+        case KLDRSTATE_GC:
+            break;
+        default:
+            KLDRDYLDMOD_ASSERT(!"Invalid state");
+            break;
+    }
+    KLDRDYLDMOD_ASSERT(!pMod->fInitList);
+    KLDRDYLDMOD_ASSERT(!pMod->cDynRefs);
+    KLDRDYLDMOD_ASSERT(!pMod->cDepRefs);
+
+
+    /*
+     * Ensure that the module is unmapped.
+     */
+    if (pMod->fMapped)
+        kldrDyldModUnmap(pMod);
+}
+
+
+/**
+ * Unlinks the module from any list it might be in.
+ * It is assumed that the module is at least linked into the load list.
+ *
+ * @param   pMod    The moduel.
+ */
+static void kldrDyldModUnlink(PKLDRDYLDMOD pMod)
+{
+    /* load list */
+    if (pMod->Load.pNext)
+        pMod->Load.pNext->Load.pPrev = pMod->Load.pPrev;
+    else
+        kLdrDyldTail = pMod->Load.pPrev;
+    if (pMod->Load.pPrev)
+        pMod->Load.pPrev->Load.pNext = pMod->Load.pNext;
+    else
+        kLdrDyldHead = pMod->Load.pNext;
+
+    /* bind list */
+    if (pMod->fBindable)
+        kldrDyldModClearBindable(pMod);
+
+    /* init term */
+    if (pMod->fInitList)
+    {
+        KLDRDYLDMOD_ASSERT(pMod->enmState < KLDRSTATE_INITIALIZATION_FAILED);
+        pMod->fInitList = 0;
+        if (pMod->InitTerm.pNext)
+            pMod->InitTerm.pNext->InitTerm.pPrev = pMod->InitTerm.pPrev;
+        else
+            g_pkLdrDyldInitTail = pMod->InitTerm.pPrev;
+        if (pMod->InitTerm.pPrev)
+            pMod->InitTerm.pPrev->InitTerm.pNext = pMod->InitTerm.pNext;
+        else
+            g_pkLdrDyldInitHead = pMod->InitTerm.pNext;
+    }
+    else if (pMod->enmState > KLDRSTATE_INITIALIZATION_FAILED)
+    {
+        KLDRDYLDMOD_ASSERT(pMod->enmState >= KLDRSTATE_GOOD);
+        if (pMod->InitTerm.pNext)
+            pMod->InitTerm.pNext->InitTerm.pPrev = pMod->InitTerm.pPrev;
+        else
+            g_pkLdrDyldTermTail = pMod->InitTerm.pPrev;
+        if (pMod->InitTerm.pPrev)
+            pMod->InitTerm.pPrev->InitTerm.pNext = pMod->InitTerm.pNext;
+        else
+            g_pkLdrDyldTermHead = pMod->InitTerm.pNext;
+    }
+    pMod->InitTerm.pNext = NULL;
+    pMod->InitTerm.pPrev = NULL;
+}
+
+
+/**
+ * Adds a reference to the module making sure it won't be freed just yet.
+ *
+ * @param   pMod    The module.
+ */
+void kldrDyldModAddRef(PKLDRDYLDMOD pMod)
+{
+    pMod->cRefs++;
+}
+
+
+/**
+ * Dereference a module.
+ *
+ * @param   pMod
+ */
+void kldrDyldModDeref(PKLDRDYLDMOD pMod)
+{
+    /* validate input */
+    KLDRDYLDMOD_ASSERT(pMod->cRefs > 0);
+    KLDRDYLDMOD_ASSERT(pMod->cRefs >= pMod->cDepRefs + pMod->cDynRefs);
+    KLDRDYLDMOD_ASSERT(pMod->enmState > KLDRSTATE_INVALID && pMod->enmState <= KLDRSTATE_END);
+
+    /* decrement. */
+    if (pMod->cRefs > 0)
+        pMod->cRefs--;
+
+    /* execute delayed freeing. */
+    if (    pMod->enmState == KLDRSTATE_DESTROYED
+        &&  !pMod->cRefs)
+        kldrHlpFree(pMod);
+}
+
+
+/**
+ * Increment the count of modules depending on this module.
+ *
+ * @param   pMod    The module.
+ * @param   pDep    The module which depends on us.
+ */
+void kldrDyldModAddDep(PKLDRDYLDMOD pMod, PKLDRDYLDMOD pDep)
+{
+    (void)pDep;
+
+    /* validate state */
+    switch (pMod->enmState)
+    {
+        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:
+            break;
+        default:
+            KLDRDYLDMOD_ASSERT(!"invalid state");
+            break;
+
+    }
+    KLDRDYLDMOD_ASSERT(pMod->enmState > KLDRSTATE_INVALID && pMod->enmState <= KLDRSTATE_END);
+    pMod->cRefs++;
+    pMod->cDepRefs++;
+}
+
+
+/**
+ * Drop a dependency.
+ *
+ * @param   pMod    The module.
+ * @param   pDep    The module which depends on us.
+ */
+void kldrDyldModRemoveDep(PKLDRDYLDMOD pMod, PKLDRDYLDMOD pDep)
+{
+    KLDRDYLDMOD_ASSERT(pMod->cDepRefs > 0);
+    if (pMod->cDepRefs == 0)
+        return;
+    KLDRDYLDMOD_ASSERT(pMod->cDepRefs <= pMod->cRefs);
+    KLDRDYLDMOD_ASSERT(pMod->enmState >= KLDRSTATE_MAPPED && pMod->enmState <= KLDRSTATE_PENDING_DESTROY);
+
+    pMod->cRefs--;
+    pMod->cDepRefs--;
+    if (    pMod->cDepRefs > 0
+        ||  pMod->cDynRefs > 0)
+        return;
+
+    /*
+     * The module should be unloaded.
+     */
+    kldrDyldModUnloadPrerequisites(pMod);
+}
+
+
+/**
+ * Increment the dynamic load count.
+ *
+ * @returns 0
+ * @param   pMod    The module.
+ */
+int kldrDyldModDynamicLoad(PKLDRDYLDMOD pMod)
+{
+    KLDRDYLDMOD_ASSERT(     pMod->enmState == KLDRSTATE_GOOD
+                       ||   pMod->enmState == KLDRSTATE_PENDING_INITIALIZATION
+                       ||   pMod->enmState == KLDRSTATE_INITIALIZING);
+    pMod->cRefs++;
+    pMod->cDynRefs++;
+    return 0;
+}
+
+
+/**
  * Decrement the dynamic load count of the module and unload the module
  * if the total reference count reaches zero.
@@ -69 +382 @@
     pMod->cRefs--;
     pMod->cDynRefs--;
-    if (pMod->cRefs > 0)
+    if (    pMod->cDynRefs > 0
+        ||  pMod->cDepRefs > 0)
         return 0;
 
@@ -150 +464 @@
  * of all affected modules.
  *
- * This function will cause a state transition ot PENDING_DESTROY, PENDING_GC
+ * This function will cause a state transition to 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.
@@ -194 +508 @@
 
 
-
-
-
-void kldrDyldModDeref(PKLDRDYLDMOD pMod)
-{
-    /* validate input */
-    KLDRDYLDMOD_ASSERT(pMod->enmState > KLDRSTATE_INVALID && pMod->enmState < KLDRSTATE_END);
+int kldrDyldModLoadPrerequisites(PKLDRDYLDMOD pMod, const char *pszPrefix, const char *pszSuffix,
+                                 KLDRDYLDSEARCH enmSearch, unsigned fFlags)
+{
+    return -1;
+}
+
+
+int kldrDyldModCheckPrerequisites(PKLDRDYLDMOD pMod)
+{
+    return -1;
+}
+
+
+/**
+ * Marks the module as global instead of being specific.
+ *
+ * A global module can be a matching result when the request
+ * doesn't specify a path. A specific module will not match
+ * unless the path also matches.
+ *
+ * @param   pMod    The module.
+ */
+void kldrDyldModMarkGlobal(PKLDRDYLDMOD pMod)
+{
+    pMod->fGlobalOrSpecific = 1;
+}
+
+/**
+ * Marks the module as specific instead of global.
+ *
+ * See kldrDyldModMarkGlobal for an explanation of the two terms.
+ *
+ * @param   pMod    The module.
+ */
+void kldrDyldModMarkSpecific(PKLDRDYLDMOD pMod)
+{
+    pMod->fGlobalOrSpecific = 0;
+}
+
+
+/**
+ * Marks a module as bindable, i.e. it'll be considered when
+ * resolving names the unix way.
+ *
+ * @param   pMod    The module.
+ * @param   fDeep   When set the module will be inserted at the head of the
+ *                  module list used to resolve symbols. This means that the
+ *                  symbols in this module will be prefered of all the other
+ *                  modules.
+ */
+void kldrDyldModSetBindable(PKLDRDYLDMOD pMod, unsigned fDeep)
+{
+    KLDRDYLDMOD_ASSERT(pMod->enmState >= KLDRSTATE_OPEN && pMod->enmState < KLDRSTATE_PENDING_GC);
+    if (!pMod->fBindable)
+    {
+        pMod->fBindable = 1;
+        if (!fDeep)
+        {
+            pMod->Bind.pNext = NULL;
+            pMod->Bind.pPrev = g_pkLdrDyldBindTail;
+            if (g_pkLdrDyldBindTail)
+                g_pkLdrDyldBindTail->Bind.pNext = pMod;
+            else
+                g_pkLdrDyldBindHead = pMod;
+            g_pkLdrDyldBindTail = pMod;
+        }
+        else
+        {
+            pMod->Bind.pPrev = NULL;
+            pMod->Bind.pNext = g_pkLdrDyldBindHead;
+            if (g_pkLdrDyldBindHead)
+                g_pkLdrDyldBindHead->Bind.pPrev = pMod;
+            else
+                g_pkLdrDyldBindTail = pMod;
+            g_pkLdrDyldBindHead = pMod;
+        }
+    }
+}
+
+
+/**
+ * Marks a module as not bindable, i.e. it will not be considered when
+ * resolving names the unix way.
+ *
+ * @param   pMod    The module.
+ */
+void kldrDyldModClearBindable(PKLDRDYLDMOD pMod)
+{
+    KLDRDYLDMOD_ASSERT(pMod->enmState >= KLDRSTATE_OPEN && pMod->enmState < KLDRSTATE_PENDING_DESTROY);
+    if (pMod->fBindable)
+    {
+        pMod->fBindable = 0;
+        if (pMod->Bind.pPrev)
+            pMod->Bind.pPrev->Bind.pNext = pMod->Bind.pNext;
+        else
+            g_pkLdrDyldBindHead = pMod->Bind.pNext;
+        if (pMod->Bind.pNext)
+            pMod->Bind.pNext->Bind.pPrev = pMod->Bind.pPrev;
+        else
+            g_pkLdrDyldBindTail = pMod->Bind.pPrev;
+        pMod->Bind.pNext = NULL;
+        pMod->Bind.pPrev = NULL;
+    }
+}
+
+
+/**
+ * Maps an open module.
+ *
+ * On success the module will be in the MAPPED state.
+ *
+ * @returns 0 on success, non-zero native OS or kLdr status code on failure.
+ * @param   pMod    The module which needs to be unmapped and set pending for destruction.
+ */
+int kldrDyldModMap(PKLDRDYLDMOD pMod)
+{
+    int rc;
+
+    /* sanity */
     KLDRDYLDMOD_ASSERT(pMod->cRefs > 0);
-    KLDRDYLDMOD_ASSERT(pMod->cRefs >= pMod->cDepRefs + pMod->cDynRefs);
-
-    /* decrement. */
-    if (pMod->cRefs > 0)
-        pMod->cRefs--;
-
-    /*
-     * Drop prerequisites for stats that implies that no recursion can have taken place yet.
-     * This ASSUMES that we're only dereferencing modules when an operation completes.
-     * (This is *required* for the reloaded state.)
-     */
+    KLDRDYLDMOD_ASSERT(pMod->enmState == KLDRSTATE_OPEN);
+    KLDRDYLDMOD_ASSERT(!pMod->fMapped);
+    if (pMod->fMapped)
+        return 0;
+
+    /* do the job. */
+    rc = kLdrModMap(pMod->pMod);
+    if (!rc)
+    {
+        pMod->fMapped = 1;
+        pMod->enmState = KLDRSTATE_MAPPED;
+    }
+    return rc;
+}
+
+
+/**
+ * Unmaps the module, unlinks it from everywhere marks it PENDING_DESTROY.
+ *
+ * @returns 0 on success, non-zero native OS or kLdr status code on failure.
+ * @param   pMod    The module which needs to be unmapped and set pending for destruction.
+ */
+int kldrDyldModUnmap(PKLDRDYLDMOD pMod)
+{
+    int rc;
+
+    /* sanity */
+    KLDRDYLDMOD_ASSERT(pMod->cRefs > 0);
+    KLDRDYLDMOD_ASSERT(pMod->fMapped);
     switch (pMod->enmState)
     {
         case KLDRSTATE_MAPPED:
-        case KLDRSTATE_LOADED_PREREQUISITES:
-        case KLDRSTATE_FIXED_UP:
-        case KLDRSTATE_RELOADED:
-            kldrDyldModUnloadPrerequisites(pMod);
-            pMod->enmState = KLDRSTATE_PENDING_GC;
-            break;
-
-        case KLDRSTATE_PENDING_INITIALIZATION:
-        case KLDRSTATE_INITIALIZING:
-        case KLDRSTATE_GOOD:
-        case KLDRSTATE_PENDING_TERMINATION:
-        case KLDRSTATE_TERMINATING:
-        case KLDRSTATE_PENDING_GC:
         case KLDRSTATE_GC:
         case KLDRSTATE_PENDING_DESTROY:
             break;
-
         default:
-            KLDRDYLDMOD_ASSERT(!"Invalid deref state");
-            break;
-    }
-
-    /*
-     * Also drop prerequisites if noone is referencing the module.
-     */
-    if (!pMod->cDepRefs && !pMod->cDynRefs)
-    {
-        switch (pMod->enmState)
+            KLDRDYLDMOD_ASSERT(!"invalid state");
+            return -1;
+    }
+
+    /* do the job. */
+    rc = kLdrModUnmap(pMod->pMod);
+    if (!rc)
+    {
+        pMod->fMapped = 0;
+        if (pMod->enmState < KLDRSTATE_PENDING_DESTROY)
         {
-            case KLDRSTATE_MAPPED:
-            case KLDRSTATE_LOADED_PREREQUISITES:
-            case KLDRSTATE_FIXED_UP:
-            case KLDRSTATE_RELOADED:
-                /* already dropped. */
-                break;
-
-            case KLDRSTATE_PENDING_INITIALIZATION:
-                kldrDyldModUnloadPrerequisites(pMod);
-                pMod->enmState = KLDRSTATE_PENDING_GC;
-                break;
-
-            case KLDRSTATE_GOOD:
-                pMod->enmState = KLDRSTATE_PENDING_TERMINATION;
-            case KLDRSTATE_PENDING_TERMINATION:
-            case KLDRSTATE_PENDING_GC:
-                kldrDyldModUnloadPrerequisites(pMod);
-                break;
-
-            case KLDRSTATE_TERMINATING:
-            case KLDRSTATE_GC:
-            case KLDRSTATE_PENDING_DESTROY:
-                break;
-
-            default:
-                KLDRDYLDMOD_ASSERT(!"Invalid deref state (b)");
-                break;
+            pMod->enmState = KLDRSTATE_PENDING_DESTROY;
+            kldrDyldModUnlink(pMod);
         }
     }
-
-    /*
-     * If there are no references whatsoever now and the module
-     * is pending destruction, destroy it.
-     */
-    if (    !pMod->cRefs
-        &&  (   pMod->enmState == KLDRSTATE_PENDING_DESTROY
-             || pMod->enmState == KLDRSTATE_GC))
-        kldrDyldModDestroy(pMod);
-}
+    return rc;
+}
+
+
+/**
+ * Applies fixups to a module which prerequisistes has been
+ * successfully loaded.
+ *
+ * @returns 0 on success, non-zero native OS or kLdr status code on failure.
+ * @param   pMod    The module which needs to be unmapped and set pending for destruction.
+ */
+int kldrDyldModFixup(PKLDRDYLDMOD pMod)
+{
+    int rc;
+
+    /* sanity */
+    KLDRDYLDMOD_ASSERT(pMod->cRefs > 0);
+    KLDRDYLDMOD_ASSERT(     pMod->enmState == KLDRSTATE_LOADED_PREREQUISITES
+                       ||   pMod->enmState == KLDRSTATE_RELOADED_LOADED_PREREQUISITES);
+
+    /* do the job */
+    rc = kLdrModFixupMapping(pMod->pMod, NULL, NULL);/// @todo fixme.
+    if (!rc)
+        pMod->enmState = KLDRSTATE_FIXED_UP;
+    return rc;
+}
+
+
+int kldrDyldModCallInit(PKLDRDYLDMOD pMod);
+void kldrDyldModCallTerm(PKLDRDYLDMOD pMod);
+
+int kldrDyldModReload(PKLDRDYLDMOD pMod);
+int kldrDyldModAttachThread(PKLDRDYLDMOD pMod);
+int kldrDyldModDetachThread(PKLDRDYLDMOD pMod);
+int kldrDyldModGetStackInfo(PKLDRDYLDMOD pMod, void **ppvStack, size_t *pcbStack);
+int kldrDyldModStartExe(PKLDRDYLDMOD pMod);
+
+int kldrDyldModGetName(PKLDRDYLDMOD pMod, char *pszName, size_t cchName);
+int kldrDyldModGetFilename(PKLDRDYLDMOD pMod, char *pszFilename, size_t cchFilename);
+int kldrDyldModQuerySymbol(PKLDRDYLDMOD pMod, uint32_t uSymbolOrdinal, const char *pszSymbolName, uintptr_t *pValue, uint32_t *pfKind);
+
+

trunk/kLdr/kLdrInternal.h

@@ -201 +201 @@
     KLDRSTATE_PENDING_DESTROY,
 
-    /** The module has been destroyed and is no longer valid.
+    /** The module has been destroyed but not freed yet.
+     *
+     * This happens when a module ends up being destroyed when cRefs > 0. The
+     * module structure will be freed when cRefs reaches 0.
      *
      * Prev state: GC, PENDING_DESTROY
@@ -246 +249 @@
      * this module is already seen and shouldn't be processed again. */
     uint32_t            fAlreadySeen : 1;
+    /** Set if the module is currently mapped.
+     * This is used to avoid unnecessary calls to kLdrModUnmap during cleanup. */
+    uint32_t            fMapped : 1;
     /** Reserved for future use. */
-    uint32_t            fReserved : 27;
+    uint32_t            f26Reserved : 26;
     /** The load list linkage. */
     struct
@@ -312 +318 @@
 
 int kldrDyldModCreate(PKLDRRDR pRdr, PPKLDRDYLDMOD ppMod);
-int kldrDyldModDestroy(PKLDRDYLDMOD pMod);
-int kldrDyldModAddRef(PKLDRDYLDMOD pMod);
+void kldrDyldModDestroy(PKLDRDYLDMOD pMod);
+void kldrDyldModAddRef(PKLDRDYLDMOD pMod);
 void kldrDyldModDeref(PKLDRDYLDMOD pMod);
-int kldrDyldModAddDep(PKLDRDYLDMOD pMod, PKLDRDYLDMOD pDep);
+void kldrDyldModAddDep(PKLDRDYLDMOD pMod, PKLDRDYLDMOD pDep);
 void kldrDyldModRemoveDep(PKLDRDYLDMOD pMod, PKLDRDYLDMOD pDep);
 int kldrDyldModDynamicLoad(PKLDRDYLDMOD pMod);
 int kldrDyldModDynamicUnload(PKLDRDYLDMOD pMod);
-int kldrDyldModMarkGlobal(PKLDRDYLDMOD pMod);
-int kldrDyldModMarkSpecific(PKLDRDYLDMOD pMod);
-int kldrDyldModSetBindable(PKLDRDYLDMOD pMod);
-int kldrDyldModClearBindable(PKLDRDYLDMOD pMod);
-int kldrDyldModSetDeepBindable(PKLDRDYLDMOD pMod);
-int kldrDyldModClearDeepBindable(PKLDRDYLDMOD pMod);
+void kldrDyldModMarkGlobal(PKLDRDYLDMOD pMod);
+void kldrDyldModMarkSpecific(PKLDRDYLDMOD pMod);
+void kldrDyldModSetBindable(PKLDRDYLDMOD pMod, unsigned fDeep);
+void kldrDyldModClearBindable(PKLDRDYLDMOD pMod);
 int kldrDyldModMap(PKLDRDYLDMOD pMod);
 int kldrDyldModUnmap(PKLDRDYLDMOD pMod);
@@ -345 +349 @@
 
 
-int kldrDyldFailure(int rc, const char *pszFilename, ...);
+int kldrDyldFailure(int rc, const char *pszFormat, ...);
 int kldrInit(void);
 void kldrTerm(void);
@@ -356 +360 @@
  * (This is exported, so no prefix.) */
 extern PKLDRDYLDMOD     kLdrDyldTail;
+/** 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. */
+extern PKLDRDYLDMOD     g_pkLdrDyldInitHead;
+/** Pointer to the tail module of the initalization list. */
+extern PKLDRDYLDMOD     g_pkLdrDyldInitTail;
 /** Pointer to the head module of the termination order list. */
 extern PKLDRDYLDMOD     g_pkLdrDyldTermHead;