VirtualBox

Changeset 96811 in vbox for trunk


Ignore:
Timestamp:
Sep 21, 2022 1:23:31 PM (2 years ago)
Author:
vboxsync
Message:

VMM,IPRT,VBoxGuest,SUPDrv: Added a more efficient interface for guest logging using the CPUID instruction. This is mainly intended for development use and not enabled by default. Require updating host drivers.

Location:
trunk
Files:
3 added
23 edited
1 copied

Legend:

Unmodified
Added
Removed

  • trunk/Makefile.kmk

    r96407 r96811  
    21082108        $(SED) -f include/VBox/various.sed --output include/VBox/param.mac         include/VBox/param.h
    21092109        $(SED) -f include/VBox/various.sed --output include/VBox/VMMDevTesting.mac include/VBox/VMMDevTesting.h
     2110        $(SED) -f include/VBox/various.sed --output include/VBox/vmm/cpuidcall.mac include/VBox/vmm/cpuidcall.h
    21102111
    21112112

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

    r96435 r96811  
    14521452        struct IEM  s;
    14531453#endif
    1454         uint8_t     padding[8];         /* multiple of 8 */
     1454        uint8_t     padding[16];         /* multiple of 8 */
    14551455    } iem;
    14561456
    … …  
    14781478
    14791479    /** Padding for aligning the structure size on a page boundrary. */
    1480     uint8_t         abAlignment2[8880 - sizeof(PVMCPUR3) * VMM_MAX_CPU_COUNT];
     1480    uint8_t         abAlignment2[8872 - sizeof(PVMCPUR3) * VMM_MAX_CPU_COUNT];
    14811481
    14821482    /* ---- end small stuff ---- */

  • trunk/include/VBox/vmm/vm.mac

    r96435 r96811  
    173173    .vm                     resb 32
    174174    .cfgm                   resb 8
    175     .iem                    resb 8
     175    .iem                    resb 16
    176176    .R0Stats                resb 64
    177177    .gcm                    resb 32

  • trunk/include/iprt/log.h

    r96448 r96811  
    545545    /** Log a memory ring buffer. */
    546546    RTLOGDEST_RINGBUF       = 0x00000020,
     547    /** The parent VMM debug log. */
     548    RTLOGDEST_VMM           = 0x00000040,
     549    /** The parent VMM release log. */
     550    RTLOGDEST_VMM_REL       = 0x00000080,
    547551    /** Open files with no deny (share read, write, delete) on Windows. */
    548552    RTLOGDEST_F_NO_DENY     = 0x00010000,
    … …  
    560564} RTLOGDEST;
    561565/** Valid log destinations. */
    562 #define RTLOG_DST_VALID_MASK    UINT32_C(0x6303003f)
     566#define RTLOG_DST_VALID_MASK    UINT32_C(0x630300ff)
    563567/** Log destinations that can be changed via RTLogChangeDestinations. */
    564 #define RTLOG_DST_CHANGE_MASK   UINT32_C(0x4000001e)
     568#define RTLOG_DST_CHANGE_MASK   UINT32_C(0x400000de)
    565569
    566570
    … …  
    25262530
    25272531/**
     2532 * Write/copy bulk log data from a nested VM logger.
     2533 *
     2534 * This is used for
     2535 *
     2536 * @returns IRPT status code.
     2537 * @param   pLogger             The logger instance (NULL for default logger).
     2538 * @param   pch                 Pointer to the block of bulk log text to write.
     2539 * @param   cch                 Size of the block of bulk log text to write.
     2540 * @param   pszInfix            String to put after the line prefixes and the
     2541 *                              line content.
     2542 */
     2543RTDECL(int) RTLogBulkNestedWrite(PRTLOGGER pLogger, const char *pch, size_t cch, const char *pszInfix);
     2544
     2545/**
    25282546 * Flushes the specified logger.
    25292547 *
    … …  
    27892807
    27902808/**
     2809 * Write log buffer to a parent VMM (hypervisor).
     2810 *
     2811 * @param   pach        What to write.
     2812 * @param   cb          How much to write.
     2813 * @param   fRelease    Set if targeting the release log, clear if debug log.
     2814 *
     2815 * @note    Currently only available on AMD64 and x86.
     2816 */
     2817RTDECL(void) RTLogWriteVmm(const char *pach, size_t cb, bool fRelease);
     2818
     2819/**
    27912820 * Write log buffer to stdout (RTLOGDEST_STDOUT).
    27922821 *

  • trunk/include/iprt/mangling.h

    r96622 r96811  
    14531453# define RTLogBulkUpdate                                RT_MANGLER(RTLogBulkUpdate)
    14541454# define RTLogBulkWrite                                 RT_MANGLER(RTLogBulkWrite)
     1455# define RTLogBulkNestedWrite                           RT_MANGLER(RTLogBulkNestedWrite)
    14551456# define RTLogChangeDestinations                        RT_MANGLER(RTLogChangeDestinations)
    14561457# define RTLogChangeFlags                               RT_MANGLER(RTLogChangeFlags)

  • trunk/src/VBox/Additions/common/VBoxGuest/freebsd/Makefile

    r96407 r96811  
    150150        RTLogWriteStdOut-stub-generic.c \
    151151        RTLogWriteStdErr-stub-generic.c \
     152        RTLogWriteVmm-stub-generic.c \
    152153        RTRandAdvCreateSystemFaster-generic.c \
    153154        RTRandAdvCreateSystemTruer-generic.c \

  • trunk/src/VBox/Additions/common/VBoxGuest/freebsd/files_vboxguest

    r96407 r96811  
    187187    ${PATH_ROOT}/src/VBox/Runtime/generic/RTLogWriteStdOut-stub-generic.cpp=>generic/RTLogWriteStdOut-stub-generic.c \
    188188    ${PATH_ROOT}/src/VBox/Runtime/generic/RTLogWriteDebugger-generic.cpp=>generic/RTLogWriteDebugger-generic.c \
     189    ${PATH_ROOT}/src/VBox/Runtime/generic/RTLogWriteVmm-stub-generic.cpp=>generic/RTLogWriteVmm-stub-generic.c \
    189190    ${PATH_ROOT}/src/VBox/Runtime/generic/RTRandAdvCreateSystemFaster-generic.cpp=>generic/RTRandAdvCreateSystemFaster-generic.c \
    190191    ${PATH_ROOT}/src/VBox/Runtime/generic/RTRandAdvCreateSystemTruer-generic.cpp=>generic/RTRandAdvCreateSystemTruer-generic.c \

  • trunk/src/VBox/Additions/common/VBoxGuest/linux/Makefile

    r96407 r96811  
    130130        generic/RTLogWriteStdErr-stub-generic.o \
    131131        generic/RTLogWriteStdOut-stub-generic.o \
     132        generic/RTLogWriteVmm-stub-generic.o \
    132133        generic/RTMpGetCoreCount-generic.o \
    133134        generic/RTSemEventWait-2-ex-generic.o \

  • trunk/src/VBox/Additions/common/VBoxGuest/linux/files_vboxguest

    r96407 r96811  
    186186    ${PATH_ROOT}/src/VBox/Runtime/generic/RTLogWriteStdErr-stub-generic.cpp=>generic/RTLogWriteStdErr-stub-generic.c \
    187187    ${PATH_ROOT}/src/VBox/Runtime/generic/RTLogWriteStdOut-stub-generic.cpp=>generic/RTLogWriteStdOut-stub-generic.c \
     188    ${PATH_ROOT}/src/VBox/Runtime/generic/RTLogWriteVmm-stub-generic.cpp=>generic/RTLogWriteVmm-stub-generic.c \
    188189    ${PATH_ROOT}/src/VBox/Runtime/generic/RTMpGetCoreCount-generic.cpp=>generic/RTMpGetCoreCount-generic.c \
    189190    ${PATH_ROOT}/src/VBox/Runtime/generic/RTSemEventWait-2-ex-generic.cpp=>generic/RTSemEventWait-2-ex-generic.c \

  • trunk/src/VBox/HostDrivers/Support/SUPDrv.cpp

    r96407 r96811  
    377377    SUPEXP_STK_BACK(    3,  RTHandleTableFreeWithCtx),
    378378    SUPEXP_STK_BACK(    3,  RTHandleTableLookupWithCtx),
     379    SUPEXP_STK_BACK(    4,  RTLogBulkNestedWrite),
    379380    SUPEXP_STK_BACK(    5,  RTLogBulkUpdate),
    380381    SUPEXP_STK_BACK(    2,  RTLogCheckGroupFlags),

  • trunk/src/VBox/HostDrivers/Support/SUPDrvIOC.h

    r96407 r96811  
    233233 *          - nothing
    234234 */
    235 #define SUPDRV_IOC_VERSION                              0x00330002
     235#define SUPDRV_IOC_VERSION                              0x00330003
    236236
    237237/** SUP_IOCTL_COOKIE. */

  • trunk/src/VBox/HostDrivers/Support/SUPLib.cpp

    r96407 r96811  
    299299        CookieReq.u.In.u32ReqVersion = SUPDRV_IOC_VERSION;
    300300        const uint32_t uMinVersion = (SUPDRV_IOC_VERSION & 0xffff0000) == 0x00330000
    301                                    ? 0x00330002
     301                                   ? 0x00330003
    302302                                   : SUPDRV_IOC_VERSION & 0xffff0000;
    303303        CookieReq.u.In.u32MinVersion = uMinVersion;

  • trunk/src/VBox/HostDrivers/Support/freebsd/Makefile

    r96407 r96811  
    152152        RTLogWriteStdErr-stub-generic.c \
    153153        RTLogWriteUser-generic.c \
     154        RTLogWriteVmm-stub-generic.c \
    154155        RTMpGetArraySize-generic.c \
    155156        RTMpOnPair-generic.c \

  • trunk/src/VBox/HostDrivers/Support/freebsd/files_vboxdrv

    r96407 r96811  
    188188    ${PATH_ROOT}/src/VBox/Runtime/generic/RTLogWriteUser-generic.cpp=>generic/RTLogWriteUser-generic.c \
    189189    ${PATH_ROOT}/src/VBox/Runtime/generic/RTLogWriteDebugger-generic.cpp=>generic/RTLogWriteDebugger-generic.c \
     190    ${PATH_ROOT}/src/VBox/Runtime/generic/RTLogWriteVmm-stub-generic.cpp=>generic/RTLogWriteVmm-stub-generic.c \
    190191    ${PATH_ROOT}/src/VBox/Runtime/generic/RTRandAdvCreateSystemFaster-generic.cpp=>generic/RTRandAdvCreateSystemFaster-generic.c \
    191192    ${PATH_ROOT}/src/VBox/Runtime/generic/RTRandAdvCreateSystemTruer-generic.cpp=>generic/RTRandAdvCreateSystemTruer-generic.c \

  • trunk/src/VBox/HostDrivers/Support/linux/Makefile

    r96407 r96811  
    131131        generic/RTLogWriteStdOut-stub-generic.o \
    132132        generic/RTLogWriteUser-generic.o \
     133        generic/RTLogWriteVmm-stub-generic.o \
    133134        generic/RTMpGetArraySize-generic.o \
    134135        generic/RTMpGetCoreCount-generic.o \

  • trunk/src/VBox/HostDrivers/Support/linux/files_vboxdrv

    r96407 r96811  
    188188    ${PATH_ROOT}/src/VBox/Runtime/generic/RTLogWriteStdOut-stub-generic.cpp=>generic/RTLogWriteStdOut-stub-generic.c \
    189189    ${PATH_ROOT}/src/VBox/Runtime/generic/RTLogWriteUser-generic.cpp=>generic/RTLogWriteUser-generic.c \
     190    ${PATH_ROOT}/src/VBox/Runtime/generic/RTLogWriteVmm-stub-generic.cpp=>generic/RTLogWriteVmm-stub-generic.c \
    190191    ${PATH_ROOT}/src/VBox/Runtime/generic/RTMpGetArraySize-generic.cpp=>generic/RTMpGetArraySize-generic.c \
    191192    ${PATH_ROOT}/src/VBox/Runtime/generic/RTMpGetCoreCount-generic.cpp=>generic/RTMpGetCoreCount-generic.c \

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

    r96753 r96811  
    825825        common/misc/zero.asm \
    826826        common/misc/RTSystemIsInsideVM-amd64-x86.cpp \
    827         common/string/RTStrMemFind32.asm
     827        common/string/RTStrMemFind32.asm \
     828        VBox/RTLogWriteVmm-amd64-x86.asm
    828829RuntimeBaseR3_SOURCES.amd64 += \
    829830        generic/RTMpGetDescription-generic.cpp \
    830831        common/misc/zero.asm \
    831832        common/misc/RTSystemIsInsideVM-amd64-x86.cpp \
    832         common/string/RTStrMemFind32.asm
     833        common/string/RTStrMemFind32.asm \
     834        VBox/RTLogWriteVmm-amd64-x86.asm
    833835RuntimeBaseR3_SOURCES.arm32 := \
    834836        common/asm/ASMBitFirstClear-generic.cpp \
    … …  
    24722474        generic/RTLogWriteStdOut-generic.cpp \
    24732475        generic/RTLogWriteUser-generic.cpp \
     2476        generic/RTLogWriteVmm-stub-generic.cpp \
    24742477        generic/RTPathIsSame-generic.cpp \
    24752478        generic/RTPathGetCurrentDrive-generic.cpp \
    … …  
    35963599        common/math/RTUInt128MulByU64.asm \
    35973600        common/math/RTUInt128MulByU64Ex.asm \
    3598         common/string/RTStrEnd.asm
     3601        common/string/RTStrEnd.asm \
     3602        VBox/RTLogWriteVmm-amd64-x86.asm
    35993603RuntimeR0Drv_SOURCES.x86   = \
    36003604        common/asm/ASMCpuIdExSlow.asm \
    … …  
    36033607        common/asm/ASMWrMsrEx.asm \
    36043608        common/math/bignum-amd64-x86.asm \
    3605         common/string/RTStrEnd.asm
     3609        common/string/RTStrEnd.asm \
     3610        VBox/RTLogWriteVmm-amd64-x86.asm
    36063611RuntimeR0Drv_SOURCES.arm32 += \
    36073612        common/string/RTStrEnd.cpp

  • trunk/src/VBox/Runtime/VBox/RTLogWriteVmm-amd64-x86.asm

    r96803 r96811  
    11; $Id$
    22;; @file
    3 ; IPRT - ASMCpuIdExSlow().
     3; IPRT - RTLogWriteVmm - AMD64 & X86 for VBox.
    44;
    55
    … …  
    3838;* Header Files                                                                *
    3939;*******************************************************************************
     40%define  RT_ASM_WITH_SEH64
    4041%include "iprt/asmdefs.mac"
     42%include "VBox/vmm/cpuidcall.mac"
    4143
    4244BEGINCODE
    … …  
    4547; CPUID with EAX and ECX inputs, returning ALL output registers.
    4648;
    47 ; @param    uOperator   x86:ebp+8   gcc:rdi      msc:rcx
    48 ; @param    uInitEBX    x86:ebp+c   gcc:rsi      msc:rdx
    49 ; @param    uInitECX    x86:ebp+10  gcc:rdx      msc:r8
    50 ; @param    uInitEDX    x86:ebp+14  gcc:rcx      msc:r9
    51 ; @param    pvEAX       x86:ebp+18  gcc:r8       msc:rbp+30h
    52 ; @param    pvEBX       x86:ebp+1c  gcc:r9       msc:rbp+38h
    53 ; @param    pvECX       x86:ebp+20  gcc:rbp+10h  msc:rbp+40h
    54 ; @param    pvEDX       x86:ebp+24  gcc:rbp+18h  msc:rbp+48h
     49; @param    pch         x86:ebp+8   gcc:rdi      msc:rcx
     50; @param    cch         x86:ebp+c   gcc:esi      msc:edx
     51; @param    fRelease    x86:ebp+10  gcc:edx      msc:r8d
    5552;
    5653; @returns  EAX
    5754;
    58 RT_BEGINPROC ASMCpuIdExSlow
     55RT_BEGINPROC RTLogWriteVmm
    5956        push    xBP
     57        SEH64_PUSH_xBP
    6058        mov     xBP, xSP
     59        SEH64_SET_FRAME_xBP 0
    6160        push    xBX
    62 %if ARCH_BITS == 32
    63         push    edi
    64 %elif ARCH_BITS == 16
    65         push    di
    66         push    es
     61        SEH64_PUSH_GREG xBX
     62%ifndef ASM_CALL64_GCC
     63        push    xSI
     64        SEH64_PUSH_GREG xSI
    6765%endif
     66        SEH64_END_PROLOGUE
    6867
    6968%ifdef ASM_CALL64_MSC
    … …  
    7170  %error ARCH_BITS mismatch?
    7271 %endif
    73         mov     eax, ecx
    74         mov     ebx, edx
    75         mov     ecx, r8d
    76         mov     edx, r9d
    77         mov     r8,  [rbp + 30h]
    78         mov     r9,  [rbp + 38h]
    79         mov     r10, [rbp + 40h]
    80         mov     r11, [rbp + 48h]
     72        mov     rsi, rcx                    ; pch
     73        mov     ebx, r8d                    ; fRelease; cch is the right register already.
    8174%elifdef ASM_CALL64_GCC
    82         mov     eax, edi
    83         mov     ebx, esi
    84         xchg    ecx, edx
    85         mov     r10, [rbp + 10h]
    86         mov     r11, [rbp + 18h]
     75        mov     ebx, edx                    ; fRelease
     76        mov     edx, esi                    ; cch
     77        mov     rsi, rdi                    ; pch
    8778%elif ARCH_BITS == 32
    88         mov     eax, [xBP + 08h]
    89         mov     ebx, [xBP + 0ch]
    90         mov     ecx, [xBP + 10h]
    91         mov     edx, [xBP + 14h]
    92         mov     edi, [xBP + 18h]
    93 %elif ARCH_BITS == 16
    94         mov     eax, [xBP + 08h - 4]
    95         mov     ebx, [xBP + 0ch - 4]
    96         mov     ecx, [xBP + 10h - 4]
    97         mov     edx, [xBP + 14h - 4]
     79        mov     esi, [xBP + 08h]            ; pch
     80        mov     edx, [xBP + 0ch]            ; cch
     81        movzx   ebx, byte [xBP + 10h]       ; fRelease
    9882%else
    9983 %error unsupported arch
    10084%endif
     85        mov     eax, VBOX_CPUID_REQ_EAX_FIXED
     86        mov     ecx, VBOX_CPUID_REQ_ECX_FIXED | VBOX_CPUID_FN_LOG
    10187
    10288        cpuid
    10389
    104 %ifdef RT_ARCH_AMD64
    105         test    r8, r8
    106         jz      .store_ebx
    107         mov     [r8], eax
    108 %elif ARCH_BITS == 32
    109         test    edi, edi
    110         jz      .store_ebx
    111         mov     [edi], eax
    112 %else
    113         cmp     dword [bp + 18h - 4], 0
    114         je      .store_ebx
    115         les     di, [bp + 18h - 4]
    116         mov     [es:di], eax
    117 %endif
    118 .store_ebx:
    119 
    120 %ifdef RT_ARCH_AMD64
    121         test    r9, r9
    122         jz      .store_ecx
    123         mov     [r9], ebx
    124 %elif ARCH_BITS == 32
    125         mov     edi, [ebp + 1ch]
    126         test    edi, edi
    127         jz      .store_ecx
    128         mov     [edi], ebx
    129 %else
    130         cmp     dword [bp + 1ch - 4], 0
    131         je      .store_ecx
    132         les     di, [bp + 1ch - 4]
    133         mov     [es:di], ebx
    134 %endif
    135 .store_ecx:
    136 
    137 %ifdef RT_ARCH_AMD64
    138         test    r10, r10
    139         jz      .store_edx
    140         mov     [r10], ecx
    141 %elif ARCH_BITS == 32
    142         mov     edi, [ebp + 20h]
    143         test    edi, edi
    144         jz      .store_edx
    145         mov     [edi], ecx
    146 %else
    147         cmp     dword [bp + 20h - 4], 0
    148         je      .store_edx
    149         les     di, [bp + 20h - 4]
    150         mov     [es:di], ecx
    151 %endif
    152 .store_edx:
    153 
    154 %ifdef RT_ARCH_AMD64
    155         test    r11, r11
    156         jz      .done
    157         mov     [r11], edx
    158 %elif ARCH_BITS == 32
    159         mov     edi, [ebp + 24h]
    160         test    edi, edi
    161         jz      .done
    162         mov     [edi], edx
    163 %else
    164         cmp     dword [bp + 24h - 4], 0
    165         je      .done
    166         les     di, [bp + 24h - 4]
    167         mov     [es:di], edx
    168 %endif
    169 .done:
    170 
    171 %if ARCH_BITS == 32
    172         pop     edi
    173 %elif ARCH_BITS == 16
    174         pop     es
    175         pop     di
     90%ifndef ASM_CALL64_GCC
     91        pop     xSI
    17692%endif
    17793        pop     xBX
    17894        leave
    17995        ret
    180 ENDPROC ASMCpuIdExSlow
     96ENDPROC RTLogWriteVmm
    18197

  • trunk/src/VBox/Runtime/common/log/log.cpp

    r96810 r96811  
    281281    /** The group. (used for prefixing.) */
    282282    unsigned                iGroup;
     283    /** Used by RTLogBulkNestedWrite.   */
     284    const char             *pszInfix;
    283285} RTLOGOUTPUTPREFIXEDARGS, *PRTLOGOUTPUTPREFIXEDARGS;
    284286
    … …  
    297299static FNRTLOGPHASEMSG rtlogPhaseMsgNormal;
    298300#endif
     301static DECLCALLBACK(size_t) rtLogOutputPrefixed(void *pv, const char *pachChars, size_t cbChars);
    299302static void rtlogLoggerExFLocked(PRTLOGGERINTERNAL pLoggerInt, unsigned fFlags, unsigned iGroup, const char *pszFormat, ...);
    300303
    … …  
    405408    { RT_STR_TUPLE("com"),          RTLOGDEST_COM },
    406409    { RT_STR_TUPLE("nodeny"),       RTLOGDEST_F_NO_DENY },
     410    { RT_STR_TUPLE("vmmrel"),       RTLOGDEST_VMM_REL },    /* before vmm */
     411    { RT_STR_TUPLE("vmm"),          RTLOGDEST_VMM },
    407412    { RT_STR_TUPLE("user"),         RTLOGDEST_USER },
    408413    /* The RTLOGDEST_FIXED_XXX flags are omitted on purpose. */
    … …  
    544549        uint16_t const iGroup = RT_HI_U16(fFlagsAndGroup);
    545550        if (   iGroup != UINT16_MAX
    546              && (   (pLoggerInt->afGroups[iGroup < pLoggerInt->cGroups ? iGroup : 0] & (fFlags | RTLOGGRPFLAGS_ENABLED))
    547                  != (fFlags | RTLOGGRPFLAGS_ENABLED)))
     551            && (   (pLoggerInt->afGroups[iGroup < pLoggerInt->cGroups ? iGroup : 0] & (fFlags | RTLOGGRPFLAGS_ENABLED))
     552                != (fFlags | RTLOGGRPFLAGS_ENABLED)))
    548553            pLoggerInt = NULL;
    549554    }
    … …  
    10851090            RTLogWriteUser(pszSecond, cchSecond);
    10861091    }
     1092
     1093# if defined(RT_ARCH_X86) || defined(RT_ARCH_AMD64)
     1094    if (pLoggerInt->fDestFlags & RTLOGDEST_VMM)
     1095    {
     1096        if (cchPreamble)
     1097            RTLogWriteVmm(pszPreamble, cchPreamble, false /*fReleaseLog*/);
     1098        if (cchFirst)
     1099            RTLogWriteVmm(pszFirst, cchFirst, false /*fReleaseLog*/);
     1100        if (cchSecond)
     1101            RTLogWriteVmm(pszSecond, cchSecond, false /*fReleaseLog*/);
     1102    }
     1103
     1104    if (pLoggerInt->fDestFlags & RTLOGDEST_VMM_REL)
     1105    {
     1106        if (cchPreamble)
     1107            RTLogWriteVmm(pszPreamble, cchPreamble, true /*fReleaseLog*/);
     1108        if (cchFirst)
     1109            RTLogWriteVmm(pszFirst, cchFirst, true /*fReleaseLog*/);
     1110        if (cchSecond)
     1111            RTLogWriteVmm(pszSecond, cchSecond, true /*fReleaseLog*/);
     1112    }
     1113# endif
    10871114
    10881115    if (pLoggerInt->fDestFlags & RTLOGDEST_DEBUGGER)
    … …  
    24362463        for (i = 0; i < RT_ELEMENTS(g_aLogDst); i++)
    24372464        {
    2438             size_t cchInstr = strlen(g_aLogDst[i].pszInstr);
    2439             if (!strncmp(pszValue, g_aLogDst[i].pszInstr, cchInstr))
     2465            if (!strncmp(pszValue, g_aLogDst[i].pszInstr, g_aLogDst[i].cchInstr))
    24402466            {
    24412467                if (!fNo)
    … …  
    24432469                else
    24442470                    pLoggerInt->fDestFlags &= ~g_aLogDst[i].fFlag;
    2445                 pszValue += cchInstr;
     2471                pszValue += g_aLogDst[i].cchInstr;
    24462472
    24472473                /* check for value. */
    … …  
    32163242
    32173243
     3244/**
     3245 * Write/copy bulk log data from a nested VM logger.
     3246 *
     3247 * This is used for
     3248 *
     3249 * @returns IRPT status code.
     3250 * @param   pLogger             The logger instance (NULL for default logger).
     3251 * @param   pch                 Pointer to the block of bulk log text to write.
     3252 * @param   cch                 Size of the block of bulk log text to write.
     3253 * @param   pszInfix            String to put after the line prefixes and the
     3254 *                              line content.
     3255 */
     3256RTDECL(int) RTLogBulkNestedWrite(PRTLOGGER pLogger, const char *pch, size_t cch, const char *pszInfix)
     3257{
     3258    if (cch > 0)
     3259    {
     3260        PRTLOGGERINTERNAL pLoggerInt = (PRTLOGGERINTERNAL)pLogger;
     3261        RTLOG_RESOLVE_DEFAULT_RET(pLoggerInt, VINF_LOG_NO_LOGGER);
     3262
     3263        /*
     3264         * Lock and validate it.
     3265         */
     3266        int rc = rtlogLock(pLoggerInt);
     3267        if (RT_SUCCESS(rc))
     3268        {
     3269            /*
     3270             * If we've got an auxilary descriptor, check if the buffer was flushed.
     3271             */
     3272            PRTLOGBUFFERDESC    pBufDesc = pLoggerInt->pBufDesc;
     3273            PRTLOGBUFFERAUXDESC pAuxDesc = pBufDesc->pAux;
     3274            if (!pAuxDesc || !pAuxDesc->fFlushedIndicator)
     3275            { /* likely, except maybe for ring-0 */ }
     3276            else
     3277            {
     3278                pAuxDesc->fFlushedIndicator = false;
     3279                pBufDesc->offBuf            = 0;
     3280            }
     3281
     3282            /*
     3283             * Write the stuff.
     3284             */
     3285            RTLOGOUTPUTPREFIXEDARGS Args;
     3286            Args.pLoggerInt = pLoggerInt;
     3287            Args.fFlags     = 0;
     3288            Args.iGroup     = ~0U;
     3289            Args.pszInfix   = pszInfix;
     3290            rtLogOutputPrefixed(&Args, pch, cch);
     3291            rtLogOutputPrefixed(&Args, pch, 0); /* termination call */
     3292
     3293            /*
     3294             * Maybe flush the buffer and update the auxiliary descriptor if there is one.
     3295             */
     3296            pBufDesc = pLoggerInt->pBufDesc;  /* (the descriptor may have changed) */
     3297            if (    !(pLoggerInt->fFlags & RTLOGFLAGS_BUFFERED)
     3298                &&  pBufDesc->offBuf)
     3299                rtlogFlush(pLoggerInt, false /*fNeedSpace*/);
     3300            else
     3301            {
     3302                pAuxDesc = pBufDesc->pAux;
     3303                if (pAuxDesc)
     3304                    pAuxDesc->offBuf = pBufDesc->offBuf;
     3305            }
     3306
     3307            rtlogUnlock(pLoggerInt);
     3308        }
     3309        return rc;
     3310    }
     3311    return VINF_SUCCESS;
     3312}
     3313RT_EXPORT_SYMBOL(RTLogBulkNestedWrite);
     3314
     3315
    32183316/*********************************************************************************************************************************
    32193317*   Flushing                                                                                                                     *
    … …  
    33263424        if (pLoggerInt->fDestFlags & RTLOGDEST_USER)
    33273425            RTLogWriteUser(pchToFlush, cchToFlush);
     3426
     3427#if defined(RT_ARCH_X86) || defined(RT_ARCH_AMD64)
     3428        if (pLoggerInt->fDestFlags & RTLOGDEST_VMM)
     3429            RTLogWriteVmm(pchToFlush, cchToFlush, false /*fReleaseLog*/);
     3430
     3431        if (pLoggerInt->fDestFlags & RTLOGDEST_VMM_REL)
     3432            RTLogWriteVmm(pchToFlush, cchToFlush, true /*fReleaseLog*/);
     3433#endif
    33283434
    33293435        if (pLoggerInt->fDestFlags & RTLOGDEST_DEBUGGER)
    … …  
    34713577            RTLogWriteUser(pThis->achScratch, pThis->offScratch);
    34723578
     3579# if defined(RT_ARCH_X86) || defined(RT_ARCH_AMD64)
     3580        if (pThis->fDestFlags & RTLOGDEST_VMM)
     3581            RTLogWriteVmm(pThis->achScratch, pThis->offScratch, false /*fReleaseLog*/);
     3582
     3583        if (pThis->fDestFlags & RTLOGDEST_VMM_REL)
     3584            RTLogWriteVmm(pThis->achScratch, pThis->offScratch, true /*fReleaseLog*/);
     3585# endif
     3586
    34733587        if (pThis->fDestFlags & RTLOGDEST_DEBUGGER)
    34743588            RTLogWriteDebugger(pThis->achScratch, pThis->offScratch);
    … …  
    37583872    if (cbChars)
    37593873    {
    3760         size_t cbRet = 0;
     3874        uint64_t const fFlags = pLoggerInt->fFlags;
     3875        size_t         cbRet  = 0;
    37613876        for (;;)
    37623877        {
    … …  
    37913906                /*
    37923907                 * Flush the buffer if there isn't enough room for the maximum prefix config.
    3793                  * Max is 256, add a couple of extra bytes.  See CCH_PREFIX check way below.
     3908                 * Max is 265, add a couple of extra bytes.  See CCH_PREFIX check way below.
    37943909                 */
    3795                 if (cb >= 256 + 16)
     3910                if (cb >= 265 + 16)
    37963911                    pLoggerInt->fPendingPrefix = false;
    37973912                else
    … …  
    38063921                 */
    38073922                psz = &pchBuf[offBuf];
    3808                 if (pLoggerInt->fFlags & RTLOGFLAGS_PREFIX_TS)
     3923                if (fFlags & RTLOGFLAGS_PREFIX_TS)
    38093924                {
    3810                     uint64_t     u64    = RTTimeNanoTS();
    3811                     int          iBase  = 16;
    3812                     unsigned int fFlags = RTSTR_F_ZEROPAD;
    3813                     if (pLoggerInt->fFlags & RTLOGFLAGS_DECIMAL_TS)
     3925                    uint64_t     u64       = RTTimeNanoTS();
     3926                    int          iBase     = 16;
     3927                    unsigned int fStrFlags = RTSTR_F_ZEROPAD;
     3928                    if (fFlags & RTLOGFLAGS_DECIMAL_TS)
    38143929                    {
    3815                         iBase = 10;
    3816                         fFlags = 0;
     3930                        iBase     = 10;
     3931                        fStrFlags = 0;
    38173932                    }
    3818                     if (pLoggerInt->fFlags & RTLOGFLAGS_REL_TS)
     3933                    if (fFlags & RTLOGFLAGS_REL_TS)
    38193934                    {
    38203935                        static volatile uint64_t s_u64LastTs;
    … …  
    38273942                    }
    38283943                    /* 1E15 nanoseconds = 11 days */
    3829                     psz += RTStrFormatNumber(psz, u64, iBase, 16, 0, fFlags);
     3944                    psz += RTStrFormatNumber(psz, u64, iBase, 16, 0, fStrFlags);
    38303945                    *psz++ = ' ';
    38313946                }
    38323947#define CCH_PREFIX_01   0 + 17
    38333948
    3834                 if (pLoggerInt->fFlags & RTLOGFLAGS_PREFIX_TSC)
     3949                if (fFlags & RTLOGFLAGS_PREFIX_TSC)
    38353950                {
    38363951#if defined(RT_ARCH_AMD64) || defined(RT_ARCH_X86)
    3837                     uint64_t     u64    = ASMReadTSC();
     3952                    uint64_t     u64       = ASMReadTSC();
    38383953#else
    3839                     uint64_t     u64    = RTTimeNanoTS();
     3954                    uint64_t     u64       = RTTimeNanoTS();
    38403955#endif
    3841                     int          iBase  = 16;
    3842                     unsigned int fFlags = RTSTR_F_ZEROPAD;
    3843                     if (pLoggerInt->fFlags & RTLOGFLAGS_DECIMAL_TS)
     3956                    int          iBase     = 16;
     3957                    unsigned int fStrFlags = RTSTR_F_ZEROPAD;
     3958                    if (fFlags & RTLOGFLAGS_DECIMAL_TS)
    38443959                    {
    3845                         iBase = 10;
    3846                         fFlags = 0;
     3960                        iBase    = 10;
     3961                        fStrFlags = 0;
    38473962                    }
    3848                     if (pLoggerInt->fFlags & RTLOGFLAGS_REL_TS)
     3963                    if (fFlags & RTLOGFLAGS_REL_TS)
    38493964                    {
    38503965                        static volatile uint64_t s_u64LastTsc;
    … …  
    38573972                    }
    38583973                    /* 1E15 ticks at 4GHz = 69 hours */
    3859                     psz += RTStrFormatNumber(psz, u64, iBase, 16, 0, fFlags);
     3974                    psz += RTStrFormatNumber(psz, u64, iBase, 16, 0, fStrFlags);
    38603975                    *psz++ = ' ';
    38613976                }
    38623977#define CCH_PREFIX_02   CCH_PREFIX_01 + 17
    38633978
    3864                 if (pLoggerInt->fFlags & RTLOGFLAGS_PREFIX_MS_PROG)
     3979                if (fFlags & RTLOGFLAGS_PREFIX_MS_PROG)
    38653980                {
    38663981#ifndef IN_RING0
    … …  
    38753990#define CCH_PREFIX_03   CCH_PREFIX_02 + 21
    38763991
    3877                 if (pLoggerInt->fFlags & RTLOGFLAGS_PREFIX_TIME)
     3992                if (fFlags & RTLOGFLAGS_PREFIX_TIME)
    38783993                {
    38793994#if defined(IN_RING3) || defined(IN_RING0)
    … …  
    38964011#define CCH_PREFIX_04   CCH_PREFIX_03 + (3+1+3+1+3+1+7+1)
    38974012
    3898                 if (pLoggerInt->fFlags & RTLOGFLAGS_PREFIX_TIME_PROG)
     4013                if (fFlags & RTLOGFLAGS_PREFIX_TIME_PROG)
    38994014                {
    39004015
    … …  
    39204035
    39214036# if 0
    3922                 if (pLoggerInt->fFlags & RTLOGFLAGS_PREFIX_DATETIME)
     4037                if (fFlags & RTLOGFLAGS_PREFIX_DATETIME)
    39234038                {
    39244039                    char szDate[32];
    … …  
    39354050# endif
    39364051
    3937                 if (pLoggerInt->fFlags & RTLOGFLAGS_PREFIX_PID)
     4052                if (fFlags & RTLOGFLAGS_PREFIX_PID)
    39384053                {
    39394054                    RTPROCESS Process = RTProcSelf();
    … …  
    39434058#define CCH_PREFIX_07   CCH_PREFIX_06 + 9
    39444059
    3945                 if (pLoggerInt->fFlags & RTLOGFLAGS_PREFIX_TID)
     4060                if (fFlags & RTLOGFLAGS_PREFIX_TID)
    39464061                {
    39474062                    RTNATIVETHREAD Thread = RTThreadNativeSelf();
    … …  
    39514066#define CCH_PREFIX_08   CCH_PREFIX_07 + 17
    39524067
    3953                 if (pLoggerInt->fFlags & RTLOGFLAGS_PREFIX_THREAD)
     4068                if (fFlags & RTLOGFLAGS_PREFIX_THREAD)
    39544069                {
    39554070#ifdef IN_RING3
    … …  
    39644079#define CCH_PREFIX_09   CCH_PREFIX_08 + 17
    39654080
    3966                 if (pLoggerInt->fFlags & RTLOGFLAGS_PREFIX_CPUID)
     4081                if (fFlags & RTLOGFLAGS_PREFIX_CPUID)
    39674082                {
    39684083#if defined(RT_ARCH_AMD64) || defined(RT_ARCH_X86)
    … …  
    39764091#define CCH_PREFIX_10   CCH_PREFIX_09 + 17
    39774092
    3978                 if (    (pLoggerInt->fFlags & RTLOGFLAGS_PREFIX_CUSTOM)
     4093                if (    (fFlags & RTLOGFLAGS_PREFIX_CUSTOM)
    39794094                    &&  pLoggerInt->pfnPrefix)
    39804095                {
    … …  
    39844099#define CCH_PREFIX_11   CCH_PREFIX_10 + 32
    39854100
    3986                 if (pLoggerInt->fFlags & RTLOGFLAGS_PREFIX_LOCK_COUNTS)
     4101                if (fFlags & RTLOGFLAGS_PREFIX_LOCK_COUNTS)
    39874102                {
    39884103#ifdef IN_RING3 /** @todo implement these counters in ring-0 too? */
    … …  
    40094124#define CCH_PREFIX_12   CCH_PREFIX_11 + 8
    40104125
    4011                 if (pLoggerInt->fFlags & RTLOGFLAGS_PREFIX_FLAG_NO)
     4126                if (fFlags & RTLOGFLAGS_PREFIX_FLAG_NO)
    40124127                {
    40134128                    psz += RTStrFormatNumber(psz, pArgs->fFlags, 16, 8, 0, RTSTR_F_ZEROPAD);
    … …  
    40164131#define CCH_PREFIX_13   CCH_PREFIX_12 + 9
    40174132
    4018                 if (pLoggerInt->fFlags & RTLOGFLAGS_PREFIX_FLAG)
     4133                if (fFlags & RTLOGFLAGS_PREFIX_FLAG)
    40194134                {
    40204135#ifdef IN_RING3
    … …  
    40274142#define CCH_PREFIX_14   CCH_PREFIX_13 + 17
    40284143
    4029                 if (pLoggerInt->fFlags & RTLOGFLAGS_PREFIX_GROUP_NO)
     4144                if (fFlags & RTLOGFLAGS_PREFIX_GROUP_NO)
    40304145                {
    40314146                    if (pArgs->iGroup != ~0U)
    … …  
    40424157#define CCH_PREFIX_15   CCH_PREFIX_14 + 9
    40434158
    4044                 if (pLoggerInt->fFlags & RTLOGFLAGS_PREFIX_GROUP)
     4159                if (fFlags & RTLOGFLAGS_PREFIX_GROUP)
    40454160                {
    40464161                    const unsigned fGrp = pLoggerInt->afGroups[pArgs->iGroup != ~0U ? pArgs->iGroup : 0];
    … …  
    40714186#define CCH_PREFIX_16   CCH_PREFIX_15 + 17
    40724187
    4073 #define CCH_PREFIX      ( CCH_PREFIX_16 )
    4074                 { AssertCompile(CCH_PREFIX < 256); }
     4188                if (pArgs->pszInfix)
     4189                {
     4190                    size_t cchInfix = strlen(pArgs->pszInfix);
     4191                    psz = rtLogStPNCpyPad2(psz, pArgs->pszInfix, RT_MIN(cchInfix, 8), 1);
     4192                }
     4193#define CCH_PREFIX_17   CCH_PREFIX_16 + 9
     4194
     4195
     4196#define CCH_PREFIX      ( CCH_PREFIX_17 )
     4197                { AssertCompile(CCH_PREFIX < 265); }
    40754198
    40764199                /*
    … …  
    40784201                 */
    40794202                AssertMsg(psz - &pchBuf[offBuf] <= 223,
    4080                           ("%#zx (%zd) - fFlags=%#x\n", psz - &pchBuf[offBuf], psz - &pchBuf[offBuf], pLoggerInt->fFlags));
     4203                          ("%#zx (%zd) - fFlags=%#x\n", psz - &pchBuf[offBuf], psz - &pchBuf[offBuf], fFlags));
    40814204                pBufDesc->offBuf = offBuf = (uint32_t)(psz - pchBuf);
    40824205                cb = cbBuf - offBuf - 1;
    … …  
    41014224            {
    41024225                cb = pszNewLine - pachChars;
    4103                 if (!(pLoggerInt->fFlags & RTLOGFLAGS_USECRLF))
     4226                if (!(fFlags & RTLOGFLAGS_USECRLF))
    41044227                {
    41054228                    cb += 1;
    … …  
    41914314        OutputArgs.iGroup     = iGroup;
    41924315        OutputArgs.fFlags     = fFlags;
     4316        OutputArgs.pszInfix   = NULL;
    41934317        RTLogFormatV(rtLogOutputPrefixed, &OutputArgs, pszFormat, args);
    41944318    }

  • trunk/src/VBox/VMM/VMMAll/IEMAll.cpp

    r96745 r96811  
    59335933     * Check the input and figure out which mapping entry to use.
    59345934     */
    5935     Assert(cbMem <= 64 || cbMem == 512 || cbMem == 256 || cbMem == 108 || cbMem == 104 || cbMem == 102 || cbMem == 94); /* 512 is the max! */
     5935    Assert(cbMem <= sizeof(pVCpu->iem.s.aBounceBuffers[0]));
     5936    Assert(   cbMem <= 64 || cbMem == 512 || cbMem == 256 || cbMem == 108 || cbMem == 104 || cbMem == 102 || cbMem == 94
     5937           || (iSegReg == UINT8_MAX && uAlignCtl == 0 && fAccess == IEM_ACCESS_DATA_R /* for the CPUID logging interface */) );
    59365938    Assert(~(fAccess & ~(IEM_ACCESS_TYPE_MASK | IEM_ACCESS_WHAT_MASK)));
    59375939    Assert(pVCpu->iem.s.cActiveMappings < RT_ELEMENTS(pVCpu->iem.s.aMemMappings));

  • trunk/src/VBox/VMM/VMMAll/IEMAllCImpl.cpp

    r96637 r96811  
    4848#ifdef VBOX_WITH_NESTED_HWVIRT_VMX
    4949# include <VBox/vmm/hmvmxinline.h>
     50#endif
     51#ifndef VBOX_WITHOUT_CPUID_HOST_CALL
     52# include <VBox/vmm/cpuidcall.h>
    5053#endif
    5154#include <VBox/vmm/tm.h>
    … …  
    77557758
    77567759
     7760#ifndef VBOX_WITHOUT_CPUID_HOST_CALL
     7761/**
     7762 * Handles a CPUID call.
     7763 */
     7764static VBOXSTRICTRC iemCpuIdVBoxCall(PVMCPUCC pVCpu, uint32_t iFunction,
     7765                                     uint32_t *pEax, uint32_t *pEbx, uint32_t *pEcx, uint32_t *pEdx)
     7766{
     7767    switch (iFunction)
     7768    {
     7769        case VBOX_CPUID_FN_ID:
     7770            LogFlow(("iemCpuIdVBoxCall: VBOX_CPUID_FN_ID\n"));
     7771            *pEax = VBOX_CPUID_RESP_ID_EAX;
     7772            *pEbx = VBOX_CPUID_RESP_ID_EBX;
     7773            *pEcx = VBOX_CPUID_RESP_ID_ECX;
     7774            *pEdx = VBOX_CPUID_RESP_ID_EDX;
     7775            break;
     7776
     7777        case VBOX_CPUID_FN_LOG:
     7778        {
     7779            CPUM_IMPORT_EXTRN_RET(pVCpu, CPUMCTX_EXTRN_RDX | CPUMCTX_EXTRN_RBX | CPUMCTX_EXTRN_RSI
     7780                                       | IEM_CPUMCTX_EXTRN_EXEC_DECODED_MEM_MASK);
     7781
     7782            /* Validate input. */
     7783            uint32_t cchToLog = *pEdx;
     7784            if (cchToLog <= _2M)
     7785            {
     7786                uint32_t const uLogPicker = *pEbx;
     7787                if (uLogPicker <= 1)
     7788                {
     7789                    /* Resolve the logger. */
     7790                    PRTLOGGER const pLogger = !uLogPicker
     7791                                            ? RTLogDefaultInstanceEx(UINT32_MAX) : RTLogRelGetDefaultInstanceEx(UINT32_MAX);
     7792                    if (pLogger)
     7793                    {
     7794                        /* Copy over the data: */
     7795                        RTGCPTR GCPtrSrc = pVCpu->cpum.GstCtx.rsi;
     7796                        while (cchToLog > 0)
     7797                        {
     7798                            uint32_t cbToMap = GUEST_PAGE_SIZE - (GCPtrSrc & GUEST_PAGE_OFFSET_MASK);
     7799                            if (cbToMap > cchToLog)
     7800                                cbToMap = cchToLog;
     7801                            /** @todo Extend iemMemMap to allowing page size accessing and avoid 7
     7802                             *        unnecessary calls & iterations per pages. */
     7803                            if (cbToMap > 512)
     7804                                cbToMap = 512;
     7805                            void        *pvSrc    = NULL;
     7806                            VBOXSTRICTRC rcStrict = iemMemMap(pVCpu, &pvSrc, cbToMap, UINT8_MAX, GCPtrSrc, IEM_ACCESS_DATA_R, 0);
     7807                            if (rcStrict == VINF_SUCCESS)
     7808                            {
     7809                                RTLogBulkNestedWrite(pLogger, (const char *)pvSrc, cbToMap, "Gst:");
     7810                                rcStrict = iemMemCommitAndUnmap(pVCpu, pvSrc, IEM_ACCESS_DATA_R);
     7811                                AssertRCSuccessReturn(VBOXSTRICTRC_VAL(rcStrict), rcStrict);
     7812                            }
     7813                            else
     7814                            {
     7815                                Log(("iemCpuIdVBoxCall: %Rrc at %RGp LB %#x\n", VBOXSTRICTRC_VAL(rcStrict), GCPtrSrc, cbToMap));
     7816                                return rcStrict;
     7817                            }
     7818
     7819                            /* Advance. */
     7820                            pVCpu->cpum.GstCtx.rsi = GCPtrSrc += cbToMap;
     7821                            *pEdx                  = cchToLog -= cbToMap;
     7822                        }
     7823                        *pEax = VINF_SUCCESS;
     7824                    }
     7825                    else
     7826                        *pEax = (uint32_t)VERR_NOT_FOUND;
     7827                }
     7828                else
     7829                    *pEax = (uint32_t)VERR_NOT_FOUND;
     7830            }
     7831            else
     7832                *pEax = (uint32_t)VERR_TOO_MUCH_DATA;
     7833            *pEdx = VBOX_CPUID_RESP_GEN_EDX;
     7834            *pEcx = VBOX_CPUID_RESP_GEN_ECX;
     7835            *pEbx = VBOX_CPUID_RESP_GEN_EBX;
     7836            break;
     7837        }
     7838
     7839        default:
     7840            LogFlow(("iemCpuIdVBoxCall: Invalid function %#x (%#x, %#x)\n", iFunction, *pEbx, *pEdx));
     7841            *pEax = (uint32_t)VERR_INVALID_FUNCTION;
     7842            *pEbx = (uint32_t)VERR_INVALID_FUNCTION;
     7843            *pEcx = (uint32_t)VERR_INVALID_FUNCTION;
     7844            *pEdx = (uint32_t)VERR_INVALID_FUNCTION;
     7845            break;
     7846    }
     7847    return VINF_SUCCESS;
     7848}
     7849#endif /* VBOX_WITHOUT_CPUID_HOST_CALL */
     7850
    77577851/**
    77587852 * Implements 'CPUID'.
    … …  
    77737867    }
    77747868
    7775     CPUMGetGuestCpuId(pVCpu, pVCpu->cpum.GstCtx.eax, pVCpu->cpum.GstCtx.ecx, pVCpu->cpum.GstCtx.cs.Attr.n.u1Long,
    7776                       &pVCpu->cpum.GstCtx.eax, &pVCpu->cpum.GstCtx.ebx, &pVCpu->cpum.GstCtx.ecx, &pVCpu->cpum.GstCtx.edx);
     7869
     7870    uint32_t const uEax = pVCpu->cpum.GstCtx.eax;
     7871    uint32_t const uEcx = pVCpu->cpum.GstCtx.ecx;
     7872
     7873#ifndef VBOX_WITHOUT_CPUID_HOST_CALL
     7874    /*
     7875     * CPUID host call backdoor.
     7876     */
     7877    if (   uEax == VBOX_CPUID_REQ_EAX_FIXED
     7878        && (uEcx & VBOX_CPUID_REQ_ECX_FIXED_MASK) == VBOX_CPUID_REQ_ECX_FIXED
     7879        && pVCpu->CTX_SUFF(pVM)->iem.s.fCpuIdHostCall)
     7880    {
     7881        VBOXSTRICTRC rcStrict = iemCpuIdVBoxCall(pVCpu, uEcx & VBOX_CPUID_REQ_ECX_FN_MASK,
     7882                                                 &pVCpu->cpum.GstCtx.eax, &pVCpu->cpum.GstCtx.ebx,
     7883                                                 &pVCpu->cpum.GstCtx.ecx, &pVCpu->cpum.GstCtx.edx);
     7884        if (rcStrict != VINF_SUCCESS)
     7885            return rcStrict;
     7886    }
     7887    /*
     7888     * Regular CPUID.
     7889     */
     7890    else
     7891#endif
     7892        CPUMGetGuestCpuId(pVCpu, uEax, uEcx, pVCpu->cpum.GstCtx.cs.Attr.n.u1Long,
     7893                          &pVCpu->cpum.GstCtx.eax, &pVCpu->cpum.GstCtx.ebx, &pVCpu->cpum.GstCtx.ecx, &pVCpu->cpum.GstCtx.edx);
     7894
    77777895    pVCpu->cpum.GstCtx.rax &= UINT32_C(0xffffffff);
    77787896    pVCpu->cpum.GstCtx.rbx &= UINT32_C(0xffffffff);

  • trunk/src/VBox/VMM/VMMR0/HMSVMR0.cpp

    r96407 r96811  
    69396939        if (rcStrict == VINF_IEM_RAISED_XCPT)
    69406940        {
     6941            CPUM_ASSERT_NOT_EXTRN(pVCpu, IEM_CPUMCTX_EXTRN_XCPT_MASK);
    69416942            ASMAtomicUoOrU64(&pVCpu->hm.s.fCtxChanged, HM_CHANGED_RAISED_XCPT_MASK);
    69426943            rcStrict = VINF_SUCCESS;

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

    r96407 r96811  
    8989VMMR3DECL(int)      IEMR3Init(PVM pVM)
    9090{
     91    int rc;
     92
     93    /*
     94     * Read configuration.
     95     */
     96    PCFGMNODE pIem = CFGMR3GetChild(CFGMR3GetRoot(pVM), "IEM");
     97
     98#ifndef VBOX_WITHOUT_CPUID_HOST_CALL
     99    /** @cfgm{/IEM/CpuIdHostCall, boolean, false}
     100     * Controls whether the custom VBox specific CPUID host call interface is
     101     * enabled or not. */
     102# ifdef DEBUG_bird
     103    rc = CFGMR3QueryBoolDef(pIem, "CpuIdHostCall", &pVM->iem.s.fCpuIdHostCall, true);
     104# else
     105    rc = CFGMR3QueryBoolDef(pIem, "CpuIdHostCall", &pVM->iem.s.fCpuIdHostCall, false);
     106# endif
     107    AssertLogRelRCReturn(rc, rc);
     108#endif
     109
     110    /*
     111     * Initialize per-CPU data and register statistics.
     112     */
    91113    uint64_t const uInitialTlbRevision = UINT64_C(0) - (IEMTLB_REVISION_INCR * 200U);
    92114    uint64_t const uInitialTlbPhysRev  = UINT64_C(0) - (IEMTLB_PHYS_REV_INCR * 100U);
    … …  
    224246    if (pVM->cpum.ro.GuestFeatures.fVmx)
    225247    {
    226         int rc = PGMR3HandlerPhysicalTypeRegister(pVM, PGMPHYSHANDLERKIND_ALL, 0 /*fFlags*/,
    227                                                   iemVmxApicAccessPageHandler,
    228                                                   "VMX APIC-access page", &pVM->iem.s.hVmxApicAccessPage);
     248        rc = PGMR3HandlerPhysicalTypeRegister(pVM, PGMPHYSHANDLERKIND_ALL, 0 /*fFlags*/,
     249                                              iemVmxApicAccessPageHandler,
     250                                              "VMX APIC-access page", &pVM->iem.s.hVmxApicAccessPage);
    229251        AssertLogRelRCReturn(rc, rc);
    230252    }

  • trunk/src/VBox/VMM/include/IEMInternal.h

    r96796 r96811  
    863863    /** The VMX APIC-access page handler type. */
    864864    PGMPHYSHANDLERTYPE      hVmxApicAccessPage;
     865#ifndef VBOX_WITHOUT_CPUID_HOST_CALL
     866    /** Set if the CPUID host call functionality is enabled.   */
     867    bool                    fCpuIdHostCall;
     868#endif
    865869} IEM;
    866870
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