VirtualBox

Changeset 24061 in vbox


Ignore:
Timestamp:
Oct 25, 2009 11:54:32 PM (15 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
53923
Message:

DBGF,DBGPlugInDiggers: Extended DBGFR3MemScan with an alignment restriction. Added DBGFR3CpuGetMode. Started on the WinNT debug digger - can detect the 32-bit kernel, locate the module list and report the nt version.

Location:
trunk
Files:
1 added
9 edited

Legend:

Unmodified
Added
Removed

  • trunk/include/VBox/cpum.h

    r23794 r24061  
    963963VMMDECL(uint32_t)       CPUMGetGuestCPL(PVMCPU pVCpu, PCPUMCTXCORE pCtxCore);
    964964VMMDECL(bool)           CPUMAreHiddenSelRegsValid(PVM pVM);
    965 
    966 /**
    967  * CPU modes.
    968  */
    969 typedef enum CPUMMODE
    970 {
    971     /** The usual invalid zero entry. */
    972     CPUMMODE_INVALID = 0,
    973     /** Real mode. */
    974     CPUMMODE_REAL,
    975     /** Protected mode (32-bit). */
    976     CPUMMODE_PROTECTED,
    977     /** Long mode (64-bit). */
    978     CPUMMODE_LONG
    979 } CPUMMODE;
    980 
    981 VMMDECL(CPUMMODE)  CPUMGetGuestMode(PVMCPU pVCpu);
     965VMMDECL(CPUMMODE)       CPUMGetGuestMode(PVMCPU pVCpu);
    982966
    983967

  • trunk/include/VBox/dbgf.h

    r22112 r24061  
    410410VMMDECL(RTGCUINTREG)    DBGFBpGetDR3(PVM pVM);
    411411VMMDECL(bool)           DBGFIsStepping(PVMCPU pVCpu);
     412
     413
     414
     415VMMR3DECL(CPUMMODE)     DBGFR3CpuGetMode(PVM pVM, VMCPUID idCpu);
    412416
    413417
    … …  
    885889
    886890
    887 VMMR3DECL(int) DBGFR3MemScan(PVM pVM, VMCPUID idCpu, PCDBGFADDRESS pAddress, RTGCUINTPTR cbRange, const uint8_t *pabNeedle, size_t cbNeedle, PDBGFADDRESS pHitAddress);
     891VMMR3DECL(int) DBGFR3MemScan(PVM pVM, VMCPUID idCpu, PCDBGFADDRESS pAddress, RTGCUINTPTR cbRange, RTGCUINTPTR uAlign,
     892                             const void *pvNeedle, size_t cbNeedle, PDBGFADDRESS pHitAddress);
    888893VMMR3DECL(int) DBGFR3MemRead(PVM pVM, VMCPUID idCpu, PCDBGFADDRESS pAddress, void *pvBuf, size_t cbRead);
    889894VMMR3DECL(int) DBGFR3MemReadString(PVM pVM, VMCPUID idCpu, PCDBGFADDRESS pAddress, char *pszBuf, size_t cbBuf);

  • trunk/include/VBox/pgm.h

    r23460 r24061  
    545545VMMR3DECL(int)      PGMR3DbgReadGCPtr(PVM pVM, void *pvDst, RTGCPTR GCPtrSrc, size_t cb, uint32_t fFlags, size_t *pcbRead);
    546546VMMR3DECL(int)      PGMR3DbgWriteGCPtr(PVM pVM, RTGCPTR GCPtrDst, void const *pvSrc, size_t cb, uint32_t fFlags, size_t *pcbWritten);
    547 VMMR3DECL(int)      PGMR3DbgScanPhysical(PVM pVM, RTGCPHYS GCPhys, RTGCPHYS cbRange, const uint8_t *pabNeedle, size_t cbNeedle, PRTGCPHYS pGCPhysHit);
    548 VMMR3DECL(int)      PGMR3DbgScanVirtual(PVM pVM, PVMCPU pVCpu, RTGCPTR GCPtr, RTGCPTR cbRange, const uint8_t *pabNeedle, size_t cbNeedle, PRTGCUINTPTR pGCPhysHit);
     547VMMR3DECL(int)      PGMR3DbgScanPhysical(PVM pVM, RTGCPHYS GCPhys, RTGCPHYS cbRange, RTGCPHYS GCPhysAlign, const uint8_t *pabNeedle, size_t cbNeedle, PRTGCPHYS pGCPhysHit);
     548VMMR3DECL(int)      PGMR3DbgScanVirtual(PVM pVM, PVMCPU pVCpu, RTGCPTR GCPtr, RTGCPTR cbRange, RTGCPTR GCPtrAlign, const uint8_t *pabNeedle, size_t cbNeedle, PRTGCUINTPTR pGCPhysHit);
    549549/** @} */
    550550#endif /* IN_RING3 */

  • trunk/include/VBox/types.h

    r23598 r24061  
    795795typedef struct CFGMLEAF *PCFGMLEAF;
    796796
     797/**
     798 * CPU modes.
     799 */
     800typedef enum CPUMMODE
     801{
     802    /** The usual invalid zero entry. */
     803    CPUMMODE_INVALID = 0,
     804    /** Real mode. */
     805    CPUMMODE_REAL,
     806    /** Protected mode (32-bit). */
     807    CPUMMODE_PROTECTED,
     808    /** Long mode (64-bit). */
     809    CPUMMODE_LONG
     810} CPUMMODE;
    797811
    798812/** @} */

  • trunk/include/iprt/err.h

    r23693 r24061  
    605605/** Authentication failure. */
    606606#define VERR_AUTHENTICATION_FAILURE         (-89)
     607/** Not a power of two. */
     608#define VERR_NOT_POWER_OF_TWO               (-90)
    607609/** @} */
    608610

  • trunk/src/VBox/VMM/DBGFMem.cpp

    • Property svn:keywords changed from Id to Author Date Id Revision
    r23012 r24061  
    4444 * @param   idCpu       The ID of the CPU context to search in.
    4545 * @param   pAddress    Where to store the mixed address.
     46 * @param   pu64Align   The alignment restriction imposed on the search result.
    4647 * @param   pcbRange    The number of bytes to scan. Passed as a pointer because
    4748 *                      it may be 64-bit.
    … …  
    5051 * @param   pHitAddress Where to put the address of the first hit.
    5152 */
    52 static DECLCALLBACK(int) dbgfR3MemScan(PVM pVM, VMCPUID idCpu, PCDBGFADDRESS pAddress, PCRTGCUINTPTR pcbRange,
     53static DECLCALLBACK(int) dbgfR3MemScan(PVM pVM, VMCPUID idCpu, PCDBGFADDRESS pAddress, PCRTGCUINTPTR pcbRange, RTGCUINTPTR *puAlign,
    5354                                       const uint8_t *pabNeedle, size_t cbNeedle, PDBGFADDRESS pHitAddress)
    5455{
    … …  
    7778        )
    7879    {
     80        RTGCPHYS GCPhysAlign = *puAlign;
     81        if (GCPhysAlign != *puAlign)
     82            return VERR_OUT_OF_RANGE;
    7983        RTGCPHYS PhysHit;
    80         rc = PGMR3DbgScanPhysical(pVM, pAddress->FlatPtr, cbRange, pabNeedle, cbNeedle, &PhysHit);
     84        rc = PGMR3DbgScanPhysical(pVM, pAddress->FlatPtr, cbRange, GCPhysAlign, pabNeedle, cbNeedle, &PhysHit);
    8185        if (RT_SUCCESS(rc))
    8286            DBGFR3AddrFromPhys(pVM, pHitAddress, PhysHit);
    … …  
    9296#endif
    9397        RTGCUINTPTR GCPtrHit;
    94         rc = PGMR3DbgScanVirtual(pVM, pVCpu, pAddress->FlatPtr, cbRange, pabNeedle, cbNeedle, &GCPtrHit);
     98        rc = PGMR3DbgScanVirtual(pVM, pVCpu, pAddress->FlatPtr, cbRange, *puAlign, pabNeedle, cbNeedle, &GCPtrHit);
    9599        if (RT_SUCCESS(rc))
    96100            DBGFR3AddrFromFlat(pVM, pHitAddress, GCPtrHit);
    … …  
    114118 * @param   pAddress    Where to store the mixed address.
    115119 * @param   cbRange     The number of bytes to scan.
    116  * @param   pabNeedle   What to search for - exact search.
     120 * @param   uAlign      The alignment restriction imposed on the result.
     121 *                      Usually set to 1.
     122 * @param   pvNeedle    What to search for - exact search.
    117123 * @param   cbNeedle    Size of the search byte string.
    118124 * @param   pHitAddress Where to put the address of the first hit.
    … …  
    120126 * @thread  Any thread.
    121127 */
    122 VMMR3DECL(int) DBGFR3MemScan(PVM pVM, VMCPUID idCpu, PCDBGFADDRESS pAddress, RTGCUINTPTR cbRange, const uint8_t *pabNeedle, size_t cbNeedle, PDBGFADDRESS pHitAddress)
     128VMMR3DECL(int) DBGFR3MemScan(PVM pVM, VMCPUID idCpu, PCDBGFADDRESS pAddress, RTGCUINTPTR cbRange, RTGCUINTPTR uAlign,
     129                             const void *pvNeedle, size_t cbNeedle, PDBGFADDRESS pHitAddress)
    123130{
    124131    AssertReturn(idCpu < pVM->cCpus, VERR_INVALID_PARAMETER);
    125     return VMR3ReqCallWait(pVM, idCpu, (PFNRT)dbgfR3MemScan, 7,
    126                            pVM, idCpu, pAddress, &cbRange, pabNeedle, cbNeedle, pHitAddress);
     132    return VMR3ReqCallWait(pVM, idCpu, (PFNRT)dbgfR3MemScan, 8,
     133                           pVM, idCpu, pAddress, &cbRange, &uAlign, pvNeedle, cbNeedle, pHitAddress);
    127134
    128135}

  • trunk/src/VBox/VMM/Makefile.kmk

    r23452 r24061  
    7878        DBGFAddrSpace.cpp \
    7979        DBGFBp.cpp \
     80        DBGFCpu.cpp \
    8081        DBGFDisas.cpp \
    8182        DBGFInfo.cpp \

  • trunk/src/VBox/VMM/PGMDbg.cpp

    r20947 r24061  
    337337
    338338
     339/**
     340 * memchr() with alignment considerations.
     341 *
     342 * @returns Pointer to matching byte, NULL if none found.
     343 * @param   pb                  Where to search. Aligned.
     344 * @param   b                   What to search for.
     345 * @param   cb                  How much to search .
     346 * @param   uAlign              The alignment restriction of the result.
     347 */
     348static const uint8_t *pgmR3DbgAlignedMemChr(const uint8_t *pb, uint8_t b, size_t cb, uint32_t uAlign)
     349{
     350    const uint8_t *pbRet;
     351    if (uAlign <= 32)
     352    {
     353        pbRet = (const uint8_t *)memchr(pb, b, cb);
     354        if ((uintptr_t)pbRet & (uAlign - 1))
     355        {
     356            do
     357            {
     358                pbRet++;
     359                size_t cbLeft = cb - (pbRet - pb);
     360                if (!cbLeft)
     361                {
     362                    pbRet = NULL;
     363                    break;
     364                }
     365                pbRet = (const uint8_t *)memchr(pbRet, b, cbLeft);
     366            } while ((uintptr_t)pbRet & (uAlign - 1));
     367        }
     368    }
     369    else
     370    {
     371        pbRet = NULL;
     372        if (cb)
     373        {
     374            for (;;)
     375            {
     376                if (*pb == b)
     377                {
     378                    pbRet = pb;
     379                    break;
     380                }
     381                if (cb <= uAlign)
     382                    break;
     383                cb -= uAlign;
     384                pb += uAlign;
     385            }
     386        }
     387    }
     388    return pbRet;
     389}
     390
    339391
    340392/**
    … …  
    345397 *          false on mismatch.
    346398 * @param   pbPage          Pointer to the current page.
    347  * @param   poff            Input: The offset into the page.
     399 * @param   poff            Input: The offset into the page (aligned).
    348400 *                          Output: The page offset of the match on success.
    349401 * @param   cb              The number of bytes to search, starting of *poff.
     402 * @param   uAlign          The needle alignment. This is of course less than a page.
    350403 * @param   pabNeedle       The byte string to search for.
    351404 * @param   cbNeedle        The length of the byte string.
    … …  
    357410 *                          Initialize to 0 before the first call to this function.
    358411 */
    359 static bool pgmR3DbgScanPage(const uint8_t *pbPage, int32_t *poff, uint32_t cb,
     412static bool pgmR3DbgScanPage(const uint8_t *pbPage, int32_t *poff, uint32_t cb, uint32_t uAlign,
    360413                             const uint8_t *pabNeedle, size_t cbNeedle,
    361414                             uint8_t *pabPrev, size_t *pcbPrev)
    … …  
    379432        /* check out the remainder of the previous page. */
    380433        const uint8_t *pb = pabPrev;
    381         while (cbPrev-- > 0)
    382         {
    383             pb = (const uint8_t *)memchr(pb + 1, *pabNeedle, cbPrev);
     434        for (;;)
     435        {
     436            if (cbPrev <= uAlign)
     437                break;
     438            cbPrev -= uAlign;
     439            pb = pgmR3DbgAlignedMemChr(pb + uAlign, *pabNeedle, cbPrev, uAlign);
    384440            if (!pb)
    385441                break;
    … …  
    405461    for (;;)
    406462    {
    407         pb = (const uint8_t *)memchr(pb, *pabNeedle, cb);
     463        pb = pgmR3DbgAlignedMemChr(pb, *pabNeedle, cb, uAlign);
    408464        if (!pb)
    409465            break;
    … …  
    430486        }
    431487
    432         /* no match, skip a byte ahead. */
    433         if (cb <= 1)
     488        /* no match, skip ahead. */
     489        if (cb <= uAlign)
    434490            break;
    435         pb++;
    436         cb--;
     491        pb += uAlign;
     492        cb -= uAlign;
    437493    }
    438494
    … …  
    453509 * @param   GCPhys          Where to start searching.
    454510 * @param   cbRange         The number of bytes to search.
     511 * @param   GCPhysAlign     The alignment of the needle. Must be a power of two
     512 *                          and less or equal to 4GB.
    455513 * @param   pabNeedle       The byte string to search for.
    456514 * @param   cbNeedle        The length of the byte string. Max 256 bytes.
    457515 * @param   pGCPhysHit      Where to store the address of the first occurence on success.
    458516 */
    459 VMMR3DECL(int) PGMR3DbgScanPhysical(PVM pVM, RTGCPHYS GCPhys, RTGCPHYS cbRange, const uint8_t *pabNeedle, size_t cbNeedle, PRTGCPHYS pGCPhysHit)
     517VMMR3DECL(int) PGMR3DbgScanPhysical(PVM pVM, RTGCPHYS GCPhys, RTGCPHYS cbRange, RTGCPHYS GCPhysAlign,
     518                                    const uint8_t *pabNeedle, size_t cbNeedle, PRTGCPHYS pGCPhysHit)
    460519{
    461520    /*
    … …  
    479538        return VERR_DBGF_MEM_NOT_FOUND;
    480539
    481     const RTGCPHYS GCPhysLast = GCPhys + cbRange - 1 >= GCPhys
    482                               ? GCPhys + cbRange - 1
    483                               : ~(RTGCPHYS)0;
     540    if (!GCPhysAlign)
     541        return VERR_INVALID_PARAMETER;
     542    if (GCPhysAlign > UINT32_MAX)
     543        return VERR_NOT_POWER_OF_TWO;
     544    if (GCPhysAlign & (GCPhysAlign - 1))
     545        return VERR_INVALID_PARAMETER;
     546
     547    if (GCPhys & (GCPhysAlign - 1))
     548    {
     549        RTGCPHYS Adj = GCPhysAlign - (GCPhys & (GCPhysAlign - 1));
     550        if (    cbRange <= Adj
     551            ||  GCPhys + Adj < GCPhys)
     552            return VERR_DBGF_MEM_NOT_FOUND;
     553        GCPhys  += Adj;
     554        cbRange -= Adj;
     555    }
     556
     557    const bool      fAllZero   = ASMMemIsAll8(pabNeedle, cbNeedle, 0) == NULL;
     558    const uint32_t  cIncPages  = GCPhysAlign <= PAGE_SIZE
     559                               ? 1
     560                               : GCPhysAlign >> PAGE_SHIFT;
     561    const RTGCPHYS  GCPhysLast = GCPhys + cbRange - 1 >= GCPhys
     562                               ? GCPhys + cbRange - 1
     563                               : ~(RTGCPHYS)0;
    484564
    485565    /*
    … …  
    511591             * Iterate the relevant pages.
    512592             */
    513             uint8_t abPrev[MAX_NEEDLE_SIZE];
    514             size_t  cbPrev = 0;
    515             const uint32_t cPages = pRam->cb >> PAGE_SHIFT;
    516             for (uint32_t iPage = off >> PAGE_SHIFT; iPage < cPages; iPage++)
     593            uint8_t         abPrev[MAX_NEEDLE_SIZE];
     594            size_t          cbPrev   = 0;
     595            const uint32_t  cPages   = pRam->cb >> PAGE_SHIFT;
     596            uint32_t        iPage    = off >> PAGE_SHIFT;
     597            uint32_t        offPage  = GCPhys & PAGE_OFFSET_MASK;
     598            GCPhys &= ~(RTGCPHYS)PAGE_OFFSET_MASK;
     599            for (;; offPage = 0)
    517600            {
    518601                PPGMPAGE pPage = &pRam->aPages[iPage];
    519                 if (    !PGM_PAGE_IS_ZERO(pPage)
     602                if (    (   !PGM_PAGE_IS_ZERO(pPage)
     603                         || fAllZero)
    520604                    &&  !PGM_PAGE_IS_MMIO(pPage))
    521605                {
    522                     void const *pvPage;
    523                     PGMPAGEMAPLOCK Lock;
    524                     int rc = PGMPhysGCPhys2CCPtrReadOnly(pVM, GCPhys & ~(RTGCPHYS)PAGE_OFFSET_MASK, &pvPage, &Lock);
     606                    void const     *pvPage;
     607                    PGMPAGEMAPLOCK  Lock;
     608                    int rc = PGMPhysGCPhys2CCPtrReadOnly(pVM, GCPhys, &pvPage, &Lock);
    525609                    if (RT_SUCCESS(rc))
    526610                    {
    527                         int32_t  offPage = (GCPhys & PAGE_OFFSET_MASK);
    528                         uint32_t cbSearch = (GCPhys ^ GCPhysLast) & ~(RTGCPHYS)PAGE_OFFSET_MASK
    529                                           ? PAGE_SIZE                           - (uint32_t)offPage
    530                                           : (GCPhysLast & PAGE_OFFSET_MASK) + 1 - (uint32_t)offPage;
    531                         bool fRc = pgmR3DbgScanPage((uint8_t const *)pvPage, &offPage, cbSearch,
    532                                                     pabNeedle, cbNeedle, &abPrev[0], &cbPrev);
     611                        int32_t     offHit = offPage;
     612                        bool        fRc;
     613                        if (GCPhysAlign < PAGE_SIZE)
     614                        {
     615                            uint32_t cbSearch = (GCPhys ^ GCPhysLast) & ~(RTGCPHYS)PAGE_OFFSET_MASK
     616                                              ? PAGE_SIZE                           - (uint32_t)offPage
     617                                              : (GCPhysLast & PAGE_OFFSET_MASK) + 1 - (uint32_t)offPage;
     618                            fRc = pgmR3DbgScanPage((uint8_t const *)pvPage, &offHit, cbSearch, (uint32_t)GCPhysAlign,
     619                                                   pabNeedle, cbNeedle, &abPrev[0], &cbPrev);
     620                        }
     621                        else
     622                            fRc = memcmp(pvPage, pabNeedle, cbNeedle) == 0
     623                               && (GCPhysLast - GCPhys) >= cbNeedle;
    533624                        PGMPhysReleasePageMappingLock(pVM, &Lock);
    534625                        if (fRc)
    535626                        {
    536                             *pGCPhysHit = (GCPhys & ~(RTGCPHYS)PAGE_OFFSET_MASK) + offPage;
     627                            *pGCPhysHit = GCPhys + offHit;
    537628                            pgmUnlock(pVM);
    538629                            return VINF_SUCCESS;
    … …  
    546637
    547638                /* advance to the next page. */
    548                 GCPhys |= PAGE_OFFSET_MASK;
    549                 if (GCPhys++ >= GCPhysLast)
     639                GCPhys += (RTGCPHYS)cIncPages << PAGE_SHIFT;
     640                if (GCPhys >= GCPhysLast) /* (may not always hit, but we're run out of ranges.) */
    550641                {
    551642                    pgmUnlock(pVM);
    552643                    return VERR_DBGF_MEM_NOT_FOUND;
    553644                }
     645                iPage += cIncPages;
     646                if (    iPage < cIncPages
     647                    ||  iPage >= cPages)
     648                    break;
    554649            }
    555650        }
    … …  
    572667 * @param   pVCpu           The CPU context to search in.
    573668 * @param   GCPtr           Where to start searching.
     669 * @param   GCPtrAlign      The alignment of the needle. Must be a power of two
     670 *                          and less or equal to 4GB.
    574671 * @param   cbRange         The number of bytes to search. Max 256 bytes.
    575672 * @param   pabNeedle       The byte string to search for.
    … …  
    577674 * @param   pGCPtrHit       Where to store the address of the first occurence on success.
    578675 */
    579 VMMR3DECL(int) PGMR3DbgScanVirtual(PVM pVM, PVMCPU pVCpu, RTGCPTR GCPtr, RTGCPTR cbRange, const uint8_t *pabNeedle, size_t cbNeedle, PRTGCUINTPTR pGCPtrHit)
     676VMMR3DECL(int) PGMR3DbgScanVirtual(PVM pVM, PVMCPU pVCpu, RTGCPTR GCPtr, RTGCPTR cbRange, RTGCPTR GCPtrAlign,
     677                                   const uint8_t *pabNeedle, size_t cbNeedle, PRTGCUINTPTR pGCPtrHit)
    580678{
    581679    VMCPU_ASSERT_EMT(pVCpu);
    … …  
    600698        return VERR_DBGF_MEM_NOT_FOUND;
    601699
     700    if (!GCPtrAlign)
     701        return VERR_INVALID_PARAMETER;
     702    if (GCPtrAlign > UINT32_MAX)
     703        return VERR_NOT_POWER_OF_TWO;
     704    if (GCPtrAlign & (GCPtrAlign - 1))
     705        return VERR_INVALID_PARAMETER;
     706
     707    if (GCPtr & (GCPtrAlign - 1))
     708    {
     709        RTGCPTR Adj = GCPtrAlign - (GCPtr & (GCPtrAlign - 1));
     710        if (    cbRange <= Adj
     711            ||  GCPtr + Adj < GCPtr)
     712            return VERR_DBGF_MEM_NOT_FOUND;
     713        GCPtr   += Adj;
     714        cbRange -= Adj;
     715    }
     716
    602717    /*
    603718     * Search the memory - ignore MMIO, zero and not-present pages.
    604719     */
     720    const bool      fAllZero  = ASMMemIsAll8(pabNeedle, cbNeedle, 0) == NULL;
    605721    PGMMODE         enmMode   = PGMGetGuestMode(pVCpu);
    606722    RTGCPTR         GCPtrMask = PGMMODE_IS_LONG_MODE(enmMode) ? UINT64_MAX : UINT32_MAX;
    607723    uint8_t         abPrev[MAX_NEEDLE_SIZE];
    608724    size_t          cbPrev    = 0;
     725    const uint32_t  cIncPages = GCPtrAlign <= PAGE_SIZE
     726                              ? 1
     727                              : GCPtrAlign >> PAGE_SHIFT;
    609728    const RTGCPTR   GCPtrLast = GCPtr + cbRange - 1 >= GCPtr
    610729                              ? (GCPtr + cbRange - 1) & GCPtrMask
    611730                              : GCPtrMask;
    612731    RTGCPTR         cPages    = (((GCPtrLast - GCPtr) + (GCPtr & PAGE_OFFSET_MASK)) >> PAGE_SHIFT) + 1;
    613     while (cPages-- > 0)
     732    uint32_t        offPage   = GCPtr & PAGE_OFFSET_MASK;
     733    GCPtr &= ~(RTGCPTR)PAGE_OFFSET_MASK;
     734    for (;; offPage = 0)
    614735    {
    615736        RTGCPHYS GCPhys;
    … …  
    619740            PPGMPAGE pPage = pgmPhysGetPage(&pVM->pgm.s, GCPhys);
    620741            if (    pPage
    621                 &&  !PGM_PAGE_IS_ZERO(pPage) /** @todo handle all zero needle. */
     742                &&  (   !PGM_PAGE_IS_ZERO(pPage)
     743                     || fAllZero)
    622744                &&  !PGM_PAGE_IS_MMIO(pPage))
    623745            {
    624746                void const *pvPage;
    625747                PGMPAGEMAPLOCK Lock;
    626                 rc = PGMPhysGCPhys2CCPtrReadOnly(pVM, GCPhys & ~(RTGCPTR)PAGE_OFFSET_MASK, &pvPage, &Lock);
     748                rc = PGMPhysGCPhys2CCPtrReadOnly(pVM, GCPhys, &pvPage, &Lock);
    627749                if (RT_SUCCESS(rc))
    628750                {
    629                     int32_t  offPage = (GCPtr & PAGE_OFFSET_MASK);
    630                     uint32_t cbSearch = cPages > 0
    631                                       ? PAGE_SIZE                          - (uint32_t)offPage
    632                                       : (GCPtrLast & PAGE_OFFSET_MASK) + 1 - (uint32_t)offPage;
    633                     bool fRc = pgmR3DbgScanPage((uint8_t const *)pvPage, &offPage, cbSearch,
    634                                                 pabNeedle, cbNeedle, &abPrev[0], &cbPrev);
     751                    int32_t offHit = offPage;
     752                    bool    fRc;
     753                    if (GCPtrAlign < PAGE_SIZE)
     754                    {
     755                        uint32_t cbSearch = cPages > 0
     756                                          ? PAGE_SIZE                          - (uint32_t)offPage
     757                                          : (GCPtrLast & PAGE_OFFSET_MASK) + 1 - (uint32_t)offPage;
     758                        fRc = pgmR3DbgScanPage((uint8_t const *)pvPage, &offHit, cbSearch, (uint32_t)GCPtrAlign,
     759                                               pabNeedle, cbNeedle, &abPrev[0], &cbPrev);
     760                    }
     761                    else
     762                        fRc = memcmp(pvPage, pabNeedle, cbNeedle) == 0
     763                           && (GCPtrLast - GCPtr) >= cbNeedle;
    635764                    PGMPhysReleasePageMappingLock(pVM, &Lock);
    636765                    if (fRc)
    637766                    {
    638                         *pGCPtrHit = (GCPtr & ~(RTGCPTR)PAGE_OFFSET_MASK) + offPage;
     767                        *pGCPtrHit = GCPtr + offHit;
    639768                        return VINF_SUCCESS;
    640769                    }
    … …  
    650779
    651780        /* advance to the next page. */
    652         GCPtr |= PAGE_OFFSET_MASK;
    653         GCPtr++;
    654         GCPtr &= GCPtrMask;
     781        if (cPages <= cIncPages)
     782            break;
     783        cPages -= cIncPages;
     784        GCPtr += (RTGCPTR)cIncPages << PAGE_SHIFT;
    655785    }
    656786    return VERR_DBGF_MEM_NOT_FOUND;

  • trunk/src/VBox/VMM/VBoxVMMDeps.cpp

    r22112 r24061  
    4343    (PFNRT)DBGFR3StackWalkEnd,
    4444    (PFNRT)DBGFR3AsSymbolByAddr,
     45    (PFNRT)DBGFR3CpuGetMode,
    4546    (PFNRT)DBGFR3MemScan,
    4647    (PFNRT)EMInterpretInstruction,
Note: See TracChangeset for help on using the changeset viewer.

© 2025 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette