vbox的更動 54218 路徑 trunk/src/VBox/Debugger

時間撮記:

2015-2-16 下午03:17:05 (10 年 以前)

作者:

vboxsync

訊息:

DBGF,DBGC: Added dmesg command and implemented it for linux guests.

位置:

trunk/src/VBox/Debugger

檔案:

• DBGCCommands.cpp (修改) (4 筆差異)
• DBGPlugInLinux.cpp (修改) (4 筆差異)
• testcase/tstDBGCStubs.cpp (修改) (1 筆差異)

trunk/src/VBox/Debugger/DBGCCommands.cpp

@@ -52 +52 @@
 static FNDBGCCMD dbgcCmdStop;
 static FNDBGCCMD dbgcCmdDetect;
+static FNDBGCCMD dbgcCmdDmesg;
 static FNDBGCCMD dbgcCmdCpu;
 static FNDBGCCMD dbgcCmdInfo;
@@ -109 +110 @@
 
 
+/** 'dmesg' arguments. */
+static const DBGCVARDESC    g_aArgDmesg[] =
+{
+    /* cTimesMin,   cTimesMax,  enmCategory,            fFlags,                         pszName,        pszDescription */
+    {  0,           1,     DBGCVAR_CAT_NUMBER_NO_RANGE, 0,                              "messages",     "Limit the output to the last N messages. (optional)" },
+};
+
+
 /** 'help' arguments. */
 static const DBGCVARDESC    g_aArgHelp[] =
@@ -232 +241 @@
     { "format",     1,        1,        &g_aArgAny[0],       RT_ELEMENTS(g_aArgAny),       0, dbgcCmdFormat,    "",                     "Evaluates an expression and formats it." },
     { "detect",     0,        0,        NULL,                0,                            0, dbgcCmdDetect,    "",                     "Detects or re-detects the guest os and starts the OS specific digger." },
+    { "dmesg",      0,        1,        &g_aArgDmesg[0],     RT_ELEMENTS(g_aArgDmesg),     0, dbgcCmdDmesg,     "[N last messages]",    "Displays the guest os kernel messages, if available." },
     { "harakiri",   0,        0,        NULL,                0,                            0, dbgcCmdHarakiri,  "",                     "Kills debugger process." },
     { "help",       0,        ~0U,      &g_aArgHelp[0],      RT_ELEMENTS(g_aArgHelp),      0, dbgcCmdHelp,      "[cmd/op [..]]",        "Display help. For help about info items try 'info help'." },
@@ -998 +1008 @@
         rc = DBGCCmdHlpPrintf(pCmdHlp, "Unable to figure out which guest OS it is, sorry.\n");
     NOREF(pCmd); NOREF(paArgs);
+    return rc;
+}
+
+
+/**
+ * @interface_method_impl{FNDBCCMD, The 'dmesg' command.}
+ */
+static DECLCALLBACK(int) dbgcCmdDmesg(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PUVM pUVM, PCDBGCVAR paArgs, unsigned cArgs)
+{
+    /* check that the parser did what it's supposed to do. */
+    if (cArgs > 1)
+        return DBGCCmdHlpPrintf(pCmdHlp, "parser error\n");
+    uint32_t cMessages = UINT32_MAX;
+    if (cArgs == 1)
+    {
+        if (paArgs[0].enmType != DBGCVAR_TYPE_NUMBER)
+            return DBGCCmdHlpPrintf(pCmdHlp, "parser error\n");
+        cMessages = paArgs[0].u.u64Number <= UINT32_MAX ? (uint32_t)paArgs[0].u.u64Number : UINT32_MAX;
+    }
+
+    /*
+     * Query the interface.
+     */
+    int rc;
+    PDBGFOSIDMESG pDmesg = (PDBGFOSIDMESG)DBGFR3OSQueryInterface(pUVM, DBGFOSINTERFACE_DMESG);
+    if (pDmesg)
+    {
+        size_t  cbActual;
+        size_t  cbBuf  = _512K;
+        char   *pszBuf = (char *)RTMemAlloc(cbBuf);
+        if (pszBuf)
+        {
+            rc = pDmesg->pfnQueryKernelLog(pDmesg, pUVM, 0 /*fFlags*/, cMessages, pszBuf, cbBuf, &cbActual);
+
+            uint32_t cTries = 10;
+            while (rc == VERR_BUFFER_OVERFLOW && cbBuf < 16*_1M && cTries-- > 0)
+            {
+                RTMemFree(pszBuf);
+                cbBuf = RT_ALIGN_Z(cbActual + _4K, _4K);
+                pszBuf = (char *)RTMemAlloc(cbBuf);
+                if (RT_UNLIKELY(!pszBuf))
+                {
+                    rc = DBGCCmdHlpFail(pCmdHlp, pCmd, "Error allocating %#zu bytes.\n", cbBuf);
+                    break;
+                }
+                rc = pDmesg->pfnQueryKernelLog(pDmesg, pUVM, 0 /*fFlags*/, cMessages, pszBuf, cbBuf, &cbActual);
+            }
+            if (RT_SUCCESS(rc))
+                rc = DBGCCmdHlpPrintf(pCmdHlp, "%s\n", pszBuf);
+            else if (rc == VERR_BUFFER_OVERFLOW && pszBuf)
+                rc = DBGCCmdHlpPrintf(pCmdHlp, "%s\nWarning: incomplete\n", pszBuf);
+            else
+                rc = DBGCCmdHlpFail(pCmdHlp, pCmd, "Error allocating %#zu bytes.\n", cbBuf);
+        }
+        else
+            rc = DBGCCmdHlpFail(pCmdHlp, pCmd, "Error allocating %#zu bytes.\n", cbBuf);
+    }
+    else
+        rc = DBGCCmdHlpFail(pCmdHlp, pCmd, "The dmesg interface isn't implemented by guest OS.\n");
     return rc;
 }

trunk/src/VBox/Debugger/DBGPlugInLinux.cpp

@@ -81 +81 @@
     DBGFADDRESS AddrKernelTokenIndex;
 
+    /** The kernel message log interface. */
+    DBGFOSIDMESG    IDmesg;
 } DBGDIGGERLINUX;
 /** Pointer to the linux guest OS digger instance data. */
 typedef DBGDIGGERLINUX *PDBGDIGGERLINUX;
+
+
+/**
+ * The current printk_log structure.
+ */
+typedef struct LNXPRINTKHDR
+{
+    /** Monotonic timestamp. */
+    uint64_t nsTimestamp;
+    /** The total size of this message record. */
+    uint16_t cbTotal;
+    /** The size of the text part (immediately follows the header). */
+    uint16_t cbText;
+    /** The size of the optional dictionary part (follows the text). */
+    uint16_t cbDict;
+    /** The syslog facility number. */
+    uint8_t  bFacility;
+    /** First 5 bits are internal flags, next 3 bits are log level. */
+    uint8_t  fFlagsAndLevel;
+} LNXPRINTKHDR;
+AssertCompileSize(LNXPRINTKHDR, 2*sizeof(uint64_t));
+/** Pointer to linux printk_log header. */
+typedef LNXPRINTKHDR *PLNXPRINTKHDR;
+/** Pointer to linux const printk_log header. */
+typedef LNXPRINTKHDR const *PCLNXPRINTKHDR;
 
 
@@ -113 +140 @@
 #define LNX_MAX_KALLSYMS_TOKEN_LEN          UINT16_C(32)
 
-
 /** Module tag for linux ('linuxmod' on little endian ASCII systems). */
 #define DIG_LNX_MOD_TAG                     UINT64_C(0x545f5d78758e898c)
@@ -137 +163 @@
 
 /**
+ * @interface_method_impl{DBGFOSIDMESG,pfnQueryKernelLog}
+ */
+static DECLCALLBACK(int) dbgDiggerLinuxIDmsg_QueryKernelLog(PDBGFOSIDMESG pThis, PUVM pUVM, uint32_t fFlags, uint32_t cMessages,
+                                                            char *pszBuf, size_t cbBuf, size_t *pcbActual)
+{
+    PDBGDIGGERLINUX pData = RT_FROM_MEMBER(pThis, DBGDIGGERLINUX, IDmesg);
+
+    if (cMessages < 1)
+        return VERR_INVALID_PARAMETER;
+
+    /*
+     * Resolve the symbols we need and read their values.
+     */
+    RTDBGAS  hAs = DBGFR3AsResolveAndRetain(pUVM, DBGF_AS_KERNEL);
+    RTDBGMOD hMod;
+    int rc = RTDbgAsModuleByName(hAs, "vmlinux", 0, &hMod);
+    if (RT_FAILURE(rc))
+        return VERR_NOT_FOUND;
+    RTDbgAsRelease(hAs);
+
+    RTGCPTR  GCPtrLogBuf;
+    uint32_t cbLogBuf;
+    uint32_t idxFirst;
+    uint32_t idxNext;
+
+    struct { void *pvVar; uint32_t cbHost, cbGuest; const char *pszSymbol; } aSymbols[] =
+    {
+        { &GCPtrLogBuf, sizeof(GCPtrLogBuf),    pData->f64Bit ? sizeof(uint64_t) : sizeof(uint32_t),   "log_buf" },
+        { &cbLogBuf,    sizeof(cbLogBuf),       sizeof(cbLogBuf),                                      "log_buf_len" },
+        { &idxFirst,    sizeof(idxFirst),       sizeof(idxFirst),                                      "log_first_idx" },
+        { &idxNext,     sizeof(idxNext),        sizeof(idxNext),                                       "log_next_idx" },
+    };
+    for (uint32_t i = 0; i < RT_ELEMENTS(aSymbols); i++)
+    {
+        RTDBGSYMBOL SymInfo;
+        rc = RTDbgModSymbolByName(hMod, aSymbols[i].pszSymbol, &SymInfo);
+        if (RT_SUCCESS(rc))
+        {
+            RT_BZERO(aSymbols[i].pvVar, aSymbols[i].cbHost);
+            Assert(aSymbols[i].cbHost >= aSymbols[i].cbGuest);
+            DBGFADDRESS Addr;
+            rc = DBGFR3MemRead(pUVM, 0 /*idCpu*/,
+                               DBGFR3AddrFromFlat(pUVM, &Addr, (RTGCPTR)SymInfo.Value + pData->AddrKernelBase.FlatPtr),
+                               aSymbols[i].pvVar,  aSymbols[i].cbGuest);
+            if (RT_SUCCESS(rc))
+                continue;
+            Log(("dbgDiggerLinuxIDmsg_QueryKernelLog: Reading '%s' at %RGv: %Rrc\n", aSymbols[i].pszSymbol, Addr.FlatPtr, rc));
+        }
+        else
+            Log(("dbgDiggerLinuxIDmsg_QueryKernelLog: Error looking up '%s': %Rrc\n", aSymbols[i].pszSymbol, rc));
+        RTDbgModRelease(hMod);
+        return VERR_NOT_FOUND;
+    }
+
+    /*
+     * Check if the values make sense.
+     */
+    if (pData->f64Bit ? !LNX64_VALID_ADDRESS(GCPtrLogBuf) : !LNX32_VALID_ADDRESS(GCPtrLogBuf))
+    {
+        Log(("dbgDiggerLinuxIDmsg_QueryKernelLog: 'log_buf' value %RGv is not valid.\n", GCPtrLogBuf));
+        return VERR_NOT_FOUND;
+    }
+    if (   cbLogBuf < 4096
+        || !RT_IS_POWER_OF_TWO(cbLogBuf)
+        || cbLogBuf > 16*_1M)
+    {
+        Log(("dbgDiggerLinuxIDmsg_QueryKernelLog: 'log_buf_len' value %#x is not valid.\n", cbLogBuf));
+        return VERR_NOT_FOUND;
+    }
+    uint32_t const cbLogAlign = 4;
+    if (   idxFirst > cbLogBuf - sizeof(LNXPRINTKHDR)
+        || (idxFirst & (cbLogAlign - 1)) != 0)
+    {
+        Log(("dbgDiggerLinuxIDmsg_QueryKernelLog: 'log_first_idx' value %#x is not valid.\n", idxFirst));
+        return VERR_NOT_FOUND;
+    }
+    if (   idxNext > cbLogBuf - sizeof(LNXPRINTKHDR)
+        || (idxNext & (cbLogAlign - 1)) != 0)
+    {
+        Log(("dbgDiggerLinuxIDmsg_QueryKernelLog: 'log_next_idx' value %#x is not valid.\n", idxNext));
+        return VERR_NOT_FOUND;
+    }
+
+    /*
+     * Read the whole log buffer.
+     */
+    uint8_t *pbLogBuf = (uint8_t *)RTMemAlloc(cbLogBuf);
+    if (!pbLogBuf)
+    {
+        Log(("dbgDiggerLinuxIDmsg_QueryKernelLog: Failed to allocate %#x bytes for log buffer\n", cbLogBuf));
+        return VERR_NO_MEMORY;
+    }
+    DBGFADDRESS Addr;
+    rc = DBGFR3MemRead(pUVM, 0 /*idCpu*/, DBGFR3AddrFromFlat(pUVM, &Addr, GCPtrLogBuf), pbLogBuf, cbLogBuf);
+    if (RT_FAILURE(rc))
+    {
+        Log(("dbgDiggerLinuxIDmsg_QueryKernelLog: Error reading %#x bytes of log buffer at %RGv: %Rrc\n",
+             cbLogBuf, Addr.FlatPtr, rc));
+        RTMemFree(pbLogBuf);
+        return VERR_NOT_FOUND;
+    }
+
+    /*
+     * Count the messages in the buffer while doing some basic validation.
+     */
+    uint32_t const cbUsed = idxFirst == idxNext ? cbLogBuf /* could be empty... */
+                          : idxFirst < idxNext  ? idxNext - idxFirst : cbLogBuf - idxFirst + idxNext;
+    uint32_t cbLeft    = cbUsed;
+    uint32_t offCur    = idxFirst;
+    uint32_t cLogMsgs  = 0;
+
+    while (cbLeft > 0)
+    {
+        PCLNXPRINTKHDR pHdr = (PCLNXPRINTKHDR)&pbLogBuf[offCur];
+        if (!pHdr->cbTotal)
+        {
+            /* Wrap around packet, most likely... */
+            if (cbLogBuf - offCur >= cbLeft)
+                break;
+            offCur = 0;
+            pHdr = (PCLNXPRINTKHDR)&pbLogBuf[offCur];
+        }
+        if (RT_UNLIKELY(   pHdr->cbTotal > cbLogBuf - sizeof(*pHdr) - offCur
+                        || pHdr->cbTotal > cbLeft
+                        || (pHdr->cbTotal & (cbLogAlign - 1)) != 0
+                        || pHdr->cbTotal < (uint32_t)pHdr->cbText + (uint32_t)pHdr->cbDict + sizeof(*pHdr) ))
+        {
+            Log(("dbgDiggerLinuxIDmsg_QueryKernelLog: Invalid printk_log record at %#x: cbTotal=%#x cbText=%#x cbDict=%#x cbLogBuf=%#x cbLeft=%#x\n",
+                 offCur, pHdr->cbTotal, pHdr->cbText, pHdr->cbDict, cbLogBuf, cbLeft));
+            rc = VERR_INVALID_STATE;
+            break;
+        }
+
+        if (pHdr->cbText > 0)
+            cLogMsgs++;
+
+        /* next */
+        offCur += pHdr->cbTotal;
+        cbLeft -= pHdr->cbTotal;
+    }
+    if (RT_FAILURE(rc))
+    {
+        RTMemFree(pbLogBuf);
+        return rc;
+    }
+
+    /*
+     * Copy the messages into the output buffer.
+     */
+    offCur = idxFirst;
+    cbLeft = cbUsed;
+
+    /* Skip messages that the caller doesn't want. */
+    if (cMessages < cLogMsgs)
+    {
+        uint32_t cToSkip = cLogMsgs - cMessages;
+        while (cToSkip > 0)
+        {
+            PCLNXPRINTKHDR pHdr = (PCLNXPRINTKHDR)&pbLogBuf[offCur];
+            if (!pHdr->cbTotal)
+            {
+                offCur = 0;
+                pHdr = (PCLNXPRINTKHDR)&pbLogBuf[offCur];
+            }
+            if (pHdr->cbText > 0)
+                cToSkip--;
+
+            /* next */
+            offCur += pHdr->cbTotal;
+            cbLeft -= pHdr->cbTotal;
+        }
+    }
+
+    /* Now copy the messages. */
+    size_t offDst = 0;
+    while (cbLeft > 0)
+    {
+        PCLNXPRINTKHDR pHdr = (PCLNXPRINTKHDR)&pbLogBuf[offCur];
+        if (!pHdr->cbTotal)
+        {
+            if (cbLogBuf - offCur >= cbLeft)
+                break;
+            offCur = 0;
+            pHdr = (PCLNXPRINTKHDR)&pbLogBuf[offCur];
+        }
+
+        if (pHdr->cbText > 0)
+        {
+            char  *pchText = (char *)(pHdr + 1);
+            size_t cchText = RTStrNLen(pchText, pHdr->cbText);
+            if (offDst + cchText < cbBuf)
+            {
+                memcpy(&pszBuf[offDst], pHdr + 1, cchText);
+                pszBuf[offDst + cchText] = '\n';
+            }
+            else if (offDst < cbBuf)
+                memcpy(&pszBuf[offDst], pHdr + 1, cbBuf - offDst);
+            offDst += cchText + 1;
+        }
+
+        /* next */
+        offCur += pHdr->cbTotal;
+        cbLeft -= pHdr->cbTotal;
+    }
+
+    /* Done with the buffer. */
+    RTMemFree(pbLogBuf);
+
+    /* Make sure we've reserved a char for the terminator. */
+    if (!offDst)
+        offDst = 1;
+
+    /* Set return size value. */
+    if (pcbActual)
+        *pcbActual = offDst;
+
+    /*
+     * All VBox strings are UTF-8 and bad things may in theory happen if we
+     * pass bad UTF-8 to code which assumes it's all valid.  So, we enforce
+     * UTF-8 upon the guest kernel messages here even if they (probably) have
+     * no defined code set in reality.
+     */
+    if (offDst <= cbBuf)
+    {
+        pszBuf[offDst - 1] = '\0';
+        RTStrPurgeEncoding(pszBuf);
+        return VINF_SUCCESS;
+    }
+
+    if (cbBuf)
+    {
+        pszBuf[cbBuf - 1] = '\0';
+        RTStrPurgeEncoding(pszBuf);
+    }
+    return VERR_BUFFER_OVERFLOW;
+}
+
+
+/**
  * @copydoc DBGFOSREG::pfnQueryInterface
  */
 static DECLCALLBACK(void *) dbgDiggerLinuxQueryInterface(PUVM pUVM, void *pvData, DBGFOSINTERFACE enmIf)
 {
-    return NULL;
+    PDBGDIGGERLINUX pThis = (PDBGDIGGERLINUX)pvData;
+    switch (enmIf)
+    {
+        case DBGFOSINTERFACE_DMESG:
+            return &pThis->IDmesg;
+
+        default:
+            return NULL;
+    }
 }
 
@@ -948 +1221 @@
 static DECLCALLBACK(int)  dbgDiggerLinuxConstruct(PUVM pUVM, void *pvData)
 {
+    PDBGDIGGERLINUX pThis = (PDBGDIGGERLINUX)pvData;
+    pThis->IDmesg.u32Magic = DBGFOSIDMESG_MAGIC;
+    pThis->IDmesg.pfnQueryKernelLog = dbgDiggerLinuxIDmsg_QueryKernelLog;
+    pThis->IDmesg.u32EndMagic = DBGFOSIDMESG_MAGIC;
+
     return VINF_SUCCESS;
 }

trunk/src/VBox/Debugger/testcase/tstDBGCStubs.cpp

@@ -294 +294 @@
     return VERR_INTERNAL_ERROR;
 }
+VMMR3DECL(void *) DBGFR3OSQueryInterface(PUVM pUVM, DBGFOSINTERFACE enmIf)
+{
+    return NULL;
+}
 
 VMMR3DECL(int) DBGFR3SelQueryInfo(PUVM pUVM, VMCPUID idCpu, RTSEL Sel, uint32_t fFlags, PDBGFSELINFO pSelInfo)