VirtualBox

Changeset 54654 in vbox for trunk/src/VBox


Ignore:
Timestamp:
Mar 5, 2015 3:43:41 PM (10 years ago)
Author:
vboxsync
Message:

VMM/GIM: cleanup.

Location:
trunk/src/VBox/VMM
Files:
8 edited

Legend:

Unmodified
Added
Removed

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

    r53466 r54654  
    55
    66/*
    7  * Copyright (C) 2014 Oracle Corporation
     7 * Copyright (C) 2014-2015 Oracle Corporation
    88 *
    99 * This file is part of VirtualBox Open Source Edition (OSE), as
    … …  
    7171    {
    7272        case GIMPROVIDERID_HYPERV:
    73             return GIMHvAreHypercallsEnabled(pVCpu);
     73            return gimHvAreHypercallsEnabled(pVCpu);
    7474
    7575        default:
    … …  
    9797    {
    9898        case GIMPROVIDERID_HYPERV:
    99             return GIMHvHypercall(pVCpu, pCtx);
     99            return gimHvHypercall(pVCpu, pCtx);
    100100
    101101        default:
    … …  
    121121    {
    122122        case GIMPROVIDERID_HYPERV:
    123             return GIMHvIsParavirtTscEnabled(pVM);
     123            return gimHvIsParavirtTscEnabled(pVM);
    124124
    125125        default:
    … …  
    152152    {
    153153        case GIMPROVIDERID_HYPERV:
    154             return GIMHvReadMsr(pVCpu, idMsr, pRange, puValue);
     154            return gimHvReadMsr(pVCpu, idMsr, pRange, puValue);
    155155
    156156        default:
    … …  
    186186    {
    187187        case GIMPROVIDERID_HYPERV:
    188             return GIMHvWriteMsr(pVCpu, idMsr, pRange, uRawValue);
     188            return gimHvWriteMsr(pVCpu, idMsr, pRange, uRawValue);
    189189
    190190        default:

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

    r54089 r54654  
    55
    66/*
    7  * Copyright (C) 2014 Oracle Corporation
     7 * Copyright (C) 2014-2015 Oracle Corporation
    88 *
    99 * This file is part of VirtualBox Open Source Edition (OSE), as
    … …  
    4242 * @param   pCtx            Pointer to the guest-CPU context.
    4343 */
    44 VMM_INT_DECL(int) GIMHvHypercall(PVMCPU pVCpu, PCPUMCTX pCtx)
     44VMM_INT_DECL(int) gimHvHypercall(PVMCPU pVCpu, PCPUMCTX pCtx)
    4545{
    4646    PVM pVM = pVCpu->CTX_SUFF(pVM);
    … …  
    6060 * @param   pVCpu       Pointer to the VMCPU.
    6161 */
    62 VMM_INT_DECL(bool) GIMHvAreHypercallsEnabled(PVMCPU pVCpu)
     62VMM_INT_DECL(bool) gimHvAreHypercallsEnabled(PVMCPU pVCpu)
    6363{
    6464    return MSR_GIM_HV_HYPERCALL_IS_ENABLED(pVCpu->CTX_SUFF(pVM)->gim.s.u.Hv.u64HypercallMsr);
    … …  
    7373 * @param   pVM     Pointer to the VM.
    7474 */
    75 VMM_INT_DECL(bool) GIMHvIsParavirtTscEnabled(PVM pVM)
     75VMM_INT_DECL(bool) gimHvIsParavirtTscEnabled(PVM pVM)
    7676{
    7777    return MSR_GIM_HV_REF_TSC_IS_ENABLED(pVM->gim.s.u.Hv.u64TscPageMsr);
    … …  
    9191 * @param   puValue     Where to store the MSR value read.
    9292 */
    93 VMM_INT_DECL(VBOXSTRICTRC) GIMHvReadMsr(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
     93VMM_INT_DECL(VBOXSTRICTRC) gimHvReadMsr(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue)
    9494{
    9595    NOREF(pRange);
    … …  
    179179 * @param   uRawValue   The raw value with the ignored bits not masked.
    180180 */
    181 VMM_INT_DECL(VBOXSTRICTRC) GIMHvWriteMsr(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uRawValue)
     181VMM_INT_DECL(VBOXSTRICTRC) gimHvWriteMsr(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uRawValue)
    182182{
    183183    NOREF(pRange);
    … …  
    207207            if (!uRawValue)
    208208            {
    209                 GIMR3HvDisableHypercallPage(pVM);
     209                gimR3HvDisableHypercallPage(pVM);
    210210                pHv->u64HypercallMsr &= ~MSR_GIM_HV_HYPERCALL_ENABLE_BIT;
    211211            }
    … …  
    241241            if (!fEnable)
    242242            {
    243                 GIMR3HvDisableHypercallPage(pVM);
     243                gimR3HvDisableHypercallPage(pVM);
    244244                pHv->u64HypercallMsr = uRawValue;
    245245                return VINF_SUCCESS;
    … …  
    248248            /* Enable the hypercall-page. */
    249249            RTGCPHYS GCPhysHypercallPage = MSR_GIM_HV_HYPERCALL_GUEST_PFN(uRawValue) << PAGE_SHIFT;
    250             int rc = GIMR3HvEnableHypercallPage(pVM, GCPhysHypercallPage);
     250            int rc = gimR3HvEnableHypercallPage(pVM, GCPhysHypercallPage);
    251251            if (RT_SUCCESS(rc))
    252252            {
    … …  
    272272            if (!fEnable)
    273273            {
    274                 GIMR3HvDisableTscPage(pVM);
     274                gimR3HvDisableTscPage(pVM);
    275275                pHv->u64TscPageMsr = uRawValue;
    276276                return VINF_SUCCESS;
    … …  
    279279            /* Enable the TSC-page. */
    280280            RTGCPHYS GCPhysTscPage = MSR_GIM_HV_REF_TSC_GUEST_PFN(uRawValue) << PAGE_SHIFT;
    281             int rc = GIMR3HvEnableTscPage(pVM, GCPhysTscPage, false /* fUseThisTscSequence */, 0 /* uTscSequence */);
     281            int rc = gimR3HvEnableTscPage(pVM, GCPhysTscPage, false /* fUseThisTscSequence */, 0 /* uTscSequence */);
    282282            if (RT_SUCCESS(rc))
    283283            {

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

    r52767 r54654  
    55
    66/*
    7  * Copyright (C) 2014 Oracle Corporation
     7 * Copyright (C) 2014-2015 Oracle Corporation
    88 *
    99 * This file is part of VirtualBox Open Source Edition (OSE), as
    … …  
    4141    {
    4242        case GIMPROVIDERID_HYPERV:
    43             return GIMR0HvInitVM(pVM);
     43            return gimR0HvInitVM(pVM);
    4444
    4545        default:
    … …  
    6464    {
    6565        case GIMPROVIDERID_HYPERV:
    66             return GIMR0HvTermVM(pVM);
     66            return gimR0HvTermVM(pVM);
    6767
    6868        default:
    … …  
    9393    {
    9494        case GIMPROVIDERID_HYPERV:
    95             return GIMR0HvUpdateParavirtTsc(pVM, u64Offset);
     95            return gimR0HvUpdateParavirtTsc(pVM, u64Offset);
    9696
    9797        case GIMPROVIDERID_NONE:

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

    r54065 r54654  
    129129        {
    130130            pVM->gim.s.enmProviderId = GIMPROVIDERID_MINIMAL;
    131             rc = GIMR3MinimalInit(pVM);
     131            rc = gimR3MinimalInit(pVM);
    132132        }
    133133        else if (!RTStrCmp(szProvider, "HyperV"))
    134134        {
    135135            pVM->gim.s.enmProviderId = GIMPROVIDERID_HYPERV;
    136             rc = GIMR3HvInit(pVM);
     136            rc = gimR3HvInit(pVM);
    137137        }
    138138        /** @todo KVM and others. */
    … …  
    159159    {
    160160        case GIMPROVIDERID_MINIMAL:
    161             return GIMR3MinimalInitCompleted(pVM);
    162 
    163         case GIMPROVIDERID_HYPERV:
    164             return GIMR3HvInitCompleted(pVM);
     161            return gimR3MinimalInitCompleted(pVM);
     162
     163        case GIMPROVIDERID_HYPERV:
     164            return gimR3HvInitCompleted(pVM);
    165165
    166166        default:
    … …  
    194194        case GIMPROVIDERID_MINIMAL:
    195195        {
    196             GIMR3MinimalRelocate(pVM, offDelta);
    197             break;
    198         }
    199 
    200         case GIMPROVIDERID_HYPERV:
    201         {
    202             GIMR3HvRelocate(pVM, offDelta);
     196            gimR3MinimalRelocate(pVM, offDelta);
     197            break;
     198        }
     199
     200        case GIMPROVIDERID_HYPERV:
     201        {
     202            gimR3HvRelocate(pVM, offDelta);
    203203            break;
    204204        }
    … …  
    248248    {
    249249        case GIMPROVIDERID_HYPERV:
    250             rc = GIMR3HvSave(pVM, pSSM);
     250            rc = gimR3HvSave(pVM, pSSM);
    251251            AssertRCReturn(rc, rc);
    252252            break;
    … …  
    311311    {
    312312        case GIMPROVIDERID_HYPERV:
    313             rc = GIMR3HvLoad(pVM, pSSM, uVersion);
     313            rc = gimR3HvLoad(pVM, pSSM, uVersion);
    314314            AssertRCReturn(rc, rc);
    315315            break;
    … …  
    337337    {
    338338        case GIMPROVIDERID_HYPERV:
    339             return GIMR3HvTerm(pVM);
     339            return gimR3HvTerm(pVM);
    340340
    341341        default:
    … …  
    360360    {
    361361        case GIMPROVIDERID_HYPERV:
    362             return GIMR3HvReset(pVM);
     362            return gimR3HvReset(pVM);
    363363
    364364        default:
    … …  
    401401    {
    402402        case GIMPROVIDERID_HYPERV:
    403             return GIMR3HvGetMmio2Regions(pVM, pcRegions);
     403            return gimR3HvGetMmio2Regions(pVM, pcRegions);
    404404
    405405        case GIMPROVIDERID_KVM:            /** @todo KVM. */

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

    r54065 r54654  
    8686 * @param   uVersion    The interface version this VM should use.
    8787 */
    88 VMMR3_INT_DECL(int) GIMR3HvInit(PVM pVM)
     88VMMR3_INT_DECL(int) gimR3HvInit(PVM pVM)
    8989{
    9090    AssertReturn(pVM, VERR_INVALID_PARAMETER);
    … …  
    239239 * @param   pVM     Pointer to the VM.
    240240 */
    241 VMMR3_INT_DECL(int) GIMR3HvInitCompleted(PVM pVM)
     241VMMR3_INT_DECL(int) gimR3HvInitCompleted(PVM pVM)
    242242{
    243243    PGIMHV pHv = &pVM->gim.s.u.Hv;
    … …  
    268268
    269269#if 0
    270 VMMR3_INT_DECL(int) GIMR3HvInitFinalize(PVM pVM)
     270VMMR3_INT_DECL(int) gimR3HvInitFinalize(PVM pVM)
    271271{
    272272    pVM->gim.s.pfnHypercallR3 = &GIMHvHypercall;
    … …  
    288288 * @param   pVM         Pointer to the VM.
    289289 */
    290 VMMR3_INT_DECL(int) GIMR3HvTerm(PVM pVM)
    291 {
    292     GIMR3HvReset(pVM);
     290VMMR3_INT_DECL(int) gimR3HvTerm(PVM pVM)
     291{
     292    gimR3HvReset(pVM);
    293293    return VINF_SUCCESS;
    294294}
    … …  
    304304 * @param   offDelta    Relocation delta relative to old location.
    305305 */
    306 VMMR3_INT_DECL(void) GIMR3HvRelocate(PVM pVM, RTGCINTPTR offDelta)
     306VMMR3_INT_DECL(void) gimR3HvRelocate(PVM pVM, RTGCINTPTR offDelta)
    307307{
    308308#if 0
    … …  
    321321 * @param   pVM     Pointer to the VM.
    322322 */
    323 VMMR3_INT_DECL(void) GIMR3HvReset(PVM pVM)
     323VMMR3_INT_DECL(void) gimR3HvReset(PVM pVM)
    324324{
    325325    /*
    … …  
    350350 * @param   pcRegions   Where to store the number of regions in the array.
    351351 */
    352 VMMR3_INT_DECL(PGIMMMIO2REGION) GIMR3HvGetMmio2Regions(PVM pVM, uint32_t *pcRegions)
     352VMMR3_INT_DECL(PGIMMMIO2REGION) gimR3HvGetMmio2Regions(PVM pVM, uint32_t *pcRegions)
    353353{
    354354    Assert(GIMIsEnabled(pVM));
    … …  
    368368 * @param   pSSM    Pointer to the SSM handle.
    369369 */
    370 VMMR3_INT_DECL(int) GIMR3HvSave(PVM pVM, PSSMHANDLE pSSM)
     370VMMR3_INT_DECL(int) gimR3HvSave(PVM pVM, PSSMHANDLE pSSM)
    371371{
    372372    PCGIMHV pcHv = &pVM->gim.s.u.Hv;
    … …  
    436436 * @param   uSSMVersion     The GIM saved-state version.
    437437 */
    438 VMMR3_INT_DECL(int) GIMR3HvLoad(PVM pVM, PSSMHANDLE pSSM, uint32_t uSSMVersion)
     438VMMR3_INT_DECL(int) gimR3HvLoad(PVM pVM, PSSMHANDLE pSSM, uint32_t uSSMVersion)
    439439{
    440440    PGIMHV pHv = &pVM->gim.s.u.Hv;
    … …  
    486486        if (RT_LIKELY(pRegion->fRegistered))
    487487        {
    488             rc = GIMR3HvEnableHypercallPage(pVM, pRegion->GCPhysPage);
     488            rc = gimR3HvEnableHypercallPage(pVM, pRegion->GCPhysPage);
    489489            if (RT_FAILURE(rc))
    490490                return SSMR3SetCfgError(pSSM, RT_SRC_POS, N_("Failed to enable the hypercall page. GCPhys=%#RGp rc=%Rrc"),
    … …  
    512512        if (pRegion->fRegistered)
    513513        {
    514             rc = GIMR3HvEnableTscPage(pVM, pRegion->GCPhysPage, true /* fUseThisTscSeq */, uTscSequence);
     514            rc = gimR3HvEnableTscPage(pVM, pRegion->GCPhysPage, true /* fUseThisTscSeq */, uTscSequence);
    515515            if (RT_FAILURE(rc))
    516516                return SSMR3SetCfgError(pSSM, RT_SRC_POS, N_("Failed to enable the TSC page. GCPhys=%#RGp rc=%Rrc"),
    … …  
    529529 *
    530530 * @returns VBox status code.
    531  * @param   pVM                     Pointer to the VM.
    532  * @param   GCPhysTscPage           Where to map the TSC page.
    533  * @param   fUseThisTscSequence     Whether to set the TSC sequence number to
    534  *                                  the one specified in @a uTscSequence.
    535  * @param   uTscSequence            The TSC sequence value to use. Ignored if @a
    536  *                                  fUseThisTscSequence is false.
    537                                                                     */
    538 VMMR3_INT_DECL(int) GIMR3HvEnableTscPage(PVM pVM, RTGCPHYS GCPhysTscPage, bool fUseThisTscSequence, uint32_t uTscSequence)
     531 * @param   pVM                Pointer to the VM.
     532 * @param   GCPhysTscPage      Where to map the TSC page.
     533 * @param   fUseThisTscSeq     Whether to set the TSC sequence number to the one
     534 *                             specified in @a uTscSeq.
     535 * @param   uTscSeq            The TSC sequence value to use. Ignored if
     536 *                             @a fUseThisTscSeq is false.
     537 */
     538VMMR3_INT_DECL(int) gimR3HvEnableTscPage(PVM pVM, RTGCPHYS GCPhysTscPage, bool fUseThisTscSeq, uint32_t uTscSeq)
    539539{
    540540    PPDMDEVINSR3    pDevIns = pVM->gim.s.pDevInsR3;
    … …  
    554554         * If it's mapped at a different address, unmap the previous address.
    555555         */
    556         rc = GIMR3HvDisableTscPage(pVM);
     556        rc = gimR3HvDisableTscPage(pVM);
    557557        AssertRC(rc);
    558558    }
    … …  
    579579        uint64_t const u64TscKHz = TMCpuTicksPerSecond(pVM) / UINT64_C(1000);
    580580        uint32_t       u32TscSeq = 1;
    581         if (   fUseThisTscSequence
    582             && uTscSequence < UINT32_C(0xfffffffe))
    583         {
    584             u32TscSeq = uTscSequence + 1;
    585         }
     581        if (   fUseThisTscSeq
     582            && uTscSeq < UINT32_C(0xfffffffe))
     583            u32TscSeq = uTscSeq + 1;
    586584        pRefTsc->u32TscSequence  = u32TscSeq;
    587585        pRefTsc->u64TscScale     = ((INT64_C(10000) << 32) / u64TscKHz) << 32;
    … …  
    607605 * @param   pVM     Pointer to the VM.
    608606 */
    609 VMMR3_INT_DECL(int) GIMR3HvDisableTscPage(PVM pVM)
     607VMMR3_INT_DECL(int) gimR3HvDisableTscPage(PVM pVM)
    610608{
    611609    PGIMHV pHv = &pVM->gim.s.u.Hv;
    … …  
    629627 * @returns VBox status code.
    630628 */
    631 VMMR3_INT_DECL(int) GIMR3HvDisableHypercallPage(PVM pVM)
     629VMMR3_INT_DECL(int) gimR3HvDisableHypercallPage(PVM pVM)
    632630{
    633631    PGIMHV pHv = &pVM->gim.s.u.Hv;
    … …  
    651649 * @param   GCPhysHypercallPage     Where to map the hypercall page.
    652650 */
    653 VMMR3_INT_DECL(int) GIMR3HvEnableHypercallPage(PVM pVM, RTGCPHYS GCPhysHypercallPage)
     651VMMR3_INT_DECL(int) gimR3HvEnableHypercallPage(PVM pVM, RTGCPHYS GCPhysHypercallPage)
    654652{
    655653    PPDMDEVINSR3    pDevIns = pVM->gim.s.pDevInsR3;
    … …  
    668666         * If it's mapped at a different address, unmap the previous address.
    669667         */
    670         int rc2 = GIMR3HvDisableHypercallPage(pVM);
     668        int rc2 = gimR3HvDisableHypercallPage(pVM);
    671669        AssertRC(rc2);
    672670    }

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

    r52707 r54654  
    55
    66/*
    7  * Copyright (C) 2014 Oracle Corporation
     7 * Copyright (C) 2014-2015 Oracle Corporation
    88 *
    99 * This file is part of VirtualBox Open Source Edition (OSE), as
    … …  
    4242 * @param   pVM     Pointer to the VM.
    4343 */
    44 VMMR3_INT_DECL(int) GIMR3MinimalInit(PVM pVM)
     44VMMR3_INT_DECL(int) gimR3MinimalInit(PVM pVM)
    4545{
    4646    AssertReturn(pVM, VERR_INVALID_PARAMETER);
    … …  
    6363 * @param   pVM     Pointer to the VM.
    6464 */
    65 VMMR3_INT_DECL(int) GIMR3MinimalInitCompleted(PVM pVM)
     65VMMR3_INT_DECL(int) gimR3MinimalInitCompleted(PVM pVM)
    6666{
    6767    /*
    … …  
    114114 * @param   offDelta    Relocation delta relative to old location.
    115115 */
    116 VMMR3_INT_DECL(void) GIMR3MinimalRelocate(PVM pVM, RTGCINTPTR offDelta)
     116VMMR3_INT_DECL(void) gimR3MinimalRelocate(PVM pVM, RTGCINTPTR offDelta)
    117117{
    118118    NOREF(pVM); NOREF(offDelta);

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

    r53509 r54654  
    55
    66/*
    7  * Copyright (C) 2014 Oracle Corporation
     7 * Copyright (C) 2014-2015 Oracle Corporation
    88 *
    99 * This file is part of VirtualBox Open Source Edition (OSE), as
    … …  
    495495RT_C_DECLS_BEGIN
    496496
    497 /** @todo r=bird: Internal header, internal prefix: s/GIM\(R.|\)Hv/gim\1Hv/g  */
    498 
    499497#ifdef IN_RING0
    500 VMMR0_INT_DECL(int)             GIMR0HvInitVM(PVM pVM);
    501 VMMR0_INT_DECL(int)             GIMR0HvTermVM(PVM pVM);
    502 VMMR0_INT_DECL(int)             GIMR0HvUpdateParavirtTsc(PVM pVM, uint64_t u64Offset);
     498VMMR0_INT_DECL(int)             gimR0HvInitVM(PVM pVM);
     499VMMR0_INT_DECL(int)             gimR0HvTermVM(PVM pVM);
     500VMMR0_INT_DECL(int)             gimR0HvUpdateParavirtTsc(PVM pVM, uint64_t u64Offset);
    503501#endif /* IN_RING0 */
    504502
    505503#ifdef IN_RING3
    506 VMMR3_INT_DECL(int)             GIMR3HvInit(PVM pVM);
    507 VMMR3_INT_DECL(int)             GIMR3HvInitCompleted(PVM pVM);
    508 VMMR3_INT_DECL(int)             GIMR3HvTerm(PVM pVM);
    509 VMMR3_INT_DECL(void)            GIMR3HvRelocate(PVM pVM, RTGCINTPTR offDelta);
    510 VMMR3_INT_DECL(void)            GIMR3HvReset(PVM pVM);
    511 VMMR3_INT_DECL(PGIMMMIO2REGION) GIMR3HvGetMmio2Regions(PVM pVM, uint32_t *pcRegions);
    512 VMMR3_INT_DECL(int)             GIMR3HvSave(PVM pVM, PSSMHANDLE pSSM);
    513 VMMR3_INT_DECL(int)             GIMR3HvLoad(PVM pVM, PSSMHANDLE pSSM, uint32_t uSSMVersion);
    514 
    515 VMMR3_INT_DECL(int)             GIMR3HvDisableTscPage(PVM pVM);
    516 VMMR3_INT_DECL(int)             GIMR3HvEnableTscPage(PVM pVM, RTGCPHYS GCPhysTscPage, bool fUseThisTscSequence, uint32_t uTscSequence);
    517 VMMR3_INT_DECL(int)             GIMR3HvDisableHypercallPage(PVM pVM);
    518 VMMR3_INT_DECL(int)             GIMR3HvEnableHypercallPage(PVM pVM, RTGCPHYS GCPhysHypercallPage);
     504VMMR3_INT_DECL(int)             gimR3HvInit(PVM pVM);
     505VMMR3_INT_DECL(int)             gimR3HvInitCompleted(PVM pVM);
     506VMMR3_INT_DECL(int)             gimR3HvTerm(PVM pVM);
     507VMMR3_INT_DECL(void)            gimR3HvRelocate(PVM pVM, RTGCINTPTR offDelta);
     508VMMR3_INT_DECL(void)            gimR3HvReset(PVM pVM);
     509VMMR3_INT_DECL(PGIMMMIO2REGION) gimR3HvGetMmio2Regions(PVM pVM, uint32_t *pcRegions);
     510VMMR3_INT_DECL(int)             gimR3HvSave(PVM pVM, PSSMHANDLE pSSM);
     511VMMR3_INT_DECL(int)             gimR3HvLoad(PVM pVM, PSSMHANDLE pSSM, uint32_t uSSMVersion);
     512
     513VMMR3_INT_DECL(int)             gimR3HvDisableTscPage(PVM pVM);
     514VMMR3_INT_DECL(int)             gimR3HvEnableTscPage(PVM pVM, RTGCPHYS GCPhysTscPage, bool fUseThisTscSeq, uint32_t uTscSeq);
     515VMMR3_INT_DECL(int)             gimR3HvDisableHypercallPage(PVM pVM);
     516VMMR3_INT_DECL(int)             gimR3HvEnableHypercallPage(PVM pVM, RTGCPHYS GCPhysHypercallPage);
    519517#endif /* IN_RING3 */
    520518
    521 VMM_INT_DECL(bool)              GIMHvIsParavirtTscEnabled(PVM pVM);
    522 VMM_INT_DECL(bool)              GIMHvAreHypercallsEnabled(PVMCPU pVCpu);
    523 VMM_INT_DECL(int)               GIMHvHypercall(PVMCPU pVCpu, PCPUMCTX pCtx);
    524 VMM_INT_DECL(VBOXSTRICTRC)      GIMHvReadMsr(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue);
    525 VMM_INT_DECL(VBOXSTRICTRC)      GIMHvWriteMsr(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uRawValue);
     519VMM_INT_DECL(bool)              gimHvIsParavirtTscEnabled(PVM pVM);
     520VMM_INT_DECL(bool)              gimHvAreHypercallsEnabled(PVMCPU pVCpu);
     521VMM_INT_DECL(int)               gimHvHypercall(PVMCPU pVCpu, PCPUMCTX pCtx);
     522VMM_INT_DECL(VBOXSTRICTRC)      gimHvReadMsr(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t *puValue);
     523VMM_INT_DECL(VBOXSTRICTRC)      gimHvWriteMsr(PVMCPU pVCpu, uint32_t idMsr, PCCPUMMSRRANGE pRange, uint64_t uRawValue);
    526524
    527525RT_C_DECLS_END

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

    r52765 r54654  
    55
    66/*
    7  * Copyright (C) 2014 Oracle Corporation
     7 * Copyright (C) 2014-2015 Oracle Corporation
    88 *
    99 * This file is part of VirtualBox Open Source Edition (OSE), as
    … …  
    2525
    2626#ifdef IN_RING3
    27 VMMR3_INT_DECL(int)         GIMR3MinimalInit(PVM pVM);
    28 VMMR3_INT_DECL(int)         GIMR3MinimalInitCompleted(PVM pVM);
    29 VMMR3_INT_DECL(void)        GIMR3MinimalRelocate(PVM pVM, RTGCINTPTR offDelta);
     27VMMR3_INT_DECL(int)         gimR3MinimalInit(PVM pVM);
     28VMMR3_INT_DECL(int)         gimR3MinimalInitCompleted(PVM pVM);
     29VMMR3_INT_DECL(void)        gimR3MinimalRelocate(PVM pVM, RTGCINTPTR offDelta);
    3030#endif /* IN_RING3 */
    3131
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