Changeset 2836

Timestamp:

Oct 26, 2006, 5:58:53 AM (19 years ago)

Author:

bird

Message:

more prototyping. (And avoid 64-bit div/rem)

Location:

trunk/kLdr

Files:

• Makefile.kmk (modified) (1 diff)
• kLdr.h (modified) (5 diffs)
• kLdrDyld.c (moved) (moved from trunk/kLdr/kLdrDy.c ) (20 diffs)
• kLdrDyldFind.c (moved) (moved from trunk/kLdr/kLdrDySearch.c ) (2 diffs)
• kLdrHlp.c (modified) (2 diffs)
• kLdrHlp.h (modified) (1 diff)
• kLdrInternal.h (modified) (5 diffs)

trunk/kLdr/Makefile.kmk

@@ -91 +91 @@
 kLdr_SOURCES = \
         kLdr.c \
-        kLdrDy.c \
+        kLdrDyld.c \
+        kLdrDyldFind.c \
         kLdrDyldMod.c \
-        kLdrDySearch.c \
         kLdrHlp.c \
         kLdrHlpHeap.c \

trunk/kLdr/kLdr.h

@@ -44 +44 @@
 typedef signed __int64      int64_t;
 typedef unsigned __int64    uint64_t;
+typedef int64_t             intmax_t;
 typedef uint64_t            uintmax_t;
 #else
@@ -287 +288 @@
     const char     *pszName;
     /** The size of the segment. */
-    size_t          cb;
+    uintmax_t       cb;
     /** The link time load address. */
-    void           *pvLink;
+    uintmax_t       LinkAddress;
     /** The actual load address (if loaded). */
-    void           *pv;
+    uintmax_t       LoadAddress;
     /** The segment protection. */
     KLDRPROT        enmProt;
@@ -609 +610 @@
 } KLDRDYLDSEARCH;
 
-/** @name kLdrLoadDll flags.
+/** @name kLdrDyldLoad and kLdrDyldFindByName flags.
  * @{ */
 /** The symbols in the module should be loaded into the global unix namespace.
@@ -625 +626 @@
                      unsigned fFlags, PHKLDRMOD phMod, char *pszErr, size_t cchErr);
 int     kLdrDyldUnload(HKLDRMOD hMod);
-int     kLdrDyldFindByName(const char *pszDll, const char *pszDefPrefix, const char *pszDefSuffix, KLDRDYLDSEARCH enmSearch, PHKLDRMOD phMod);
+int     kLdrDyldFindByName(const char *pszDll, const char *pszDefPrefix, const char *pszDefSuffix, KLDRDYLDSEARCH enmSearch,
+                           unsigned fFlags, PHKLDRMOD phMod);
 int     kLdrDyldFindByAddress(uintptr_t Address, PHKLDRMOD phMod, uint32_t *piSegment, uintptr_t *poffSegment);
 int     kLdrDyldGetName(HKLDRMOD hMod, char *pszName, size_t cchName);
@@ -728 +730 @@
 /** Invalid handle parameter to a kLdr API. */
 #define KLDR_ERR_INVALID_HANDLE         (KLDR_ERR_BASE + 33)
+/** The module wasn't found. */
+#define KLDR_ERR_MODULE_NOT_FOUND       (KLDR_ERR_BASE + 34)
 
 /** Encountered a bad fixup. */

trunk/kLdr/kLdrDyld.c

@@ -32 +32 @@
 #include "kLdrHlp.h"
 #include "kLdrInternal.h"
+
+
+/*******************************************************************************
+*   Defined Constants And Macros                                               *
+*******************************************************************************/
+/** @def KLDRDYLD_STRICT
+ * Define KLDRDYLD_STRICT to enabled strict checks in kLdrDyld. */
+#define KLDRDYLD_STRICT 1
+
+/** @def KLDRDYLD_ASSERT
+ * Assert that an expression is true when KLDRDYLD_STRICT is defined.
+ */
+#ifdef KLDRDYLD_STRICT
+# define KLDRDYLD_ASSERT(expr)  kldrHlpAssert(expr)
+#else
+# define KLDRDYLD_ASSERT(expr)  do {} while (0)
+#endif
 
 
@@ -43 +60 @@
  * (This is exported, so no prefix.) */
 PKLDRDYLDMOD    kLdrDyldTail = NULL;
+/** Pointer to the head module of the termination order list. */
+PKLDRDYLDMOD    g_pkLdrDyldTermHead;
+/** Pointer to the tail module of the termination order list. */
+PKLDRDYLDMOD    g_pkLdrDyldTermTail;
+/** Pointer to the head module of the bind order list.
+ * The modules in this list makes up the global namespace used when binding symbol unix fashion. */
+PKLDRDYLDMOD    g_pkLdrDyldBindHead;
+/** Pointer to the tail module of the bind order list. */
+PKLDRDYLDMOD    g_pkLdrDyldBindTail;
+
+/** Stack of modules involved in the active loads.
+ *
+ * The main purpose is to allow module init routines to loading and unloading
+ * modules without upsetting the init order and to assist in dereferencing
+ * modules on load failure.
+ *
+ * Each call to kLdrDyldLoad and kLdrDyldLoadExe will start a load frame
+ * when doing a fresh load. All dependant modules will be pushed on each
+ * reference. The frame is completed when all the dependant modules has
+ * been resolved (or a failure occurs). After doing fixups, the frame is
+ * used to do module initialization. Should an error occur during the load
+ * the frame will be used to dereference all the modules involved in the
+ * load operation (it will not however, be used for termination calls as
+ * they are postponed till the last load operation completes).
+ *
+ * Should any of the init calls load a module, a new frame will be created
+ * for that operation and processed before the init call returns to the
+ * previous frame.
+ */
+PPKLDRDYLDMOD   g_pakLdrDyld;
+/** The number of used entries in the g_pakLdrDyld array. */
+uint32_t        g_ckLdrDyld;
+/** The number of entries allocated for the g_pakLdrDyld array. */
+uint32_t        g_ckLdrDyldAllocated;
+
+/** The global error buffer. */
+char            g_szkLdrDyldError[1024];
+
 /** The Library search path. */
 char            kLdrDyldLibraryPath[4096];
@@ -52 +107 @@
 *   Internal Functions                                                         *
 *******************************************************************************/
-static int kldrDyldLoad(const char *pszDll, const char *pszDefPrefix, const char *pszDefSuffix, KLDRDYLDSEARCH enmSearch,
-                        unsigned fFlags, PPKLDRDYLDMOD ppMod, char *pszErr, size_t cchErr);
-static int kldrDyldUnload(PKLDRDYLDMOD pMod);
-static int kldrDyldFindByName(const char *pszDll, const char *pszDefPrefix, const char *pszDefSuffix, KLDRDYLDSEARCH enmSearch, PPKLDRDYLDMOD ppMod);
-static int kldrDyldFindByAddress(uintptr_t Address, PPKLDRDYLDMOD ppMod, uint32_t *piSegment, uintptr_t *poffSegment);
-static int kldrDyldGetName(PKLDRDYLDMOD pMod, char *pszName, size_t cchName);
-static int kldrDyldGetFilename(PKLDRDYLDMOD pMod, char *pszFilename, size_t cchFilename);
-static int kldrDyldQuerySymbol(PKLDRDYLDMOD pMod, uint32_t uSymbolOrdinal, const char *pszSymbolName, uintptr_t *pValue, uint32_t *pfKind);
+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 kldrDyldDoUnload(PKLDRDYLDMOD pMod);
+static int kldrDyldDoFindByName(const char *pszDll, const char *pszDefPrefix, const char *pszDefSuffix, KLDRDYLDSEARCH enmSearch,
+                              unsigned fFlags, PPKLDRDYLDMOD ppMod);
+static int kldrDyldDoFindByAddress(uintptr_t Address, PPKLDRDYLDMOD ppMod, uint32_t *piSegment, uintptr_t *poffSegment);
+static int kldrDyldDoGetName(PKLDRDYLDMOD pMod, char *pszName, size_t cchName);
+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 kldrDyldStartLoading(void);
+static void kldrDyldStopLoading(void);
+static int kldrDyldCopyError(int rc, char *pszErr, size_t cchErr);
 
 
@@ -68 +127 @@
 int kldrDyInit(void)
 {
-    kLdrDyldHead = NULL;
-    kLdrDyldTail = NULL;
+    kLdrDyldHead = kLdrDyldTail = NULL;
+    g_pkLdrDyldTermHead = g_pkLdrDyldTermTail = NULL;
+    g_pkLdrDyldBindHead = g_pkLdrDyldBindTail = NULL;
     kLdrDyldFlags = 0;
+    g_szkLdrDyldError[0] = '\0';
     return 0;
 }
@@ -117 +178 @@
     {
         PKLDRDYLDMOD pMod = NULL;
-        rc = kldrDyldLoad(pszDll, pszDefPrefix, pszDefSuffix, enmSearch, fFlags, phMod, pszErr, cchErr);
+        rc = kldrDyldDoLoad(pszDll, pszDefPrefix, pszDefSuffix, enmSearch, fFlags, phMod, pszErr, cchErr);
         kldrHlpSemRelease();
         *phMod = pMod;
@@ -142 +203 @@
     if (!rc)
     {
-        rc = kldrDyldUnload(hMod);
+        rc = kldrDyldDoUnload(hMod);
         kldrHlpSemRelease();
     }
@@ -158 +219 @@
  * @returns KLDR_ERR_MODULE_NOT_FOUND on failure.
  * @param   pszDll          The name of the dll to look for.
- * @param   pszDefPrefix    Prefix to use when searching.
- * @param   pszDefSuffix    Suffix to use when searching.
+ * @param   pszDefPrefix    Prefix than can be used when searching.
+ * @param   pszDefSuffix    Suffix than can be used when searching.
  * @param   enmSearch       Method to use when locating the module.
+ * @param   fFlags          Flags, a combintation of the KLDRYDLD_LOAD_FLAGS_* \#defines.
  * @param   phMod           Where to store the handle of the module on success.
  */
-int     kLdrDyldFindByName(const char *pszDll, const char *pszDefPrefix, const char *pszDefSuffix, KLDRDYLDSEARCH enmSearch, PHKLDRMOD phMod)
+int     kLdrDyldFindByName(const char *pszDll, const char *pszDefPrefix, const char *pszDefSuffix, KLDRDYLDSEARCH enmSearch,
+                           unsigned fFlags, PHKLDRMOD phMod)
 {
     int rc;
@@ -176 +239 @@
     {
         PKLDRDYLDMOD pMod = NULL;
-        rc = kldrDyldFindByName(pszDll, pszDefPrefix, pszDefSuffix, enmSearch, phMod);
+        rc = kldrDyldDoFindByName(pszDll, pszDefPrefix, pszDefSuffix, enmSearch, fFlags, phMod);
         kldrHlpSemRelease();
         *phMod = pMod;
@@ -213 +276 @@
     {
         PKLDRDYLDMOD pMod = NULL;
-        rc = kldrDyldFindByAddress(Address, &pMod, piSegment, poffSegment);
+        rc = kldrDyldDoFindByAddress(Address, &pMod, piSegment, poffSegment);
         kldrHlpSemRelease();
         *phMod = pMod;
@@ -245 +308 @@
     if (!rc)
     {
-        rc = kldrDyldGetName(hMod, pszName, cchName);
+        rc = kldrDyldDoGetName(hMod, pszName, cchName);
         kldrHlpSemRelease();
     }
@@ -276 +339 @@
     if (!rc)
     {
-        rc = kldrDyldGetFilename(hMod, pszFilename, cchFilename);
+        rc = kldrDyldDoGetFilename(hMod, pszFilename, cchFilename);
         kldrHlpSemRelease();
     }
@@ -312 +375 @@
     if (!rc)
     {
-        rc = kldrDyldQuerySymbol(hMod, uSymbolOrdinal, pszSymbolName, pValue, pfKind);
+        rc = kldrDyldDoQuerySymbol(hMod, uSymbolOrdinal, pszSymbolName, pValue, pfKind);
         kldrHlpSemRelease();
     }
@@ -322 +385 @@
 
 
-
-/**
- * Worker for kldrDyldLoad().
+/**
+ * Worker for kLdrDyldLoad().
  * @internal
  */
-static int kldrDyldLoad(const char *pszDll, const char *pszDefPrefix, const char *pszDefSuffix, KLDRDYLDSEARCH enmSearch,
-                        unsigned fFlags, PPKLDRDYLDMOD ppMod, char *pszErr, size_t cchErr)
-{
-    /*
-     * Open the module.
-     */
-
-
-    return -1;
-}
-
-
-/**
- * Worker for kldrDyldUnload().
+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 it among the modules that's already loaded.
+     */
+    rc = kldrDyldFindExistingModule(pszDll, pszDefPrefix, pszDefSuffix, enmSearch, fFlags, ppMod);
+    if (!rc)
+    {
+        /*
+         * If we're in a module termination call we must check that all the modules we
+         * depend on are loaded and initialized.
+         */
+//continue here        if ((*ppMod)->enmState::KLDRSTATE_LOADED)
+        {
+            kldrHlpAssert(!"implement me");
+        }
+        return kldrDyldModDynamicLoad(*ppMod);
+    }
+
+    /*
+     * Try open it.
+     */
+    kldrDyldStartLoading();
+    rc = kldrDyldFindNewModule(pszDll, pszDefPrefix, pszDefSuffix, enmSearch, fFlags, ppMod);
+    if (!rc)
+    {
+
+
+    }
+    return kldrDyldCopyError(rc, pszErr, cchErr);
+}
+
+
+/**
+ * Worker for kLdrDyldUnload().
  * @internal
  */
-static int kldrDyldUnload(HKLDRMOD hMod)
-{
-    return -1;
+static int kldrDyldDoUnload(PKLDRDYLDMOD pMod)
+{
+    return kldrDyldModDynamicUnload(pMod);
 }
 
@@ -353 +439 @@
  * @internal
  */
-static int kldrDyldFindByName(const char *pszDll, const char *pszDefPrefix, const char *pszDefSuffix, KLDRDYLDSEARCH enmSearch, PPKLDRDYLDMOD ppMod)
-{
-    return -1;
+static int kldrDyldDoFindByName(const char *pszDll, const char *pszDefPrefix, const char *pszDefSuffix, KLDRDYLDSEARCH enmSearch,
+                                unsigned fFlags, PPKLDRDYLDMOD ppMod)
+{
+    return kldrDyldFindExistingModule(pszDll, pszDefPrefix, pszDefSuffix, enmSearch, fFlags, ppMod);
 }
 
@@ -363 +450 @@
  * @internal
  */
-static int kldrDyldFindByAddress(uintptr_t Address, PPKLDRDYLDMOD ppMod, uint32_t *piSegment, uintptr_t *poffSegment)
-{
-    return -1;
+static int kldrDyldDoFindByAddress(uintptr_t Address, PPKLDRDYLDMOD ppMod, uint32_t *piSegment, uintptr_t *poffSegment)
+{
+    /* Scan the segments of each module in the load list. */
+    PKLDRDYLDMOD pMod = kLdrDyldHead;
+    while (pMod)
+    {
+        uint32_t iSeg;
+        for (iSeg = 0; iSeg < pMod->pMod->cSegments; iSeg++)
+        {
+            uintmax_t off = (uintmax_t)Address - pMod->pMod->aSegments[iSeg].LoadAddress;
+            if (off < pMod->pMod->aSegments[iSeg].cb)
+            {
+                *ppMod = pMod->hMod;
+                if (piSegment)
+                    *piSegment = iSeg;
+                if (poffSegment)
+                    *poffSegment = (uintptr_t)off;
+                return 0;
+            }
+        }
+
+        /* next */
+        pMod = pMod->Load.pNext;
+    }
+
+    return KLDR_ERR_MODULE_NOT_FOUND;
 }
 
@@ -373 +483 @@
  * @internal
  */
-static int kldrDyldGetName(PKLDRDYLDMOD pMod, char *pszName, size_t cchName)
-{
-    return -1;
+static int kldrDyldDoGetName(PKLDRDYLDMOD pMod, char *pszName, size_t cchName)
+{
+    return kldrDyldModGetName(pMod, pszName, cchName);
 }
 
@@ -383 +493 @@
  * @internal
  */
-static int kldrDyldGetFilename(PKLDRDYLDMOD pMod, char *pszFilename, size_t cchFilename)
-{
-    return -1;
+static int kldrDyldDoGetFilename(PKLDRDYLDMOD pMod, char *pszFilename, size_t cchFilename)
+{
+    return kldrDyldModGetFilename(pMod, pszFilename, cchFilename);
 }
 
@@ -393 +503 @@
  * @internal
  */
-static int kldrDyldQuerySymbol(PKLDRDYLDMOD pMod, uint32_t uSymbolOrdinal, const char *pszSymbolName, uintptr_t *pValue, uint32_t *pfKind)
-{
-    return -1;
+static int kldrDyldDoQuerySymbol(PKLDRDYLDMOD pMod, uint32_t uSymbolOrdinal, const char *pszSymbolName, uintptr_t *pValue, uint32_t *pfKind)
+{
+    return kldrDyldModQuerySymbol(pMod, uSymbolOrdinal, pszSymbolName, pValue, pfKind);
 }
 
@@ -482 +592 @@
 }
 
+#endif
+
+/**
+ * Starts loading a new module and its dependencies.
+ */
+static void kldrDyldStartLoading(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
+}
+
+
+/**
+ * Records the loading of 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 kldrDyldRecord(PKLDRDYLDMOD pMod)
+{
+
+}
+
+
+
+/**
+ * Done loading a module and its dependencies.
+ *
+ * If the load failed, unload all the modules involved.
+ * If the load succeeded,
+ *
+ * @returns rc.
+ * @param   rc  The status code.
+ */
+static void kldrDyldDoneLoading(int rc)
+{
+
+}
+
+
 
 /**
@@ -493 +652 @@
 int kldrFailure(int rc, const char *pszFormat, ...)
 {
-    kldrExit(1);
-    return rc;
-}
-
-#endif
-
+    kldrHlpExit(1);
+    return rc;
+}
+
+
+/**
+ * Copies the error string to the user buffer.
+ *
+ * @returns rc.
+ * @param   rc      The status code.
+ * @param   pszErr  Where to copy the error string to.
+ * @param   cchErr  The size of the destination buffer.
+ */
+static int kldrDyldCopyError(int rc, char *pszErr, size_t cchErr)
+{
+    size_t cchToCopy;
+
+    /* if no error string, format the rc into a string. */
+    if (!g_szkLdrDyldError[0] && rc)
+        kldrHlpInt2Ascii(g_szkLdrDyldError, sizeof(g_szkLdrDyldError), rc, 10);
+
+    /* copy it if we got something. */
+    if (cchErr && pszErr && g_szkLdrDyldError[0])
+    {
+        cchToCopy = kLdrHlpStrLen(g_szkLdrDyldError);
+        if (cchToCopy >= cchErr)
+            cchToCopy = cchErr - 1;
+        kLdrHlpMemCopy(pszErr, g_szkLdrDyldError, cchToCopy);
+        pszErr[cchToCopy] = '\0';
+    }
+
+    return rc;
+}
+

trunk/kLdr/kLdrDyldFind.c

@@ -41 +41 @@
  *
  * @param   pszName         Partial or complete name, it's specific to the search method to determin which.
- * @param   pszPrefix       Prefix that might be used (that's method specific).
- * @param   pszSuffix       Suffix that can be applied to an incomplete name.
+ * @param   pszDefPrefix    Prefix than can be used when searching.
+ * @param   pszDefSuffix    Suffix than can be used when searching.
  * @param   enmSearch       The file search method to apply.
  * @param   fFlags          Search flags.
@@ -61 +61 @@
  *
  * @param   pszName         Partial or complete name, it's specific to the search method to determin which.
- * @param   pszPrefix       Prefix that might be used (that's method specific).
- * @param   pszSuffix       Suffix that can be applied to an incomplete name.
+ * @param   pszDefPrefix    Prefix than can be used when searching.
+ * @param   pszDefSuffix    Suffix than can be used when searching.
  * @param   enmSearch       The file search method to apply.
  * @param   fFlags          Search flags.

trunk/kLdr/kLdrHlp.c

@@ -494 +494 @@
 
 
-/** Internal worker for kldrHlpAssertMsg. */
-static void int2dec(char *pszLine, unsigned iLine)
-{
-    do
-    {
-        *pszLine = (iLine % 10) + '0';
-        iLine /= 10;
-    } while (iLine);
-    *pszLine++ = '\0';
+/**
+ * Converts an signed integer to an ascii string.
+ *
+ * @returns psz.
+ * @param   psz         Pointer to the output buffer.
+ * @param   cch         The size of the output buffer.
+ * @param   lVal        The value.
+ * @param   iBase       The base to format it. (2,8,10 or 16)
+ */
+char *kldrHlpInt2Ascii(char *psz, size_t cch, long lVal, unsigned iBase)
+{
+    static const char s_szDigits[] = "0123456789abcdefghijklmnopqrstuvwxyz";
+    char *pszRet = psz;
+
+    if (cch >= (lVal < 0 ? 3U : 2U) && psz)
+    {
+        /* prefix */
+        if (lVal < 0)
+        {
+            *psz++ = '-';
+            cch--;
+            lVal = -lVal;
+        }
+
+        /* the digits */
+        do
+        {
+            *psz++ = s_szDigits[lVal % iBase];
+            cch--;
+            lVal /= iBase;
+        } while (lVal && cch > 1);
+
+        /* overflow indicator */
+        if (lVal)
+            psz[-1] = '+';
+    }
+    else if (!pszRet)
+        return pszRet;
+    else if (cch < 1 || !pszRet)
+        return pszRet;
+    else
+        *psz++ = '+';
+    *psz = '\0';
+
+    return pszRet;
 }
 
@@ -574 +610 @@
     kldrHlpAssertWrite(pszFile);
     kldrHlpAssertWrite("(");
-    int2dec(szLine, iLine);
-    kldrHlpAssertWrite(szLine);
+    kldrHlpAssertWrite(kldrHlpInt2Ascii(szLine, sizeof(szLine), iLine, 10));
     kldrHlpAssertWrite(") ");
     kldrHlpAssertWrite(pszFunction);

trunk/kLdr/kLdrHlp.h

@@ -146 +146 @@
 void    kldrHlpExit(int rc);
 void    kldrHlpSleep(unsigned cMillies);
+char   *kldrHlpInt2Ascii(char *psz, size_t cch, long lVal, unsigned iBase);
 void    kldrHlpAssertMsg(const char *pszExpr, const char *pszFile, unsigned iLine, const char *pszFunction);
 

trunk/kLdr/kLdrInternal.h

@@ -70 +70 @@
     /** The usual invalid 0 enum. */
     KLDRSTATE_INVALID = 0,
-    /** kldrOpen succeeded.
-     * Modules in this state will be freed at  */
+    /** The module has just been opened and has no references.
+     * Prev state: -
+     * Next state: MAPPED, DESTROYED
+     */
     KLDRSTATE_OPEN,
-    /** Dependencies has been loaded. */
-    KLDRSTATE_DEPS,
-    /** Fixups has been applied. */
-    KLDRSTATE_FIXED,
-    /** The module has been initialized. */
-    KLDRSTATE_INITED,
-    /** The module is loaded successfully. */
-    KLDRSTATE_LOADED,
+    /** The module been mapped.
+     * Prev state: OPEN
+     * Next state: LOADED_DEPS, DESTROYED
+     */
+    KLDRSTATE_MAPPED,
+    /** The immediate dependencies has been loaded.
+     * Prev state: MAPPED
+     * Next state: FIXED_UP, DESTROYED
+     */
+    KLDRSTATE_LOADED_DEPS,
+    /** Fixups has been applied.
+     * Prev state: LOADED_DEPS
+     * Next state: PENDING_INIT, DESTROYED
+     */
+    KLDRSTATE_FIXED_UP,
+    /** Pending initialization.
+     * (The loader can now be in a re-entrant mode.)
+     * Prev state: FIXED_UP
+     * Next state: PENDING_INITIALIZATION, PENDING_GC
+     */
+    KLDRSTATE_PENDING_INITIALIZATION,
+    /** Initializing.
+     * (The loader is now in a re-entrant mode.)
+     * Prev state: PENDING_INITIALIZATION
+     * Next state: GOOD, PENDING_GC
+     */
+    KLDRSTATE_INITIALIZING,
+    /** The module has been successfully loaded and initialized.
+     * (The loader can still be in a re-entrant mode.)
+     * Prev state: INITIALIZING
+     * Next state: PENDING_TERMINATION
+     * Re-entrant.
+     */
+    KLDRSTATE_GOOD,
+    /** Pending termination, reference count is 0.
+     * (The loader can now be in a re-entrant mode.)
+     * Prev state: GOOD
+     * Next state: TERMINATING, GOOD
+     */
+    KLDRSTATE_PENDING_TERMINATION,
+    /** Terminating, reference count is still 0.
+     * (The loader is now in a re-entrant mode, but loading is a bit restricted.)
+     * Prev state: PENDING_TERMINATION
+     * Next state: PENDING_GC
+     */
+    KLDRSTATE_TERMINATING,
+    /** Pending garbage collection.
+     * (The loader can still be in a re-entrant mode.)
+     * Prev state: TERMINATING, INITIALIZING, PENDING_INITIALIZATION
+     * Next state: GC, RELOADING
+     */
+    KLDRSTATE_PENDING_GC,
+    /** Being garbage collected.
+     * (The loader can still be in a re-entrant mode.)
+     * Prev state: PENDING_GC
+     * Next state: DESTROYED
+     */
+    KLDRSTATE_GC,
+    /** The module is being reloaded after having been scheduled for termination or/and GC.
+     * (The loader can still be in a re-entrant mode.)
+     * Prev state: PENDING_GC
+     * Next state: PENDING_INITIALIZATION
+     */
+    KLDRSTATE_RELOADING,
+    /** The module has been destroyed and is no longer valid.
+     * Prev state: GC
+     */
+    KLDRSTATE_DESTROYED,
     /** The end of valid states (exclusive) */
-    KLDRSTATE_END,
+    KLDRSTATE_END = KLDRSTATE_DESTROYED,
     /** The usual 32-bit blowup. */
     KLDRSTATE_32BIT_HACK = 0x7fffffff
@@ -99 +161 @@
     /** The module. */
     PKLDRMOD            pMod;
+    /** The module handle. */
+    HKLDRMOD            hMod;
     /** The number of references. */
     uint32_t            cRefs;
     /** The number of dynamic references. */
     uint32_t            cDynRefs;
-    /** Set if this is the executable module. */
+    /** The number of dynamic load operations in progress.
+     * This is used to reject anyone trying to unload a module before the load has
+     * been completed. An alternative to this would be to not add the cDynRefs until
+     * the load operation has completed... */
+    uint32_t            cDynRefsInProgress;
+    /** Set if this is the executable module.
+     * When clear, the module is a shared object or relocatable object. */
     uint32_t            fExecutable : 1;
     /** Global DLL (set) or specific DLL (clear). */
-    uint32_t            fGlobal : 1;
-    /** Load stage one. */
-    uint32_t            fLoadStageOne : 1;
+    uint32_t            fGlobalOrSpecific : 1;
+    /** Whether the module contains bindable symbols in the global unix namespace. */
+    uint32_t            fBindable : 1;
     /** Reserved for future use. */
     uint32_t            fReserved : 29;
-    /** The next module in the list. */
-    struct KLDRDYMOD   *pNext;
-    /** The prev module in the list. */
-    struct KLDRDYMOD   *pPrev;
+    /** The load list linkage. */
+    struct
+    {
+        /** The next module in the list. */
+        struct KLDRDYLDMOD *pNext;
+        /** The prev module in the list. */
+        struct KLDRDYLDMOD *pPrev;
+    } Load;
+    /** The termination list linkage. */
+    struct
+    {
+        /** The next module in the list. */
+        struct KLDRDYLDMOD *pNext;
+        /** The prev module in the list. */
+        struct KLDRDYLDMOD *pPrev;
+    } Term;
+    /** The bind order list linkage.
+     * The module is not in this list when fBindable is clear. */
+    struct
+    {
+        /** The next module in the list. */
+        struct KLDRDYLDMOD *pNext;
+        /** The prev module in the list. */
+        struct KLDRDYLDMOD *pPrev;
+    } Bind;
     /** Magic number. */
     uint32_t            u32MagicTail;
 } KLDRDYLDMOD, *PKLDRDYLDMOD, **PPKLDRDYLDMOD;
 
-/** KLDRDYMOD magic value. (Fuyumi Soryo) */
+/** KLDRDYLDMOD magic value. (Fuyumi Soryo) */
 #define KLDRDYMOD_MAGIC     0x19590106
 
@@ -134 +225 @@
 
 
-int kldrDyldFindNewModule(const char *pszName, const char *pszPrefix, const char *pszSuffix,
+int kldrDyldFindNewModule(const char *pszName, const char *pszDefPrefix, const char *pszDefSuffix,
                           KLDRDYLDSEARCH enmSearch, unsigned fFlags, PPKLDRDYLDMOD ppMod);
-int kldrDyldFindExistingModule(const char *pszName, const char *pszPrefix, const char *pszSuffix,
+int kldrDyldFindExistingModule(const char *pszName, const char *pszDefPrefix, const char *pszDefSuffix,
                                KLDRDYLDSEARCH enmSearch, unsigned fFlags, PPKLDRDYLDMOD ppMod);
 
@@ -158 +249 @@
 int kldrDyldModCallInit(PKLDRDYLDMOD pMod);
 int kldrDyldModCallTerm(PKLDRDYLDMOD pMod);
+int kldrDyldModAttachThread(PKLDRDYLDMOD pMod);
+int kldrDyldModDetachThread(PKLDRDYLDMOD pMod);
 int kldrDyldModGetStackInfo(PKLDRDYLDMOD pMod, void *pvStack, size_t *pcbStack, size_t);
 int kldrDyldModStartExe(PKLDRDYLDMOD pMod);
@@ -169 +262 @@
 
 
-/** Pointer to the head module (the executable). */
+/** Pointer to the head module of the load list (the executable). */
 extern PKLDRDYLDMOD     kLdrDyldModuleHead;
-/** Pointer to the tail module. */
+/** Pointer to the tail module of the load list. */
 extern PKLDRDYLDMOD     kLdrDyldModuleTail;
+/** Pointer to the head module of the termination order list. */
+extern PKLDRDYLDMOD     g_pkLdrDyldTermHead;
+/** Pointer to the tail module of the termination order list. */
+extern PKLDRDYLDMOD     g_pkLdrDyldTermTail;
+/** Pointer to the head module of the bind order list.
+ * The modules in this list makes up the global namespace used when binding symbol unix fashion. */
+extern PKLDRDYLDMOD     g_pkLdrDyldBindHead;
+/** Pointer to the tail module of the bind order list. */
+extern PKLDRDYLDMOD     g_pkLdrDyldBindTail;
+
+/** The global error buffer. */
+extern char             g_szkLdrDyldError[1024];
+
 /** The Library search path. */
 extern char             kLdrDyldLibraryPath[4096];
-/** The global error buffer. */
-extern char             g_szkLdrDyldError[1024];