Changeset 2847 for trunk/kLdr/kLdrDyldMod.c

Timestamp:

Nov 1, 2006, 8:17:21 PM (19 years ago)

Author:

bird

Message:

Roughly done with kldrDyldMod now.

File:

• trunk/kLdr/kLdrDyldMod.c (modified) (9 diffs)

trunk/kLdr/kLdrDyldMod.c

@@ -50 +50 @@
 # define KLDRDYLDMOD_ASSERT(expr)  do {} while (0)
 #endif
+
+/*******************************************************************************
+*   Internal Functions                                                         *
+*******************************************************************************/
+static void kldrDyldModUnlink(PKLDRDYLDMOD pMod);
 
 
@@ -175 +180 @@
 void kldrDyldModDestroy(PKLDRDYLDMOD pMod)
 {
+    int rc;
+
     /*
      * Validate the state.
@@ -191 +198 @@
     KLDRDYLDMOD_ASSERT(!pMod->cDepRefs);
 
-
     /*
      * Ensure that the module is unmapped.
      */
+    if (pMod->fAllocatedTLS)
+    {
+        kLdrModFreeTLS(pMod->pMod);
+        pMod->fAllocatedTLS = 0;
+    }
     if (pMod->fMapped)
-        kldrDyldModUnmap(pMod);
+    {
+        rc = kLdrModUnmap(pMod->pMod); KLDRDYLDMOD_ASSERT(!rc);
+        pMod->fMapped = 0;
+    }
+
+    /*
+     * Ensure it's unlinked from all chains.
+     */
+    if (pMod->enmState < KLDRSTATE_PENDING_DESTROY)
+        kldrDyldModUnlink(pMod);
+
+    /*
+     * Free everything associated with the module.
+     */
+    /* the prerequisite array. */
+    if (pMod->papPrereqs)
+    {
+        uint32_t i = pMod->cPrereqs;
+        while (i-- > 0)
+        {
+            KLDRDYLDMOD_ASSERT(pMod->papPrereqs[i] == NULL);
+            pMod->papPrereqs[i] = NULL;
+        }
+
+        kldrHlpFree(pMod->papPrereqs);
+        pMod->papPrereqs = NULL;
+        pMod->cPrereqs = 0;
+    }
+
+    /* the module interpreter.  */
+    if (pMod->pMod)
+    {
+        rc = kLdrModClose(pMod->pMod); KLDRDYLDMOD_ASSERT(!rc);
+        pMod->pMod = NULL;
+    }
+
+
+    /*
+     * Finally, change the module state and free the module if
+     * there are not more references to it. If somebody is still
+     * referencing it, postpone the freeing to Deref.
+     */
+    pMod->enmState = KLDRSTATE_DESTROYED;
+    if (!pMod->cRefs)
+    {
+        pMod->u32MagicHead = 1;
+        pMod->u32MagicTail = 2;
+        kldrHlpFree(pMod);
+    }
 }
 
@@ -377 +436 @@
     if (    pMod->enmState == KLDRSTATE_DESTROYED
         &&  !pMod->cRefs)
+    {
+        pMod->u32MagicHead = 1;
+        pMod->u32MagicTail = 2;
         kldrHlpFree(pMod);
+    }
 }
 
@@ -511 +574 @@
         if (pMod2)
         {
+            pMod->papPrereqs[i] = NULL;
+
             /* do the derefering ourselves or we'll end up in a recursive loop here. */
             KLDRDYLDMOD_ASSERT(pMod2->cDepRefs > 0);
@@ -603 +668 @@
 
 
+/**
+ * Loads the prerequisite modules this module depends on.
+ *
+ * To find each of the prerequisite modules this method calls
+ * kldrDyldGetPrerequisite() and it will make sure the modules
+ * are added to the load stack frame.
+ *
+ * @returns 0 on success, non-zero native OS or kLdr status code on failure.
+ *          The state is changed to LOADED_PREREQUISITES or RELOADED_LOADED_PREREQUISITES.
+ * @param   pMod            The module.
+ * @param   pszPrefix       Prefix to use when searching.
+ * @param   pszSuffix       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.
+ */
 int kldrDyldModLoadPrerequisites(PKLDRDYLDMOD pMod, const char *pszPrefix, const char *pszSuffix,
                                  KLDRDYLDSEARCH enmSearch, unsigned fFlags)
 {
-
-    return -1;
-}
-
-
-int kldrDyldModCheckPrerequisites(PKLDRDYLDMOD pMod)
-{
-    return -1;
+    int32_t     cPrereqs;
+    uint32_t    i;
+    int         rc = 0;
+
+    /* sanity */
+    switch (pMod->enmState)
+    {
+        case KLDRSTATE_MAPPED:
+        case KLDRSTATE_RELOADED:
+            break;
+        default:
+            KLDRDYLDMOD_ASSERT(!"invalid state");
+            return -1;
+    }
+
+    /*
+     * Query number of prerequiste modules and allocate the array.
+     */
+    cPrereqs = kLdrModNumberOfImports(pMod->pMod);
+    kldrHlpAssert(cPrereqs >= 0);
+    if (pMod->cPrereqs != cPrereqs)
+    {
+        KLDRDYLDMOD_ASSERT(!pMod->papPrereqs);
+        pMod->papPrereqs = (PPKLDRDYLDMOD)kldrHlpAllocZ(sizeof(pMod->papPrereqs[0]) * cPrereqs);
+        if (!pMod->papPrereqs)
+            return KLDR_ERR_NO_MEMORY;
+        pMod->cPrereqs = cPrereqs;
+    }
+    else
+        KLDRDYLDMOD_ASSERT(pMod->papPrereqs || !pMod->cPrereqs);
+
+    /*
+     * Iterate the prerequisites and load them.
+     */
+    for (i = 0; i < pMod->cPrereqs; i++)
+    {
+        static char s_szPrereq[260];
+        PKLDRDYLDMOD pPrereqMod;
+
+        KLDRDYLDMOD_ASSERT(pMod->papPrereqs[i] == NULL);
+        rc = kLdrModGetImport(pMod->pMod, i, s_szPrereq, sizeof(s_szPrereq));
+        if (rc)
+            break;
+        rc = kldrDyldGetPrerequisite(s_szPrereq, pszPrefix, pszSuffix, enmSearch, fFlags, pMod, &pPrereqMod);
+        if (rc)
+            break;
+        pMod->papPrereqs[i] = pPrereqMod;
+    }
+
+    /* change the state regardless of what happend. */
+    if (pMod->enmState == KLDRSTATE_MAPPED)
+        pMod->enmState = KLDRSTATE_LOADED_PREREQUISITES;
+    else
+        pMod->enmState = KLDRSTATE_RELOADED_LOADED_PREREQUISITES;
+    return rc;
 }
 
@@ -679 +806 @@
 
     /* do the job. */
-    rc = kLdrModFreeTLS(pMod->pMod);
+    if (pMod->fAllocatedTLS)
+    {
+        kLdrModFreeTLS(pMod->pMod);
+        pMod->fAllocatedTLS = 0;
+    }
+    rc = kLdrModUnmap(pMod->pMod);
     if (!rc)
     {
-        rc = kLdrModUnmap(pMod->pMod);
-        if (!rc)
+        pMod->fMapped = 0;
+        if (pMod->enmState < KLDRSTATE_PENDING_DESTROY)
         {
-            pMod->fMapped = 0;
-            if (pMod->enmState < KLDRSTATE_PENDING_DESTROY)
-            {
-                pMod->enmState = KLDRSTATE_PENDING_DESTROY;
-                kldrDyldModUnlink(pMod);
-            }
+            pMod->enmState = KLDRSTATE_PENDING_DESTROY;
+            kldrDyldModUnlink(pMod);
         }
-        else
-            kLdrModAllocTLS(pMod->pMod);
-    }
+    }
+
     return rc;
 }
@@ -716 +843 @@
     KLDRDYLDMOD_ASSERT(pMod->cRefs > 0);
     KLDRDYLDMOD_ASSERT(pMod->fMapped);
-    KLDRDYLDMOD_ASSERT(pMod->fAllocatedTLS);
 
     switch (pMod->enmState)
@@ -729 +855 @@
     }
 
+    /* Free TLS before reloading. */
+    if (pMod->fAllocatedTLS)
+    {
+        kLdrModFreeTLS(pMod->pMod);
+        pMod->fAllocatedTLS = 0;
+    }
+
     /* Let the module interpreter do the reloading of the mapping. */
     rc = kLdrModReload(pMod->pMod);
     if (!rc)
     {
-        /* Free and allocate the TLS anew to ensure we get clean entries. */
-        if (pMod->fAllocatedTLS)
-            rc = kLdrModFreeTLS(pMod->pMod);
+        rc = kLdrModAllocTLS(pMod->pMod);
         if (!rc)
         {
-            pMod->fAllocatedTLS = 0;
-            rc = kLdrModAllocTLS(pMod->pMod);
-            if (!rc)
-            {
-                pMod->fAllocatedTLS = 1;
-                pMod->enmState = KLDRSTATE_RELOADED;
-            }
+            pMod->fAllocatedTLS = 1;
+            pMod->enmState = KLDRSTATE_RELOADED;
         }
     }