Changeset 5731

Timestamp:

11/13/07 23:42:00 (1 year ago)

Author:

vboxsync

Message:

Implemented some search commands in the debugger.

Files:

• trunk/include/VBox/dbg.h (modified) (2 diffs)
• trunk/include/VBox/dbgf.h (modified) (1 diff)
• trunk/src/VBox/Debugger/DBGCCmdHlp.cpp (modified) (1 diff)
• trunk/src/VBox/Debugger/DBGCCmdWorkers.cpp (modified) (6 diffs)
• trunk/src/VBox/Debugger/DBGCEmulateCodeView.cpp (modified) (5 diffs)
• trunk/src/VBox/Debugger/DBGCInternal.h (modified) (3 diffs)
• trunk/src/VBox/Debugger/DBGConsole.cpp (modified) (4 diffs)
• trunk/src/VBox/Debugger/testcase/tstDBGCStubs.cpp (modified) (1 diff)
• trunk/src/VBox/VMM/DBGFMem.cpp (modified) (1 diff)
• trunk/src/VBox/VMM/PGMDbg.cpp (modified) (5 diffs)

trunk/include/VBox/dbg.h

@@ -66 +66 @@
-    DBGCVAR_CAT_STRING,
-    /** Symbol. */
-
+
+
+
+
+
+
+
-} DBGCVARCAT;
-
@@ -203 +209 @@
-
-
- 
+
- * Macro for initializing a DBGC variable with defaults.
- * The result is an unknown variable type without any range.

trunk/include/VBox/dbgf.h

@@ -1516 +1516 @@
-#endif
-
+
+/**
+ * Scan guest memory for an exact byte string.
+ *
+ * @returns VBox status codes:
+ * @retval  VINF_SUCCESS and *pGCPtrHit on success.
+ * @retval  VERR_DBGF_MEM_NOT_FOUND if not found.
+ * @retval  VERR_INVALID_POINTER if any of the pointer arguments are invalid.
+ * @retval  VERR_INVALID_ARGUMENT if any other arguments are invalid.
+ *
+ * @param   pVM         The VM handle.
+ * @param   pAddress    Where to store the mixed address.
+ * @param   cbRange     The number of bytes to scan.
+ * @param   pabNeedle   What to search for - exact search.
+ * @param   cbNeedle    Size of the search byte string.
+ * @param   pHitAddress Where to put the address of the first hit.
+ *
+ * @thread  Any thread.
+ */
+DBGFR3DECL(int) DBGFR3MemScan(PVM pVM, PCDBGFADDRESS pAddress, RTGCUINTPTR cbRange, const uint8_t *pabNeedle, size_t cbNeedle, PDBGFADDRESS pHitAddress);
+
-/** @} */
-

trunk/src/VBox/Debugger/DBGCCmdHlp.cpp

@@ -270 +270 @@
-        default:
-            rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL, "error: %Vrc: %s", rc, pszFormat ? " " : "\n");
-VBOX
+RT
-                rc = pCmdHlp->pfnPrintfV(pCmdHlp, NULL, pszFormat, args);
+            if (RT_SUCCESS(rc))
+                rc = VERR_DBGC_COMMAND_FAILED;
-            break;
-    }

trunk/src/VBox/Debugger/DBGCCmdWorkers.cpp

@@ -53 +53 @@
-
-/** @todo move me!*/
+void dbgcVarInit(PDBGCVAR pVar)
+{
+    if (pVar)
+    {
+        memset(pVar, 0, sizeof(*pVar));
+        AssertCompile(DBGCVAR_TYPE_UNKNOWN == 0);
+        AssertCompile(DBGCVAR_RANGE_NONE == 0);
+    }
+}
+
+
+/** @todo move me!*/
-void dbgcVarSetGCFlat(PDBGCVAR pVar, RTGCPTR GCFlat)
-{
@@ -58 +70 @@
-    {
-        pVar->enmType  = DBGCVAR_TYPE_GC_FLAT;
+        memset(&pVar->u, 0, sizeof(pVar->u));
-        pVar->u.GCFlat = GCFlat;
-        pVar->enmRangeType = DBGCVAR_RANGE_NONE;
@@ -71 +84 @@
-    {
-        pVar->enmType  = DBGCVAR_TYPE_GC_FLAT;
+        memset(&pVar->u, 0, sizeof(pVar->u));
-        pVar->u.GCFlat = GCFlat;
-        pVar->enmRangeType = DBGCVAR_RANGE_BYTES;
-        pVar->u64Range  = cb;
+    }
+}
+
+
+/** @todo move me!*/
+void dbgcVarSetU64(PDBGCVAR pVar, uint64_t u64)
+{
+    if (pVar)
+    {
+        pVar->enmType  = DBGCVAR_TYPE_NUMBER;
+        memset(&pVar->u, 0, sizeof(pVar->u));
+        pVar->u.u64Number = u64;
+        pVar->enmRangeType = DBGCVAR_RANGE_NONE;
+        pVar->u64Range  = 0;
-    }
-}
@@ -95 +123 @@
-}
-
+/** @todo move me!*/
+void dbgcVarSetDbgfAddr(PDBGCVAR pVar, PCDBGFADDRESS pAddress)
+{
+    if (pVar)
+    {
+        memset(&pVar->u, 0, sizeof(pVar->u));
+
+        Assert(!pAddress || DBGFADDRESS_IS_VALID(pAddress));
+        if (pAddress && DBGFADDRESS_IS_VALID(pAddress))
+        {
+            switch (pAddress->fFlags & DBGFADDRESS_FLAGS_TYPE_MASK)
+            {
+                case DBGFADDRESS_FLAGS_FAR16:
+                case DBGFADDRESS_FLAGS_FAR32:
+                case DBGFADDRESS_FLAGS_FAR64:
+                    pVar->enmType = DBGCVAR_TYPE_GC_FAR;
+                    pVar->u.GCFar.off = pAddress->off;
+                    pVar->u.GCFar.sel = pAddress->Sel;
+                    break;
+
+                case DBGFADDRESS_FLAGS_FLAT:
+                    pVar->enmType = DBGCVAR_TYPE_GC_FLAT;
+                    pVar->u.GCFlat = pAddress->FlatPtr;
+                    break;
+
+                case DBGFADDRESS_FLAGS_PHYS:
+                    pVar->enmType = DBGCVAR_TYPE_GC_PHYS;
+                    pVar->u.GCPhys = pAddress->FlatPtr;
+                    break;
+
+                default:
+                    AssertFailed();
+                    pVar->enmType = DBGCVAR_TYPE_UNKNOWN;
+                    break;
+            }
+        }
+        else
+            pVar->enmType = DBGCVAR_TYPE_UNKNOWN;
+        pVar->enmRangeType = DBGCVAR_RANGE_NONE;
+        pVar->u64Range = 0;
+    }
+}
+
-
-/** @todo move me!*/
@@ -141 +212 @@
-        case DBGCVAR_TYPE_GC_FAR:
-            return DBGFR3AddrFromSelOff(pDbgc->pVM, pAddress, pVar->u.GCFar.sel, pVar->u.GCFar.sel);
+
+        case DBGCVAR_TYPE_GC_PHYS:
+            DBGFR3AddrFromPhys(pDbgc->pVM, pAddress, pVar->u.GCPhys);
+            return VINF_SUCCESS;
-
-        case DBGCVAR_TYPE_STRING:
@@ -152 +227 @@
-        }
-
-        case DBGCVAR_TYPE_GC_PHYS:
-        case DBGCVAR_TYPE_HC_FLAT:
-        case DBGCVAR_TYPE_HC_FAR:

trunk/src/VBox/Debugger/DBGCEmulateCodeView.cpp

@@ -68 +68 @@
-static DECLCALLBACK(int) dbgcCmdRegTerse(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult);
-static DECLCALLBACK(int) dbgcCmdSearchMem(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult);
+static DECLCALLBACK(int) dbgcCmdSearchMemType(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult);
-static DECLCALLBACK(int) dbgcCmdStack(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult);
-static DECLCALLBACK(int) dbgcCmdTrace(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult);
@@ -229 +230 @@
-/** 's' arguments. */
-static const DBGCVARDESC    g_aArgSearchMem[] =
+{
+    /* cTimesMin,   cTimesMax,  enmCategory,            fFlags,                         pszName,        pszDescription */
+    {  0,           1,          DBGCVAR_CAT_OPTION,     0,                              "-b",           "Byte string." },
+    {  0,           1,          DBGCVAR_CAT_OPTION,     0,                              "-w",           "Word string." },
+    {  0,           1,          DBGCVAR_CAT_OPTION,     0,                              "-d",           "DWord string." },
+    {  0,           1,          DBGCVAR_CAT_OPTION,     0,                              "-q",           "QWord string." },
+    {  0,           1,          DBGCVAR_CAT_OPTION,     0,                              "-a",           "ASCII string." },
+    {  0,           1,          DBGCVAR_CAT_OPTION,     0,                              "-u",           "Unicode string." },
+    {  0,           1,          DBGCVAR_CAT_OPTION_NUMBER, 0,                           "-n <Hits>",    "Maximum number of hits." },
+    {  0,           1,          DBGCVAR_CAT_GC_POINTER, 0,                              "range",        "Register to show or set." },
+    {  0,           ~0,         DBGCVAR_CAT_ANY,        0,                              "pattern",      "Pattern to search for." },
+};
+
+
+/** 's?' arguments. */
+static const DBGCVARDESC    g_aArgSearchMemType[] =
-{
-    /* cTimesMin,   cTimesMax,  enmCategory,            fFlags,                         pszName,        pszDescription */
@@ -294 +311 @@
-    { "rh",         0,        2,        &g_aArgReg[0],      RT_ELEMENTS(g_aArgReg),        NULL,               0,       dbgcCmdRegHyper,    "[reg [newval]]",       "Show or set register(s) - hypervisor reg set." },
-    { "rt",         0,        0,        NULL,               0,                             NULL,               0,       dbgcCmdRegTerse,    "",                     "Toggles terse / verbose register info." },
-//{ "s",          2,       ~0,        &g_aArgSearchMem[0],RT_ELEMENTS(g_aArgSearchMem),  NULL,               0,       dbgcCmdSearchMem,   "<range> <pattern>",  
-[0],RT_ELEMENTS(g_aArgSearchMem),  NULL,               0,       dbgcCmdSearchMem
-[0],RT_ELEMENTS(g_aArgSearchMem),  NULL,               0,       dbgcCmdSearchMem
-[0],RT_ELEMENTS(g_aArgSearchMem),  NULL,               0,       dbgcCmdSearchMem
-[0],RT_ELEMENTS(g_aArgSearchMem),  NULL,               0,       dbgcCmdSearchMem
-[0],RT_ELEMENTS(g_aArgSearchMem),  NULL,               0,       dbgcCmdSearchMem
-[0],RT_ELEMENTS(g_aArgSearchMem),  NULL,               0,       dbgcCmdSearchMem
+{ "s",          0,       ~0,        &g_aArgSearchMem[0], RT_ELEMENTS(g_aArgSearchMem),  NULL,              0,       dbgcCmdSearchMem,   "[options] <range> <pattern>",
+Type[0], RT_ELEMENTS(g_aArgSearchMemType),  NULL,      0,       dbgcCmdSearchMemType
+Type[0], RT_ELEMENTS(g_aArgSearchMemType),  NULL,      0,       dbgcCmdSearchMemType
+Type[0], RT_ELEMENTS(g_aArgSearchMemType),  NULL,      0,       dbgcCmdSearchMemType
+Type[0], RT_ELEMENTS(g_aArgSearchMemType),  NULL,      0,       dbgcCmdSearchMemType
+Type[0], RT_ELEMENTS(g_aArgSearchMemType),  NULL,      0,       dbgcCmdSearchMemType
+Type[0], RT_ELEMENTS(g_aArgSearchMemType),  NULL,      0,       dbgcCmdSearchMemType
-    { "t",          0,        0,        NULL,               0,                             NULL,               0,       dbgcCmdTrace,       "",                     "Instruction trace (step into)." },
-    { "u",          0,        1,        &g_aArgUnassemble[0],RT_ELEMENTS(g_aArgUnassemble),NULL,               0,       dbgcCmdUnassemble,  "[addr]",               "Unassemble." },
@@ -2809 +2826 @@
-
-/**
+ * Converts one or more variables into a byte buffer for a
+ * given unit size.
+ *
+ * @returns VBox status codes:
+ * @retval  VERR_TOO_MUCH_DATA if the buffer is too small, bitched.
+ * @retval  VERR_INTERNAL_ERROR on bad variable type, bitched.
+ * @retval  VINF_SUCCESS on success.
+ *
+ * @param   pvBuf   The buffer to convert into.
+ * @param   pcbBuf  The buffer size on input. The size of the result on output.
+ * @param   cbUnit  The unit size to apply when converting.
+ * @param   paVars  The array of variables to convert.
+ * @param   cVars   The number of variables.
+ */
+int dbgcVarsToBytes(PDBGCCMDHLP pCmdHlp, void *pvBuf, uint32_t *pcbBuf, size_t cbUnit, PCDBGCVAR paVars, unsigned cVars)
+{
+    union
+    {
+        uint8_t *pu8;
+        uint16_t *pu16;
+        uint32_t *pu32;
+        uint64_t *pu64;
+    } u, uEnd;
+    u.pu8 = (uint8_t *)pvBuf;
+    uEnd.pu8 = u.pu8 + *pcbBuf;
+
+    unsigned i;
+    for (i = 0; i < cVars && u.pu8 < uEnd.pu8; i++)
+    {
+        switch (paVars[i].enmType)
+        {
+            case DBGCVAR_TYPE_GC_FAR:
+            case DBGCVAR_TYPE_HC_FAR:
+            case DBGCVAR_TYPE_GC_FLAT:
+            case DBGCVAR_TYPE_GC_PHYS:
+            case DBGCVAR_TYPE_HC_FLAT:
+            case DBGCVAR_TYPE_HC_PHYS:
+            case DBGCVAR_TYPE_NUMBER:
+            {
+                uint64_t u64 = paVars[i].u.u64Number;
+                switch (cbUnit)
+                {
+                    case 1:
+                        do
+                        {
+                            *u.pu8++ = u64;
+                            u64 >>= 8;
+                        } while (u64);
+                        break;
+                    case 2:
+                        do
+                        {
+                            *u.pu16++ = u64;
+                            u64 >>= 16;
+                        } while (u64);
+                        break;
+                    case 4:
+                        *u.pu32++ = u64;
+                        u64 >>= 32;
+                        if (u64)
+                            *u.pu32++ = u64;
+                        break;
+                    case 8:
+                        *u.pu64++ = u64;
+                        break;
+                }
+                break;
+            }
+
+            case DBGCVAR_TYPE_STRING:
+            case DBGCVAR_TYPE_SYMBOL:
+            {
+                const char *psz = paVars[i].u.pszString;
+                size_t cbString = strlen(psz);
+                if (cbString > (uintptr_t)(uEnd.pu8 - u.pu8))
+                    cbString = uEnd.pu8 - u.pu8;
+
+                size_t cbCopy = cbString & ~(cbUnit - 1);
+                memcpy(u.pu8, psz, cbCopy);
+                u.pu8 += cbCopy;
+                psz += cbCopy;
+
+                size_t cbReminder = cbString & (cbUnit - 1);
+                if (cbReminder)
+                {
+                    memcpy(u.pu8, psz, cbString & (cbUnit - 1));
+                    memset(u.pu8 + cbReminder, 0, cbUnit - cbReminder);
+                    u.pu8 += cbUnit;
+                }
+                break;
+            }
+
+            default:
+                *pcbBuf = u.pu8 - (uint8_t *)pvBuf;
+                pCmdHlp->pfnVBoxError(pCmdHlp, VERR_INTERNAL_ERROR,
+                                      "i=%d enmType=%d\n", i, paVars[i].enmType);
+                return VERR_INTERNAL_ERROR;
+        }
+    }
+    *pcbBuf = u.pu8 - (uint8_t *)pvBuf;
+    if (i != cVars)
+    {
+        pCmdHlp->pfnVBoxError(pCmdHlp, VERR_TOO_MUCH_DATA, "Max %d bytes.\n", uEnd.pu8 - (uint8_t *)pvBuf);
+        return VERR_TOO_MUCH_DATA;
+    }
+    return VINF_SUCCESS;
+}
+
+
+/**
+ * Executes the search.
+ *
+ * @returns VBox status code.
+ * @param   pCmdHlp     The command helpers.
+ * @param   pVM         The VM handle.
+ * @param   pAddress    The address to start searching from. (undefined on output)
+ * @param   cbRange     The address range to search. Must not wrap.
+ * @param   pabBytes    The byte pattern to search for.
+ * @param   cbBytes     The size of the pattern.
+ * @param   cbUnit      The search unit.
+ * @param   cMaxHits    The max number of hits.
+ * @param   pResult     Where to store the result if it's a function invocation.
+ */
+static int dbgcCmdWorkerSearchMemDoIt(PDBGCCMDHLP pCmdHlp, PVM pVM, PDBGFADDRESS pAddress, RTGCUINTPTR cbRange,
+                                      const uint8_t *pabBytes, uint32_t cbBytes,
+                                      uint32_t cbUnit, uint64_t cMaxHits, PDBGCVAR pResult)
+{
+    /*
+     * Do the search.
+     */
+    uint64_t cHits = 0;
+    for (;;)
+    {
+        /* search */
+        DBGFADDRESS HitAddress;
+        int rc = DBGFR3MemScan(pVM, pAddress, cbRange, pabBytes, cbBytes, &HitAddress);
+        if (RT_FAILURE(rc))
+        {
+            if (rc != VERR_DBGF_MEM_NOT_FOUND)
+                return pCmdHlp->pfnVBoxError(pCmdHlp, rc, "DBGFR3MemScan\n");
+
+            /* update the current address so we can save it (later). */
+            pAddress->off += cbRange;
+            pAddress->FlatPtr += cbRange;
+            cbRange = 0;
+            break;
+        }
+
+        /* report result */
+        DBGCVAR VarCur;
+        dbgcVarInit(&VarCur);
+        dbgcVarSetDbgfAddr(&VarCur, &HitAddress);
+        if (!pResult)
+            pCmdHlp->pfnExec(pCmdHlp, "db %DV LB 10", &VarCur);
+        else
+            dbgcVarSetDbgfAddr(pResult, &HitAddress);
+
+        /* advance */
+        cbRange -= HitAddress.FlatPtr - pAddress->FlatPtr;
+        *pAddress = HitAddress;
+        pAddress->FlatPtr += cbBytes;
+        pAddress->off += cbBytes;
+        if (cbRange <= cbBytes)
+        {
+            cbRange = 0;
+            break;
+        }
+        cbRange -= cbBytes;
+
+        if (++cHits >= cMaxHits)
+        {
+            /// @todo save the search.
+            break;
+        }
+    }
+
+    /*
+     * Save the search so we can resume it...
+     */
+    PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
+    if (pDbgc->abSearch != pabBytes)
+    {
+        memcpy(pDbgc->abSearch, pabBytes, cbBytes);
+        pDbgc->cbSearch = cbBytes;
+        pDbgc->cbSearchUnit = cbUnit;
+    }
+    pDbgc->cMaxSearchHits = cMaxHits;
+    pDbgc->SearchAddr = *pAddress;
+    pDbgc->cbSearchRange = cbRange;
+
+    return cHits ? VINF_SUCCESS : VERR_DBGC_COMMAND_FAILED;
+}
+
+
+/**
+ * Resumes the previous search.
+ *
+ * @returns VBox status code.
+ * @param   pCmdHlp     Pointer to the command helper functions.
+ * @param   pVM         Pointer to the current VM (if any).
+ * @param   pResult     Where to store the result of a function invocation.
+ */
+static int dbgcCmdWorkerSearchMemResume(PDBGCCMDHLP pCmdHlp, PVM pVM, PDBGCVAR pResult)
+{
+    PDBGC pDbgc = DBGC_CMDHLP2DBGC(pCmdHlp);
+
+    /*
+     * Make sure there is a previous command.
+     */
+    if (!pDbgc->cbSearch)
+    {
+        pCmdHlp->pfnPrintf(pCmdHlp, NULL, "Error: No previous search\n");
+        return VERR_DBGC_COMMAND_FAILED;
+    }
+
+    /*
+     * Make range and address adjustments.
+     */
+    DBGFADDRESS Address = pDbgc->SearchAddr;
+    if (Address.FlatPtr == ~(RTGCUINTPTR)0)
+    {
+        Address.FlatPtr -= Address.off;
+        Address.off = 0;
+    }
+
+    RTGCUINTPTR cbRange = pDbgc->cbSearchRange;
+    if (!cbRange)
+        cbRange = ~(RTGCUINTPTR)0;
+    if (Address.FlatPtr + cbRange < pDbgc->SearchAddr.FlatPtr)
+        cbRange = ~(RTGCUINTPTR)0 - pDbgc->SearchAddr.FlatPtr + !!pDbgc->SearchAddr.FlatPtr;
+
+    return dbgcCmdWorkerSearchMemDoIt(pCmdHlp, pVM, &Address, cbRange, pDbgc->abSearch, pDbgc->cbSearch,
+                                      pDbgc->cbSearchUnit, pDbgc->cMaxSearchHits, pResult);
+}
+
+
+/**
+ * Search memory, worker for the 's' and 's?' functions.
+ *
+ * @returns VBox status.
+ * @param   pCmdHlp     Pointer to the command helper functions.
+ * @param   pVM         Pointer to the current VM (if any).
+ * @param   pAddress    Where to start searching. If no range, search till end of address space.
+ * @param   cMaxHits    The maximum number of hits.
+ * @param   chType      The search type.
+ * @param   paPatArgs   The pattern variable array.
+ * @param   cPatArgs    Number of pattern variables.
+ * @param   pResult     Where to store the result of a function invocation.
+ */
+static int dbgcCmdWorkerSearchMem(PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR pAddress, uint64_t cMaxHits, char chType,
+                                  PCDBGCVAR paPatArgs, unsigned cPatArgs, PDBGCVAR pResult)
+{
+    dbgcVarSetGCFlat(pResult, 0);
+
+    /*
+     * Convert the search pattern into bytes and DBGFR3MemScan can deal with.
+     */
+    uint32_t cbUnit;
+    switch (chType)
+    {
+        case 'a':
+        case 'b':   cbUnit = 1; break;
+        case 'u':
+        case 'w':   cbUnit = 2; break;
+        case 'd':   cbUnit = 4; break;
+        case 'q':   cbUnit = 8; break;
+        default:
+            return pCmdHlp->pfnVBoxError(pCmdHlp, VERR_INVALID_PARAMETER, "chType=%c\n", chType);
+    }
+    uint8_t abBytes[RT_SIZEOFMEMB(DBGC, abSearch)];
+    uint32_t cbBytes = sizeof(abBytes);
+    int rc = dbgcVarsToBytes(pCmdHlp, abBytes, &cbBytes, cbUnit, paPatArgs, cPatArgs);
+    if (RT_FAILURE(rc))
+        return VERR_DBGC_COMMAND_FAILED;
+
+    /*
+     * Make DBGF address and fix the range.
+     */
+    DBGFADDRESS Address;
+    rc = pCmdHlp->pfnVarToDbgfAddr(pCmdHlp, pAddress, &Address);
+    if (RT_FAILURE(rc))
+        return pCmdHlp->pfnVBoxError(pCmdHlp, rc, "VarToDbgfAddr(,%Dv,)\n", pAddress);
+
+    RTGCUINTPTR cbRange;
+    switch (pAddress->enmRangeType)
+    {
+        case DBGCVAR_RANGE_BYTES:
+            cbRange = pAddress->u64Range;
+            if (cbRange != pAddress->u64Range)
+                cbRange = ~(RTGCUINTPTR)0;
+            break;
+
+        case DBGCVAR_RANGE_ELEMENTS:
+            cbRange = (RTGCUINTPTR)(pAddress->u64Range * cbUnit);
+            if (    cbRange != pAddress->u64Range * cbUnit
+                ||  cbRange < pAddress->u64Range)
+                cbRange = ~(RTGCUINTPTR)0;
+            break;
+
+        default:
+            cbRange = ~(RTGCUINTPTR)0;
+            break;
+    }
+    if (Address.FlatPtr + cbRange < Address.FlatPtr)
+        cbRange = ~(RTGCUINTPTR)0 - Address.FlatPtr + !!Address.FlatPtr;
+
+    /*
+     * Ok, do it.
+     */
+    return dbgcCmdWorkerSearchMemDoIt(pCmdHlp, pVM, &Address, cbRange, abBytes, cbBytes, cbUnit, cMaxHits, pResult);
+}
+
+
+/**
- * The 's' command.
- *
@@ -2821 +3152 @@
-{
-    /* check that the parser did what it's supposed to do. */
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-        return pCmdHlp->pfnPrintf(pCmdHlp, NULL, "parser error\n");
--1
+dbgcCmdWorkerSearchMem(pCmdHlp, pVM, &paArgs[0], pResult ? 1 : 80, pCmd->pszCmd[1], paArgs + 1, cArgs - 1, pResult)
-}
-

trunk/src/VBox/Debugger/DBGCInternal.h

@@ -64 +64 @@
-#define VERR_DBGC_BP_EXISTS                     (-12004)
-#define VINF_DBGC_BP_NO_COMMAND                 12005
+#define VERR_DBGC_COMMAND_FAILED                (-12006)
-
-
@@ -159 +160 @@
-    /** The list of breakpoints. (singly linked) */
-    PDBGCBP             pFirstBp;
+
+    /** Save search pattern. */
+    uint8_t             abSearch[256];
+    /** The length of the search pattern. */
+    uint32_t            cbSearch;
+    /** The search unit */
+    uint32_t            cbSearchUnit;
+    /** The max hits. */
+    uint64_t            cMaxSearchHits;
+    /** The address to resume searching from. */
+    DBGFADDRESS         SearchAddr;
+    /** What's left of the original search range. */
+    RTGCUINTPTR         cbSearchRange;
-
-    /** @name Parsing and Execution
@@ -337 +351 @@
-int     dbgcBpExec(PDBGC pDbgc, RTUINT iBp);
-
+void    dbgcVarInit(PDBGCVAR pVar);
-void    dbgcVarSetGCFlat(PDBGCVAR pVar, RTGCPTR GCFlat);
-void    dbgcVarSetGCFlatByteRange(PDBGCVAR pVar, RTGCPTR GCFlat, uint64_t cb);
+void    dbgcVarSetU64(PDBGCVAR pVar, uint64_t u64);
-void    dbgcVarSetVar(PDBGCVAR pVar, PCDBGCVAR pVar2);
+void    dbgcVarSetDbgfAddr(PDBGCVAR pVar, PCDBGFADDRESS pAddress);
-void    dbgcVarSetNoRange(PDBGCVAR pVar);
-void    dbgcVarSetByteRange(PDBGCVAR pVar, uint64_t cb);

trunk/src/VBox/Debugger/DBGConsole.cpp

@@ -1260 +1260 @@
-            rc = pCmd->pfnHandler(pCmd, &pDbgc->CmdHlp, pDbgc->pVM, &pDbgc->aArgs[0], cArgs, NULL);
-        pDbgc->rcCmd = rc;
+        if (rc == VERR_DBGC_COMMAND_FAILED)
+            rc = VINF_SUCCESS;
-    }
-    else
@@ -1343 +1345 @@
-                rc = pDbgc->CmdHlp.pfnPrintf(&pDbgc->CmdHlp, NULL,
-                    "Error: Cannot get symbol, it's set only (argument %d).\n", cArgs);
+                break;
+
+            case VERR_DBGC_COMMAND_FAILED:
+                rc = VINF_SUCCESS;
-                break;
-
@@ -1355 +1361 @@
-         */
-        if (rc >= VERR_PARSE_FIRST && rc < VERR_PARSE_LAST)
-0
+VINF_SUCCESS
-    }
-
@@ -1941 +1947 @@
-    //pDbgc->paVars           = NULL;
-    //pDbgc->pFirstBp         = NULL;
+    //pDbgc->abSearch         = {0};
+    //pDbgc->cbSearch         = 0;
+    pDbgc->cbSearchUnit       = 1;
+    pDbgc->cMaxSearchHits     = 1;
+    //pDbgc->SearchAddr       = {0};
+    //pDbgc->cbSearchRange    = 0;
+
-    //pDbgc->uInputZero       = 0;
-    //pDbgc->iRead            = 0;

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

@@ -275 +275 @@
-    return VERR_INTERNAL_ERROR;
-}
-
+
+
+
+
+
+
+

trunk/src/VBox/VMM/DBGFMem.cpp

@@ -84 +84 @@
- * Scan guest memory for an exact byte string.
- *
-
+
+
+
+
+
+
- * @param   pVM         The VM handle.
- * @param   pAddress    Where to store the mixed address.

trunk/src/VBox/VMM/PGMDbg.cpp

@@ -264 +264 @@
-            break;
-        cb = pbEnd - pb;
-<
+>
-        {
-            /* match? */
@@ -325 +325 @@
-    if (!cbNeedle)
-        return VERR_INVALID_PARAMETER;
-Rang
+Needl
-        return VERR_INVALID_PARAMETER;
-
@@ -370 +370 @@
-            {
-                PPGMPAGE pPage = &pRam->aPages[iPage];
-
-
+/** @todo 
+*/
-                {
-                    void const *pvPage;
@@ -437 +437 @@
-    if (!cbNeedle)
-        return VERR_INVALID_PARAMETER;
-Rang
+Needl
-        return VERR_INVALID_PARAMETER;
-
@@ -456 +456 @@
-    while (cPages-- > 0)
-    {
-        uint64_t fFlags;
-        RTGCPHYS GCPhys;
-GstGetPage(pVM, GCPtr, &fFlags
+PhysGCPtr2GCPhys(pVM, GCPtr
-        if (RT_SUCCESS(rc))
-        {
-            PPGMPAGE pPage = pgmPhysGetPage(&pVM->pgm.s, GCPhys);
-            if (    pPage
-
+///@todo 
-                &&  !PGM_PAGE_IS_MMIO(pPage))
-            {
-                void const *pvPage;
-                PGMPAGEMAPLOCK Lock;
-tr
+hys
-                if (RT_SUCCESS(rc))
-                {