Changeset 3541 for trunk/kStuff/kDbg/kDbgModule.cpp

Timestamp:

Aug 25, 2007, 5:46:14 AM (18 years ago)

Author:

bird

Message:

errors and stuff.

File:

• trunk/kStuff/kDbg/kDbgModule.cpp (modified) (12 diffs)

trunk/kStuff/kDbg/kDbgModule.cpp

@@ -5 +5 @@
 
 /*
- * Copyright (c) 2006-2007 knut st. osmundsen <bird-src-spam@anduin.net>
- *
- * This file is part of kLIBC.
- *
- * kLIBC is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
+ * Copyright (c) 2007 knut st. osmundsen <bird-src-spam@anduin.net>
+ *
+ *
+ * This file is part of kStuff.
+ *
+ * kStuff is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published
+ * by the Free Software Foundation; either version 2 of the License, or
  * (at your option) any later version.
  *
- * kLIBC is distributed in the hope that it will be useful,
+ * kStuff is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with kLIBC; if not, write to the Free Software
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with kStuff; if not, write to the Free Software
  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  *
  */
+
 
 
@@ -29 +31 @@
 *   Header Files                                                               *
 *******************************************************************************/
-#include "kLdr.h"
 #include <k/kDbg.h>
+#include <k/kErrors.h>
+#include <string.h>
 #include "kDbgInternal.h"
-#include <kLdrModMZ.h>
 
 
@@ -38 +40 @@
 *   Global Variables                                                           *
 *******************************************************************************/
-
-
-
-KDBG_DECL(int) kDbgModuleOpenFilePart(PKDBGHLPFILE pFile, int64_t off, int64_t cb, PKDBGMOD *ppDbgMod)
+/**
+ * The built-in debug module readers.
+ */
+static PCKDBGMODOPS const g_aBuiltIns[] =
 {
 #if K_OS == K_OS_WINDOWS
-    /*
-     * If we're on Windows, let DbgHelp have a go first.
-     */
-    if (!off)
+    &g_kDbgModWinDbgHelpOpen,
+#endif
+    &g_kDbgModLdr,
+    &g_kDbgModCv8,
+    &g_kDbgModDwarf,
+    &g_kDbgModHll,
+    &g_kDbgModStabs,
+    &g_kDbgModSym,
+    &g_kDbgModMapILink,
+    &g_kDbgModMapMSLink,
+    &g_kDbgModMapNm,
+    &g_kDbgModMapWLink
+};
+
+/**
+ * The debug module readers registered at runtime.
+ */
+static PKDBGMODOPS g_pHead = NULL;
+
+
+/**
+ * Register a debug module reader with the kDbgModule component.
+ *
+ * Dynamically registered readers are kept in FIFO order, and external
+ * readers will be tried after the builtin ones.
+ *
+ * Like all other kDbg APIs serializing is left to the caller.
+ *
+ * @returns 0 on success.
+ * @returns KERR_INVALID_POINTER if pOps is missing bits.
+ * @returns KERR_INVALID_PARAMETER if pOps is already in the list.
+ * @param   pOps        The reader method table, kDbg takes owner ship of
+ *                      this. This must be writeable as the pNext pointer
+ *                      will be update. It must also stick around for as
+ *                      long as kDbg is in use.
+ */
+KDBG_DECL(int) kDbgModuleRegisterReader(PKDBGMODOPS pOps)
+{
+    /*
+     * Validate input.
+     */
+    kDbgAssertPtrReturn(pOps, KERR_INVALID_POINTER);
+    kDbgAssertPtrReturn(pOps->pszName, KERR_INVALID_POINTER);
+    kDbgAssertPtrReturn(pOps->pfnOpen, KERR_INVALID_POINTER);
+    kDbgAssertPtrReturn(pOps->pfnClose, KERR_INVALID_POINTER);
+    kDbgAssertPtrReturn(pOps->pfnQuerySymbol, KERR_INVALID_POINTER);
+    kDbgAssertPtrReturn(pOps->pfnQueryLine, KERR_INVALID_POINTER);
+    kDbgAssertPtrReturn(pOps->pszName2, KERR_INVALID_POINTER);
+    if (strcmp(pOps->pszName, pOps->pszName2))
+        return KERR_INVALID_PARAMETER;
+    kDbgAssertReturn(pOps->pNext == NULL, KERR_INVALID_PARAMETER);
+
+    /*
+     * Link it into the list.
+     */
+    if (!g_pHead)
+        g_pHead = pOps;
+    else
     {
-        int rc = kdbgModWinDbgHelpOpen(pFile, ppDbgMod);
-        if (!rc)
-            return 0;
+        PKDBGMODOPS pPrev = g_pHead;
+        while (pPrev->pNext)
+            pPrev = pPrev->pNext;
+        kDbgAssertReturn(pPrev != pOps, KERR_INVALID_PARAMETER);
+        pPrev->pNext = pOps;
     }
-#endif
-
-    /*
-     * Probe the file for signatures we recognize.
-     */
-    int64_t offHdr = 0;
-    union
+    return 0;
+}
+
+
+/**
+ * Deregister a debug module reader previously registered using
+ * the kDbgModuleRegisterReader API.
+ *
+ * Deregistering a reader does not mean that non of its functions
+ * will be called after successful return, it only means that it
+ * will no longer be subjected to new module.
+ *
+ * @returns 0 on success.
+ * @returns KERR_INVALID_POINTER if pOps isn't a valid pointer.
+ * @returns KERR_INVALID_PARAMETER if pOps wasn't registered.
+ * @param   pOps    The debug module method table to deregister.
+ */
+KDBG_DECL(int) kDbgModuleDeregisterReader(PKDBGMODOPS pOps)
+{
+    /*
+     * Validate the pointer.
+     */
+    kDbgAssertPtrReturn(pOps, KERR_INVALID_POINTER);
+
+    /*
+     * Find it in the list and unlink it.
+     */
+    if (g_pHead == pOps)
+        g_pHead = pOps->pNext;
+    else
     {
-        uint32_t    au32[4];
-        uint16_t    au16[8];
-        uint8_t     ab[16];
-        char
-    } Buf;
-    rc = kDbgHlpReadAt(pFile, &Buf, sizeof(Buf), off);
-
-}
-
-
-KDBG_DECL(int) kDbgModuleOpenFile(PKDBGHLPFILE pFile, PKDBGMOD *ppDbgMod)
-{
-    return kDbgModuleOpenFilePart(pFile, 0, INT64_MAX, ppDbgMod);
-}
-
-
-KDBG_DECL(int) kDbgModuleOpenkLdrMod(PKLDRMOD pLdrMod, PKDBGMOD *ppDbgMod)
-{
-    /*
-     * Enumerate the debug info, if nothing found check for a matching .pdb,
-     * .dbg, .sym or .map file.
-     */
-
+        PKDBGMODOPS pPrev = g_pHead;
+        while (pPrev && pPrev->pNext != pOps)
+            pPrev = pPrev->pNext;
+        if (!pPrev)
+            return KERR_INVALID_PARAMETER;
+        pPrev->pNext = pOps->pNext;
+    }
+    pOps->pNext = NULL;
+    return 0;
+}
+
+
+/**
+ * Opens a debug module reader for the specified file or file section
+ *
+ * @returns kStuff status code.
+ * @param   ppDbgMod            Where to store the debug module reader handle.
+ * @param   pFile               The file reader.
+ * @param   off                 The offset of the file section. If the entire file, pass 0.
+ * @param   cb                  The size of the file section. If the entire file, pass KFOFF_MAX.
+ * @param   pLdrMod             Associated kLdr module that the kDbg component can use to
+ *                              verify and suplement the debug info found in the file specified
+ *                              by pszFilename. The module will be used by kDbg for as long as
+ *                              the returned kDbg module remains open.
+ *                              This is an optional parameter, pass NULL if no kLdr module at hand.
+ */
+KDBG_DECL(int) kDbgModuleOpenFilePart(PKDBGMOD *ppDbgMod, PKDBGHLPFILE pFile, KFOFF off, KFOFF cb, struct KLDRMOD *pLdrMod)
+{
+    /*
+     * Validate input.
+     */
+    kDbgAssertPtrReturn(ppDbgMod, KERR_INVALID_POINTER);
+    kDbgAssertPtrReturn(pFile, KERR_INVALID_POINTER);
+    kDbgAssertPtrNullReturn(pLdrMod, KERR_INVALID_POINTER);
+    kDbgAssertMsgReturn(off >= 0 && off < KFOFF_MAX, (KFOFF_PRI "\n", off), KERR_INVALID_OFFSET);
+    kDbgAssertMsgReturn(cb >= 0 && cb <= KFOFF_MAX, (KFOFF_PRI "\n", cb), KERR_INVALID_SIZE);
+    kDbgAssertMsgReturn(off + cb > off, ("off=" KFOFF_PRI " cb=" KFOFF_PRI "\n", off, cb), KERR_INVALID_RANGE);
+    *ppDbgMod = NULL;
+
+    /*
+     * Walk the built-in table and the list of registered readers
+     * and let each of them have a go at the file. Stop and return
+     * on the first one returning successfully.
+     */
+    int rc = KDBG_ERR_UNKOWN_FORMAT;
+    for (KSIZE i = 0; i < K_ELEMENTS(g_aBuiltIns); i++)
+        if (g_aBuiltIns[i]->pfnOpen)
+        {
+            int rc2 = g_aBuiltIns[i]->pfnOpen(ppDbgMod, pFile, off, cb, pLdrMod);
+            if (!rc)
+                return 0;
+            if (rc2 != KDBG_ERR_UNKOWN_FORMAT && rc == KDBG_ERR_UNKOWN_FORMAT)
+                rc = rc2;
+        }
+
+    for (PKDBGMODOPS pCur = g_pHead; pCur; pCur = pCur->pNext)
+        if (g_aBuiltIns[i]->pfnOpen)
+        {
+            int rc2 = g_aBuiltIns[i]->pfnOpen(ppDbgMod, pFile, off, cb, pLdrMod);
+            if (!rc)
+                return 0;
+            if (rc2 != KDBG_ERR_UNKOWN_FORMAT && rc == KDBG_ERR_UNKOWN_FORMAT)
+                rc = rc2;
+        }
+    return rc;
+}
+
+
+/**
+ * Opens a debug module reader for the specified file.
+ *
+ * @returns kStuff status code.
+ * @param   ppDbgMod            Where to store the debug module reader handle.
+ * @param   pFile               The file reader.
+ * @param   pLdrMod             Associated kLdr module that the kDbg component can use to
+ *                              verify and suplement the debug info found in the file specified
+ *                              by pszFilename. The module will be used by kDbg for as long as
+ *                              the returned kDbg module remains open.
+ *                              This is an optional parameter, pass NULL if no kLdr module at hand.
+ */
+KDBG_DECL(int) kDbgModuleOpenFile(PKDBGMOD *ppDbgMod, PKDBGHLPFILE pFile, struct KLDRMOD *pLdrMod)
+{
+    return kDbgModuleOpenFilePart(ppDbgMod, pFile, 0, KFOFF_MAX, pLdrMod);
 }
 
@@ -90 +231 @@
  * Opens the debug info for a specified executable module.
  *
- * @returns IPRT status code.
- * @param   pszModulePath       The path to the executable module.
+ * @returns kStuff status code.
  * @param   ppDbgMod            Where to store the debug module handle.
- */
-KDBG_DECL(int) kDbgModuleOpen(const char *pszModulePath, PKDBGMOD *ppDbgMod)
+ * @param   pszFilename         The name of the file containing debug info and/or which
+ *                              debug info is wanted.
+ * @param   pLdrMod             Associated kLdr module that the kDbg component can use to
+ *                              verify and suplement the debug info found in the file specified
+ *                              by pszFilename. The module will be used by kDbg for as long as
+ *                              the returned kDbg module remains open.
+ *                              This is an optional parameter, pass NULL if no kLdr module at hand.
+ */
+KDBG_DECL(int) kDbgModuleOpen(PKDBGMOD *ppDbgMod, const char *pszFilename, struct KLDRMOD *pLdrMod)
 {
     /*
      * Validate input.
      */
-    kDbgAssertPtrReturn(pszModulePath, KDBG_ERR_INVALID_POINTER);
-    kDbgAssertMsgReturn(*pszModulePath, ("%p\n", pszModulePath), KDBG_ERR_INVALID_PARAMETER);
-    kDbgAssertPtrReturn(ppDbgMod, KDBG_ERR_INVALID_POINTER);
+    kDbgAssertPtrReturn(ppDbgMod, KERR_INVALID_POINTER);
+    kDbgAssertPtrReturn(pszFilename, KERR_INVALID_POINTER);
+    kDbgAssertMsgReturn(*pszFilename, ("%p\n", pszFilename), KERR_INVALID_PARAMETER);
+    kDbgAssertPtrNullReturn(pLdrMod, KERR_INVALID_POINTER);
     *ppDbgMod = NULL;
 
@@ -108 +256 @@
      */
     PKDBGHLPFILE pFile;
-    int rc = kDbgHlpOpenRO(pszModulePath, &pFile);
+    int rc = kDbgHlpOpenRO(pszFilename, &pFile);
     if (rc)
         return rc;
-    rc = kDbgModuleOpenFile(pFile, ppDbgMod);
+    rc = kDbgModuleOpenFilePart(ppDbgMod, pFile, 0, KFOFF_MAX, pLdrMod);
     if (rc)
-    {
         kDbgHlpClose(pFile);
-
-        /*
-         * Let kLdr have a shot at it, if it's a binary it may contain
-         * some debug sections or a link to an external debug file.
-         */
-        PKLDRMOD pLdrMod;
-        int rc2 = kLdrModOpen(pszModulePath, *pLdrMod);
-        if (!rc2)
-        {
-            rc = kDbgModuleOpenkLdrMod(pLdrMod, ppDbgMod);
-            if (rc)
-                kLdrModClose(pLdrMod);
-        }
-    }
-
     return rc;
 }
@@ -159 +291 @@
 {
     if (!kdbgModIsValid(pMod))
-        return KDBG_ERR_INVALID_PARAMETER;
+        return KERR_INVALID_PARAMETER;
 
     int rc = pMod->pOps->pfnClose(pMod);
@@ -184 +316 @@
 {
     if (!kdbgModIsValid(pMod))
-        return KDBG_ERR_INVALID_PARAMETER;
-    kDbgAssertPtrReturn(pSym, KDBG_ERR_INVALID_POINTER);
+        return KERR_INVALID_PARAMETER;
+    kDbgAssertPtrReturn(pSym, KERR_INVALID_POINTER);
 
     return pMod->pOps->pfnQuerySymbol(pMod, iSegment, off, pSym);
@@ -207 +339 @@
 KDBG_DECL(int) kDbgModuleQuerySymbolA(PKDBGMOD pMod, int32_t iSegment, KDBGADDR off, PPKDBGSYMBOL ppSym)
 {
-    kDbgAssertPtrReturn(ppSym, KDBG_ERR_INVALID_POINTER);
+    kDbgAssertPtrReturn(ppSym, KERR_INVALID_POINTER);
 
     KDBGSYMBOL Sym;
@@ -215 +347 @@
         *ppSym = kDbgSymbolDup(&Sym);
         if (!*ppSym)
-            rc = KDBG_ERR_NO_MEMORY;
+            rc = KERR_NO_MEMORY;
     }
     else
@@ -239 +371 @@
 {
     if (!kdbgModIsValid(pMod))
-        return KDBG_ERR_INVALID_PARAMETER;
-    kDbgAssertPtrReturn(pLine, KDBG_ERR_INVALID_POINTER);
+        return KERR_INVALID_PARAMETER;
+    kDbgAssertPtrReturn(pLine, KERR_INVALID_POINTER);
 
     return pMod->pOps->pfnQueryLine(pMod, iSegment, off, pLine);
@@ -262 +394 @@
 KDBG_DECL(int) kDbgModuleQueryLineA(PKDBGMOD pMod, int32_t iSegment, KDBGADDR off, PPKDBGLINE ppLine)
 {
-    kDbgAssertPtrReturn(ppLine, KDBG_ERR_INVALID_POINTER);
+    kDbgAssertPtrReturn(ppLine, KERR_INVALID_POINTER);
 
     KDBGLINE Line;
@@ -270 +402 @@
         *ppLine = kDbgLineDup(&Line);
         if (!*ppLine)
-            rc = KDBG_ERR_NO_MEMORY;
+            rc = KERR_NO_MEMORY;
     }
     else