VirtualBox

Changeset 35606 in vbox


Ignore:
Timestamp:
Jan 18, 2011 2:04:34 PM (14 years ago)
Author:
vboxsync
Message:

DBGFRegs: Introduced DBGFREG_HYPER_VMCPUID. Fixed some bugs.

Location:
trunk
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • trunk/include/VBox/vmm/dbgf.h

    r35601 r35606  
    14041404typedef DBGFREGENTRY const *PCDBGFREGENTRY;
    14051405
     1406/** Used with DBGFR3Reg* to indicate the hypervisor register set instead of the
     1407 *  guest. */
     1408#define DBGFREG_HYPER_VMCPUID       UINT32_C(0x01000000)
     1409
    14061410VMMR3DECL(int) DBGFR3RegCpuQueryU8(  PVM pVM, VMCPUID idCpu, DBGFREG enmReg, uint8_t     *pu8);
    14071411VMMR3DECL(int) DBGFR3RegCpuQueryU16( PVM pVM, VMCPUID idCpu, DBGFREG enmReg, uint16_t    *pu16);
    … …  
    14111415VMMR3DECL(int) DBGFR3RegCpuQueryLrd( PVM pVM, VMCPUID idCpu, DBGFREG enmReg, long double *plrd);
    14121416VMMR3DECL(int) DBGFR3RegCpuQueryXdtr(PVM pVM, VMCPUID idCpu, DBGFREG enmReg, uint64_t *pu64Base, uint16_t *pu16Limit);
     1417#if 0
    14131418VMMR3DECL(int) DBGFR3RegCpuQueryBatch(PVM pVM,VMCPUID idCpu, PDBGFREGENTRY paRegs, size_t cRegs);
    14141419VMMR3DECL(int) DBGFR3RegCpuQueryAll( PVM pVM, VMCPUID idCpu, PDBGFREGENTRY paRegs, size_t cRegs);
    … …  
    14211426VMMR3DECL(int) DBGFR3RegCpuSetLrd(   PVM pVM, VMCPUID idCpu, DBGFREG enmReg, long double lrd);
    14221427VMMR3DECL(int) DBGFR3RegCpuSetBatch( PVM pVM, VMCPUID idCpu, PCDBGFREGENTRY paRegs, size_t cRegs);
     1428#endif
    14231429
    14241430VMMR3DECL(const char *) DBGFR3RegCpuName(PVM pVM, DBGFREG enmReg, DBGFREGVALTYPE enmType);
    14251431
    14261432VMMR3_INT_DECL(int) DBGFR3RegRegisterCpu(PVM pVM, PVMCPU pVCpu, PCDBGFREGDESC paRegisters, bool fGuestRegs);
    1427 VMMR3DECL(int) DBGFR3RegRegisterDevice(PVM pVM, PCDBGFREGDESC paRegisters, PPDMDEVINS pDevIns, const char *pszPrefix, uint32_t iInstance);
     1433VMMR3DECL(int)      DBGFR3RegRegisterDevice(PVM pVM, PCDBGFREGDESC paRegisters, PPDMDEVINS pDevIns, const char *pszPrefix, uint32_t iInstance);
    14281434
    14291435/**
    … …  
    14551461VMMR3DECL(int) DBGFR3RegNmQueryAllCount(PVM pVM, size_t *pcRegs);
    14561462VMMR3DECL(int) DBGFR3RegNmQueryAll( PVM pVM,                   PDBGFREGENTRYNM paRegs, size_t cRegs);
    1457 VMMR3DECL(int) DBGFR3RegNmPrintf(   PVM pVM, VMCPUID idDefCpu, char *pszBuf, size_t cbBuf, const char *pszFormat, ...);
    1458 VMMR3DECL(int) DBGFR3RegNmPrintfV(  PVM pVM, VMCPUID idDefCpu, char *pszBuf, size_t cbBuf, const char *pszFormat, va_list va);
    14591463
    14601464VMMR3DECL(int) DBGFR3RegNmSetU8(    PVM pVM, VMCPUID idDefCpu, const char *pszReg, uint8_t     u8);
    … …  
    14671471
    14681472/** @todo add enumeration methods.  */
     1473
     1474VMMR3DECL(int) DBGFR3RegPrintf( PVM pVM, VMCPUID idDefCpu, char *pszBuf, size_t cbBuf, const char *pszFormat, ...);
     1475VMMR3DECL(int) DBGFR3RegPrintfV(PVM pVM, VMCPUID idDefCpu, char *pszBuf, size_t cbBuf, const char *pszFormat, va_list va);
    14691476
    14701477

  • trunk/src/VBox/VMM/VMMR3/DBGFReg.cpp

    r35601 r35606  
    178178    /** The target CPU. */
    179179    VMCPUID     idCpu;
     180    /** Set if we're looking at guest registers. */
     181    bool        fGuestRegs;
    180182    /** The output buffer. */
    181183    char       *pszBuf;
    … …  
    784786 * @param   enmReg              The register to query.
    785787 * @param   enmType             The desired return type.
     788 * @param   fGuestRegs          Query guest CPU registers if set (true),
     789 *                              hypervisor CPU registers if clear (false).
    786790 * @param   pValue              Where to return the register value.
    787791 */
    788 static DECLCALLBACK(int) dbgfR3RegCpuQueryWorker(PVM pVM, VMCPUID idCpu, DBGFREG enmReg, DBGFREGVALTYPE enmType, PDBGFREGVAL pValue)
     792static DECLCALLBACK(int) dbgfR3RegCpuQueryWorkerOnCpu(PVM pVM, VMCPUID idCpu, DBGFREG enmReg, DBGFREGVALTYPE enmType,
     793                                                      bool fGuestRegs, PDBGFREGVAL pValue)
    789794{
    790795    int rc = VINF_SUCCESS;
    … …  
    794799     * Look up the register set of the specified CPU.
    795800     */
    796     PDBGFREGSET pSet = pVM->aCpus[idCpu].dbgf.s.pGuestRegSet;
     801    PDBGFREGSET pSet = fGuestRegs
     802                     ? pVM->aCpus[idCpu].dbgf.s.pGuestRegSet
     803                     : pVM->aCpus[idCpu].dbgf.s.pHyperRegSet;
    797804    if (RT_LIKELY(pSet))
    798805    {
    … …  
    830837
    831838/**
    832  * Queries a 8-bit CPU register value.
    833  *
    834  * @retval  VINF_SUCCESS
    835  * @retval  VERR_INVALID_VM_HANDLE
    836  * @retval  VERR_INVALID_CPU_ID
    837  * @retval  VERR_DBGF_REGISTER_NOT_FOUND
    838  * @retval  VERR_DBGF_UNSUPPORTED_CAST
    839  * @retval  VINF_DBGF_TRUNCATED_REGISTER
    840  *
    841  * @param   pVM                 The VM handle.
    842  * @param   idCpu               The target CPU ID.
    843  * @param   enmReg              The register that's being queried.
    844  * @param   pu8                 Where to store the register value.
    845  */
    846 VMMR3DECL(int) DBGFR3RegCpuQueryU8(PVM pVM, VMCPUID idCpu, DBGFREG enmReg, uint8_t *pu8)
    847 {
    848     VM_ASSERT_VALID_EXT_RETURN(pVM, VERR_INVALID_VM_HANDLE);
    849     AssertReturn(idCpu < pVM->cCpus, VERR_INVALID_CPU_ID);
    850 
    851     DBGFREGVAL Value;
    852     int rc = VMR3ReqCallWait(pVM, idCpu, (PFNRT)dbgfR3RegCpuQueryWorker, 5, pVM, idCpu, enmReg, DBGFREGVALTYPE_U8, &Value);
    853     if (RT_SUCCESS(rc))
    854         *pu8 = Value.u8;
    855     else
    856         *pu8 = 0;
    857 
    858     return rc;
    859 }
    860 
    861 
    862 /**
    863  * Queries a 16-bit CPU register value.
    864  *
     839 * Internal worker for the CPU register query functions.
     840 *
     841 * @returns VBox status code.
    865842 * @retval  VINF_SUCCESS
    866843 * @retval  VERR_INVALID_VM_HANDLE
    … …  
    872849 *
    873850 * @param   pVM                 The VM handle.
    874  * @param   idCpu               The target CPU ID.
     851 * @param   idCpu               The virtual CPU ID.  Can be OR'ed with
     852 *                              DBGFREG_HYPER_VMCPUID.
     853 * @param   enmReg              The register to query.
     854 * @param   enmType             The desired return type.
     855 * @param   pValue              Where to return the register value.
     856 */
     857static int dbgfR3RegCpuQueryWorker(PVM pVM, VMCPUID idCpu, DBGFREG enmReg, DBGFREGVALTYPE enmType, PDBGFREGVAL pValue)
     858{
     859    VM_ASSERT_VALID_EXT_RETURN(pVM, VERR_INVALID_VM_HANDLE);
     860    AssertMsgReturn(enmReg >= DBGFREG_AL && enmReg <= DBGFREG_END, ("%d\n", enmReg), VERR_INVALID_PARAMETER);
     861
     862    bool const fGuestRegs = idCpu & DBGFREG_HYPER_VMCPUID;
     863    idCpu &= ~DBGFREG_HYPER_VMCPUID;
     864    AssertReturn(idCpu < pVM->cCpus, VERR_INVALID_CPU_ID);
     865
     866    return VMR3ReqCallWait(pVM, idCpu, (PFNRT)dbgfR3RegCpuQueryWorkerOnCpu, 6,
     867                           pVM, idCpu, enmReg, enmType, fGuestRegs, pValue);
     868}
     869
     870
     871/**
     872 * Queries a 8-bit CPU register value.
     873 *
     874 * @retval  VINF_SUCCESS
     875 * @retval  VERR_INVALID_VM_HANDLE
     876 * @retval  VERR_INVALID_CPU_ID
     877 * @retval  VERR_DBGF_REGISTER_NOT_FOUND
     878 * @retval  VERR_DBGF_UNSUPPORTED_CAST
     879 * @retval  VINF_DBGF_TRUNCATED_REGISTER
     880 *
     881 * @param   pVM                 The VM handle.
     882 * @param   idCpu               The target CPU ID. Can be OR'ed with
     883 *                              DBGFREG_HYPER_VMCPUID.
    875884 * @param   enmReg              The register that's being queried.
    876  * @param   pu16                Where to store the register value.
    877  */
    878 VMMR3DECL(int) DBGFR3RegCpuQueryU16(PVM pVM, VMCPUID idCpu, DBGFREG enmReg, uint16_t *pu16)
    879 {
    880     VM_ASSERT_VALID_EXT_RETURN(pVM, VERR_INVALID_VM_HANDLE);
    881     AssertReturn(idCpu < pVM->cCpus, VERR_INVALID_CPU_ID);
    882 
     885 * @param   pu8                 Where to store the register value.
     886 */
     887VMMR3DECL(int) DBGFR3RegCpuQueryU8(PVM pVM, VMCPUID idCpu, DBGFREG enmReg, uint8_t *pu8)
     888{
    883889    DBGFREGVAL Value;
    884     int rc = VMR3ReqCallWait(pVM, idCpu, (PFNRT)dbgfR3RegCpuQueryWorker, 5, pVM, idCpu, enmReg, DBGFREGVALTYPE_U16, &Value);
     890    int rc = dbgfR3RegCpuQueryWorker(pVM, idCpu, enmReg, DBGFREGVALTYPE_U8, &Value);
    885891    if (RT_SUCCESS(rc))
    886         *pu16 = Value.u16;
     892        *pu8 = Value.u8;
    887893    else
    888         *pu16 = 0;
    889 
     894        *pu8 = 0;
    890895    return rc;
    891896}
    … …  
    893898
    894899/**
    895  * Queries a 32-bit CPU register value.
     900 * Queries a 16-bit CPU register value.
    896901 *
    897902 * @retval  VINF_SUCCESS
    … …  
    904909 *
    905910 * @param   pVM                 The VM handle.
    906  * @param   idCpu               The target CPU ID.
     911 * @param   idCpu               The target CPU ID.  Can be OR'ed with
     912 *                              DBGFREG_HYPER_VMCPUID.
    907913 * @param   enmReg              The register that's being queried.
    908  * @param   pu32                Where to store the register value.
    909  */
    910 VMMR3DECL(int) DBGFR3RegCpuQueryU32(PVM pVM, VMCPUID idCpu, DBGFREG enmReg, uint32_t *pu32)
    911 {
    912     VM_ASSERT_VALID_EXT_RETURN(pVM, VERR_INVALID_VM_HANDLE);
    913     AssertReturn(idCpu < pVM->cCpus, VERR_INVALID_CPU_ID);
    914 
     914 * @param   pu16                Where to store the register value.
     915 */
     916VMMR3DECL(int) DBGFR3RegCpuQueryU16(PVM pVM, VMCPUID idCpu, DBGFREG enmReg, uint16_t *pu16)
     917{
    915918    DBGFREGVAL Value;
    916     int rc = VMR3ReqCallWait(pVM, idCpu, (PFNRT)dbgfR3RegCpuQueryWorker, 5, pVM, idCpu, enmReg, DBGFREGVALTYPE_U32, &Value);
     919    int rc = dbgfR3RegCpuQueryWorker(pVM, idCpu, enmReg, DBGFREGVALTYPE_U16, &Value);
    917920    if (RT_SUCCESS(rc))
    918         *pu32 = Value.u32;
     921        *pu16 = Value.u16;
    919922    else
    920         *pu32 = 0;
    921 
     923        *pu16 = 0;
    922924    return rc;
    923925}
    … …  
    925927
    926928/**
    927  * Queries a 64-bit CPU register value.
     929 * Queries a 32-bit CPU register value.
    928930 *
    929931 * @retval  VINF_SUCCESS
    … …  
    936938 *
    937939 * @param   pVM                 The VM handle.
    938  * @param   idCpu               The target CPU ID.
     940 * @param   idCpu               The target CPU ID.  Can be OR'ed with
     941 *                              DBGFREG_HYPER_VMCPUID.
     942 * @param   enmReg              The register that's being queried.
     943 * @param   pu32                Where to store the register value.
     944 */
     945VMMR3DECL(int) DBGFR3RegCpuQueryU32(PVM pVM, VMCPUID idCpu, DBGFREG enmReg, uint32_t *pu32)
     946{
     947    DBGFREGVAL Value;
     948    int rc = dbgfR3RegCpuQueryWorker(pVM, idCpu, enmReg, DBGFREGVALTYPE_U32, &Value);
     949    if (RT_SUCCESS(rc))
     950        *pu32 = Value.u32;
     951    else
     952        *pu32 = 0;
     953    return rc;
     954}
     955
     956
     957/**
     958 * Queries a 64-bit CPU register value.
     959 *
     960 * @retval  VINF_SUCCESS
     961 * @retval  VERR_INVALID_VM_HANDLE
     962 * @retval  VERR_INVALID_CPU_ID
     963 * @retval  VERR_DBGF_REGISTER_NOT_FOUND
     964 * @retval  VERR_DBGF_UNSUPPORTED_CAST
     965 * @retval  VINF_DBGF_TRUNCATED_REGISTER
     966 * @retval  VINF_DBGF_ZERO_EXTENDED_REGISTER
     967 *
     968 * @param   pVM                 The VM handle.
     969 * @param   idCpu               The target CPU ID.  Can be OR'ed with
     970 *                              DBGFREG_HYPER_VMCPUID.
    939971 * @param   enmReg              The register that's being queried.
    940972 * @param   pu64                Where to store the register value.
    … …  
    942974VMMR3DECL(int) DBGFR3RegCpuQueryU64(PVM pVM, VMCPUID idCpu, DBGFREG enmReg, uint64_t *pu64)
    943975{
    944     VM_ASSERT_VALID_EXT_RETURN(pVM, VERR_INVALID_VM_HANDLE);
    945     AssertReturn(idCpu < pVM->cCpus, VERR_INVALID_CPU_ID);
    946 
    947976    DBGFREGVAL Value;
    948     int rc = VMR3ReqCallWait(pVM, idCpu, (PFNRT)dbgfR3RegCpuQueryWorker, 5, pVM, idCpu, enmReg, DBGFREGVALTYPE_U64, &Value);
     977    int rc = dbgfR3RegCpuQueryWorker(pVM, idCpu, enmReg, DBGFREGVALTYPE_U64, &Value);
    949978    if (RT_SUCCESS(rc))
    950979        *pu64 = Value.u64;
    951980    else
    952981        *pu64 = 0;
    953 
    954982    return rc;
    955983}
    956984
     985#if 0 /* rewrite / remove */
    957986
    958987/**
    … …  
    10431072 *
    10441073 * @param   pVM                 The VM handle.
    1045  * @param   idCpu               The target CPU ID.
     1074 * @param   idCpu               The target CPU ID.  Can be OR'ed with
     1075 *                              DBGFREG_HYPER_VMCPUID.
    10461076 * @param   paRegs              Pointer to an array of @a cRegs elements.  On
    10471077 *                              input the enmReg members indicates which
    … …  
    10781108 *
    10791109 * @param   pVM                 The VM handle.
    1080  * @param   idCpu               The target CPU ID.
     1110 * @param   idCpu               The target CPU ID.  Can be OR'ed with
     1111 *                              DBGFREG_HYPER_VMCPUID.
    10811112 * @param   paRegs              Pointer to an array of @a cRegs elements.
    10821113 *                              These will be filled with the CPU register
    … …  
    11141145}
    11151146
    1116 
     1147#endif /* rewrite or remove? */
    11171148
    11181149/**
    … …  
    11931224 * @param   idDefCpu            The default CPU ID set.
    11941225 * @param   pszReg              The register name.
    1195  */
    1196 static PCDBGFREGLOOKUP dbgfR3RegResolve(PVM pVM, VMCPUID idDefCpu, const char *pszReg)
     1226 * @param   fGuestRegs          Default to guest CPU registers if set, the
     1227 *                              hypervisor CPU registers if clear.
     1228 */
     1229static PCDBGFREGLOOKUP dbgfR3RegResolve(PVM pVM, VMCPUID idDefCpu, const char *pszReg, bool fGuestRegs)
    11971230{
    11981231    DBGF_REG_DB_LOCK_READ(pVM);
    … …  
    12131246        {
    12141247            /* Prefix it with the specified CPU set. */
    1215             size_t cchCpuSet = RTStrPrintf(szName, sizeof(szName), "cpu%u.", idDefCpu);
     1248            size_t cchCpuSet = RTStrPrintf(szName, sizeof(szName), fGuestRegs ? "cpu%u." : "hypercpu%u.", idDefCpu);
    12161249            dbgfR3RegCopyToLower(pszReg, RTSTR_MAX, &szName[cchCpuSet], sizeof(szName) - cchCpuSet);
    12171250            pLookupRec = (PCDBGFREGLOOKUP)RTStrSpaceGet(&pVM->dbgf.s.RegSpace, szName);
    … …  
    13451378 * @param   pVM                 The VM handle.
    13461379 * @param   idDefCpu            The virtual CPU ID for the default CPU register
    1347  *                              set.
     1380 *                              set.  Can be OR'ed with DBGFREG_HYPER_VMCPUID.
    13481381 * @param   pszReg              The register to query.
    13491382 * @param   enmType             The desired return type.
    … …  
    13591392     */
    13601393    VM_ASSERT_VALID_EXT_RETURN(pVM, VERR_INVALID_VM_HANDLE);
    1361     AssertReturn(idDefCpu < pVM->cCpus || idDefCpu == VMCPUID_ANY, VERR_INVALID_CPU_ID);
     1394    AssertReturn((idDefCpu & ~DBGFREG_HYPER_VMCPUID) < pVM->cCpus || idDefCpu == VMCPUID_ANY, VERR_INVALID_CPU_ID);
    13621395    AssertPtrReturn(pszReg, VERR_INVALID_POINTER);
    13631396
    … …  
    13681401     * Resolve the register and call the getter on the relevant CPU.
    13691402     */
    1370     PCDBGFREGLOOKUP pLookupRec = dbgfR3RegResolve(pVM, idDefCpu, pszReg);
     1403    bool const fGuestRegs = !(idDefCpu & DBGFREG_HYPER_VMCPUID) && idDefCpu != VMCPUID_ANY;
     1404    PCDBGFREGLOOKUP pLookupRec = dbgfR3RegResolve(pVM, idDefCpu, pszReg, fGuestRegs);
    13711405    if (pLookupRec)
    13721406    {
    13731407        if (pLookupRec->pSet->enmType == DBGFREGSETTYPE_CPU)
    13741408            idDefCpu = pLookupRec->pSet->uUserArg.pVCpu->idCpu;
     1409        else if (idDefCpu != VMCPUID_ANY)
     1410            idDefCpu &= ~DBGFREG_HYPER_VMCPUID;
    13751411        return VMR3ReqCallWait(pVM, idDefCpu, (PFNRT)dbgfR3RegNmQueryWorkerOnCpu, 5, pVM, pLookupRec, enmType, pValue, penmType);
    13761412    }
    … …  
    13891425 * @param   pVM                 The VM handle.
    13901426 * @param   idDefCpu            The default target CPU ID, VMCPUID_ANY if not
    1391  *                              applicable.
     1427 *                              applicable. Can be OR'ed with
     1428 *                              DBGFREG_HYPER_VMCPUID.
    13921429 * @param   pszReg              The register that's being queried.  Except for
    13931430 *                              CPU registers, this must be on the form
    … …  
    14141451 * @param   pVM                 The VM handle.
    14151452 * @param   idDefCpu            The default target CPU ID, VMCPUID_ANY if not
    1416  *                              applicable.
     1453 *                              applicable. Can be OR'ed with
     1454 *                              DBGFREG_HYPER_VMCPUID.
    14171455 * @param   pszReg              The register that's being queried.  Except for
    14181456 *                              CPU registers, this must be on the form
    … …  
    14451483 * @param   pVM                 The VM handle.
    14461484 * @param   idDefCpu            The default target CPU ID, VMCPUID_ANY if not
    1447  *                              applicable.
     1485 *                              applicable.  Can be OR'ed with
     1486 *                              DBGFREG_HYPER_VMCPUID.
    14481487 * @param   pszReg              The register that's being queried.  Except for
    14491488 *                              CPU registers, this must be on the form
    … …  
    14761515 * @param   pVM                 The VM handle.
    14771516 * @param   idDefCpu            The default target CPU ID, VMCPUID_ANY if not
    1478  *                              applicable.
     1517 *                              applicable.  Can be OR'ed with
     1518 *                              DBGFREG_HYPER_VMCPUID.
    14791519 * @param   pszReg              The register that's being queried.  Except for
    14801520 *                              CPU registers, this must be on the form
    … …  
    15071547 * @param   pVM                 The VM handle.
    15081548 * @param   idDefCpu            The default target CPU ID, VMCPUID_ANY if not
    1509  *                              applicable.
     1549 *                              applicable.  Can be OR'ed with
     1550 *                              DBGFREG_HYPER_VMCPUID.
    15101551 * @param   pszReg              The register that's being queried.  Except for
    15111552 *                              CPU registers, this must be on the form
    … …  
    15381579 * @param   pVM                 The VM handle.
    15391580 * @param   idDefCpu            The default target CPU ID, VMCPUID_ANY if not
    1540  *                              applicable.
     1581 *                              applicable.  Can be OR'ed with
     1582 *                              DBGFREG_HYPER_VMCPUID.
    15411583 * @param   pszReg              The register that's being queried.  Except for
    15421584 *                              CPU registers, this must be on the form
    … …  
    15701612 * @param   pVM                 The VM handle.
    15711613 * @param   idDefCpu            The default target CPU ID, VMCPUID_ANY if not
    1572  *                              applicable.
     1614 *                              applicable.  Can be OR'ed with
     1615 *                              DBGFREG_HYPER_VMCPUID.
    15731616 * @param   pszReg              The register that's being queried.  Except for
    15741617 *                              CPU registers, this must be on the form
    … …  
    16021645 * @param   pVM                 The VM handle.
    16031646 * @param   idDefCpu            The default target CPU ID, VMCPUID_ANY if not
    1604  *                              applicable.
     1647 *                              applicable.  Can be OR'ed with
     1648 *                              DBGFREG_HYPER_VMCPUID.
    16051649 * @param   pszReg              The register that's being queried.  Except for
    16061650 *                              CPU registers, this must be on the form
    … …  
    20832127     * The end and length of the register.
    20842128     */
    2085     const char *pszEnd = strchr(&pachReg[3], '}');
     2129    const char *pszEnd = strchr(pachReg, '}');
    20862130    AssertMsgReturn(pszEnd, ("Missing closing curly bracket: '%s'\n", pszFormat), 0);
    20872131    size_t const cchReg = pszEnd - pachReg;
    … …  
    21052149        {
    21062150            /* Prefix it with the specified CPU set. */
    2107             size_t cchCpuSet = RTStrPrintf(szName, sizeof(szName), "cpu%u.", pThis->idCpu);
     2151            size_t cchCpuSet = RTStrPrintf(szName, sizeof(szName), pThis->fGuestRegs ? "cpu%u." : "hypercpu%u.", pThis->idCpu);
    21082152            dbgfR3RegCopyToLower(pachReg, cchReg, &szName[cchCpuSet], sizeof(szName) - cchCpuSet);
    21092153            pLookupRec = (PCDBGFREGLOOKUP)RTStrSpaceGet(&pThis->pVM->dbgf.s.RegSpace, szName);
    … …  
    22062250 * @param   va                  Other format arguments.
    22072251 */
    2208 VMMR3DECL(int) DBGFR3RegNmPrintfV(PVM pVM, VMCPUID idCpu, char *pszBuf, size_t cbBuf, const char *pszFormat, va_list va)
     2252VMMR3DECL(int) DBGFR3RegPrintfV(PVM pVM, VMCPUID idCpu, char *pszBuf, size_t cbBuf, const char *pszFormat, va_list va)
    22092253{
    22102254    AssertPtrReturn(pszBuf, VERR_INVALID_POINTER);
    … …  
    22132257
    22142258    VM_ASSERT_VALID_EXT_RETURN(pVM, VERR_INVALID_VM_HANDLE);
    2215     AssertReturn(idCpu < pVM->cCpus || idCpu == VMCPUID_ANY, VERR_INVALID_CPU_ID);
     2259    AssertReturn((idCpu & ~DBGFREG_HYPER_VMCPUID) < pVM->cCpus || idCpu == VMCPUID_ANY, VERR_INVALID_CPU_ID);
    22162260    AssertPtrReturn(pszFormat, VERR_INVALID_POINTER);
    22172261
    … …  
    22222266    DBGFR3REGNMPRINTFARGS Args;
    22232267    Args.pVM        = pVM;
    2224     Args.idCpu      = idCpu;
     2268    Args.idCpu      = idCpu != VMCPUID_ANY ? idCpu & ~DBGFREG_HYPER_VMCPUID : idCpu;
     2269    Args.fGuestRegs = idCpu != VMCPUID_ANY && !(idCpu & DBGFREG_HYPER_VMCPUID);
    22252270    Args.pszBuf     = pszBuf;
    22262271    Args.pszFormat  = pszFormat;
    … …  
    22292274    Args.cchLeftBuf = cbBuf - 1;
    22302275    Args.rc         = VINF_SUCCESS;
    2231     int rc = VMR3ReqCallWait(pVM, idCpu, (PFNRT)dbgfR3RegNmPrintfWorkerOnCpu, 1, &Args);
     2276    int rc = VMR3ReqCallWait(pVM, Args.idCpu, (PFNRT)dbgfR3RegNmPrintfWorkerOnCpu, 1, &Args);
    22322277    va_end(Args.va);
    22332278    return rc;
    … …  
    22532298 * @param   ...                 Other format arguments.
    22542299 */
    2255 VMMR3DECL(int) DBGFR3RegNmPrintf(PVM pVM, VMCPUID idCpu, char *pszBuf, size_t cbBuf, const char *pszFormat, ...)
     2300VMMR3DECL(int) DBGFR3RegPrintf(PVM pVM, VMCPUID idCpu, char *pszBuf, size_t cbBuf, const char *pszFormat, ...)
    22562301{
    22572302    va_list va;
    22582303    va_start(va, pszFormat);
    2259     int rc = DBGFR3RegNmPrintfV(pVM, idCpu, pszBuf, cbBuf, pszFormat, va);
     2304    int rc = DBGFR3RegPrintfV(pVM, idCpu, pszBuf, cbBuf, pszFormat, va);
    22602305    va_end(va);
    22612306    return rc;
Note: See TracChangeset for help on using the changeset viewer.

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