Changeset 2847 for trunk/kLdr

Timestamp:

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

Author:

bird

Message:

Roughly done with kldrDyldMod now.

Location:

trunk/kLdr

Files:

• kLdr.h (modified) (3 diffs)
• kLdrDyld.c (modified) (1 diff)
• kLdrDyldMod.c (modified) (9 diffs)
• kLdrHlp.h (modified) (1 diff)
• kLdrHlpHeap.c (modified) (1 diff)
• kLdrInternal.h (modified) (1 diff)

trunk/kLdr/kLdr.h

@@ -551 +551 @@
                                uintmax_t *pValue, uint32_t *pfKind, void *pvModuleUser, void *pvUser);
 typedef FNKLDRMODGETIMPORT *PFNKLDRMODGETIMPORT;
-typedef int FNKLDRMODENUMIMPMODS(PKLDRMOD pMod, const char *pszImpMod, unsigned fFlags, void *pvUser);
-typedef FNKLDRMODENUMIMPMODS *PFNKLDRMODENUMIMPMODS;
 typedef int FNKLDRMODENUMSYMS(PKLDRMOD pMod, const char *pszSymbol, unsigned uSymbol, uintmax_t Value, uint32_t fKind, void *pvUser);
 typedef FNKLDRMODENUMSYMS *PFNKLDRMODENUMSYMS;
@@ -562 +560 @@
 int     kLdrModQuerySymbol(PKLDRMOD pMod, const void *pvBits, uintmax_t BaseAddress, const char *pszSymbol, uintmax_t *pValue, uint32_t *pfKind);
 int     kLdrModEnumSymbols(PKLDRMOD pMod, unsigned fFlags, const void *pvBits, uintmax_t BaseAddress, PFNKLDRMODENUMSYMS pfnCallback, void *pvUser);
-int     kLdrModEnumImportModules(PKLDRMOD pMod, unsigned fFlags, const void *pvBits, FNKLDRMODENUMIMPMODS pfnCallback, void *pvUser);
+int     kLdrModGetImport(PKLDRMOD pMod, uint32_t iImport, const char *pszName, size_t cchName);
+int32_t kLdrModNumberOfImports(PKLDRMOD pMod);
 int     kLdrModMap(PKLDRMOD pMod);
 int     kLdrModUnmap(PKLDRMOD pMod);
@@ -573 +572 @@
 int     kLdrModQueryMainEntrypoint(PKLDRMOD pMod, void *pvBits, uintmax_t uBaseAddress, uintmax_t *puValue);
 int     kLdrModAllocTLS(PKLDRMOD pMod);
-int     kLdrModFreeTLS(PKLDRMOD pMod);
+void    kLdrModFreeTLS(PKLDRMOD pMod);
 int     kLdrModReload(PKLDRMOD pMod);
 int     kLdrModCallInit(PKLDRMOD pMod);

trunk/kLdr/kLdrDyld.c

@@ -754 +754 @@
  * @returns 0 on success, non-zero error code on failure.
  * @param   pMod            The module to start at.
- * @param   pszPrefix    Prefix to use when searching.
- * @param   pszSuffix    Suffix to use when searching.
+ * @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.

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;
         }
     }

trunk/kLdr/kLdrHlp.h

@@ -143 +143 @@
 void    kldrHlpHeapDonate(void *pv, size_t cb);
 void *  kldrHlpAlloc(size_t cb);
+void *  kldrHlpAllocZ(size_t cb);
 void    kldrHlpFree(void *pv);
 

trunk/kLdr/kLdrHlpHeap.c

@@ -217 +217 @@
 {
     return kLdrHeapAlloc(&g_Heap, cb);
+}
+
+
+/**
+ * Allocates zero initialized memory from the kLdr heap.
+ *
+ * @returns Pointer to the allocated heap block. NULL if we can't satify the request.
+ * @param   cb      The requested heap block size.
+ */
+void *kldrHlpAllocZ(size_t cb)
+{
+    void *pv = kLdrHeapAlloc(&g_Heap, cb);
+    if (pv)
+        kLdrHlpMemSet(pv, 0, cb);
+    return pv;
 }
 

trunk/kLdr/kLdrInternal.h

@@ -318 +318 @@
                                KLDRDYLDSEARCH enmSearch, unsigned fFlags, PPKLDRDYLDMOD ppMod);
 
+int kldrDyldGetPrerequisite(const char *pszDll, const char *pszPrefix, const char *pszSuffix, KLDRDYLDSEARCH enmSearch,
+                            unsigned fFlags, PKLDRDYLDMOD pDep, PPKLDRDYLDMOD ppMod);
+
 
 int kldrDyldModCreate(PKLDRRDR pRdr, PPKLDRDYLDMOD ppMod);