VirtualBox

儲存庫 vbox 的更動 91920


忽略:
時間撮記:
2021-10-21 上午06:45:26 (3 年 以前)
作者:
vboxsync
svn:sync-xref-src-repo-rev:
147725
訊息:

VMM,Devices: Eliminate direct calls to VMMR3 and VMR3 APIs and introduce callbacks in the device helper callback table, bugref:10074

位置:
trunk
檔案:
修改 10 筆資料

圖例:

未更動
新增
刪除

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

    r91909 r91920  
    24242424
    24252425/** Current PDMDEVHLPR3 version number. */
    2426 #define PDM_DEVHLPR3_VERSION                    PDM_VERSION_MAKE_PP(0xffe7, 52, 0)
     2426#define PDM_DEVHLPR3_VERSION                    PDM_VERSION_MAKE_PP(0xffe7, 53, 0)
    24272427
    24282428/**
    … …  
    31293129
    31303130    /**
     3131     * Checks if a GC physical address is a normal page,
     3132     * i.e. not ROM, MMIO or reserved.
     3133     *
     3134     * @returns true if normal.
     3135     * @returns false if invalid, ROM, MMIO or reserved page.
     3136     * @param   pDevIns             The device instance.
     3137     * @param   GCPhys              The physical address to check.
     3138     */
     3139    DECLR3CALLBACKMEMBER(bool, pfnPhysIsGCPhysNormal,(PPDMDEVINS pDevIns, RTGCPHYS GCPhys));
     3140
     3141    /**
    31313142     * Allocate memory which is associated with current VM instance
    31323143     * and automatically freed on it's destruction.
    … …  
    32343245    DECLR3CALLBACKMEMBER(int, pfnVMSetRuntimeErrorV,(PPDMDEVINS pDevIns, uint32_t fFlags, const char *pszErrorId,
    32353246                                                     const char *pszFormat, va_list va) RT_IPRT_FORMAT_ATTR(4, 0));
     3247
     3248    /**
     3249     * Special interface for implementing a HLT-like port on a device.
     3250     *
     3251     * This can be called directly from device code, provide the device is trusted
     3252     * to access the VMM directly.  Since we may not have an accurate register set
     3253     * and the caller certainly shouldn't (device code does not access CPU
     3254     * registers), this function will return when interrupts are pending regardless
     3255     * of the actual EFLAGS.IF state.
     3256     *
     3257     * @returns VBox error status (never informational statuses).
     3258     * @param   pDevIns             The device instance.
     3259     * @param   idCpu               The id of the calling EMT.
     3260     */
     3261    DECLR3CALLBACKMEMBER(int, pfnVMWaitForDeviceReady,(PPDMDEVINS pDevIns, VMCPUID idCpu));
     3262
     3263    /**
     3264     * Wakes up a CPU that has called PDMDEVHLPR3::pfnVMWaitForDeviceReady.
     3265     *
     3266     * @returns VBox error status (never informational statuses).
     3267     * @param   pDevIns             The device instance.
     3268     * @param   idCpu               The id of the calling EMT.
     3269     */
     3270    DECLR3CALLBACKMEMBER(int, pfnVMNotifyCpuDeviceReady,(PPDMDEVINS pDevIns, VMCPUID idCpu));
     3271
     3272    /**
     3273     * Convenience wrapper for VMR3ReqCallU.
     3274     *
     3275     * This assumes (1) you're calling a function that returns an VBox status code
     3276     * and that you do not wish to wait for it to complete.
     3277     *
     3278     * @returns VBox status code returned by VMR3ReqCallVU.
     3279     *
     3280     * @param   pDevIns             The device instance.
     3281     * @param   idDstCpu            The destination CPU(s). Either a specific CPU ID or
     3282     *                              one of the following special values:
     3283     *                                  VMCPUID_ANY, VMCPUID_ANY_QUEUE, VMCPUID_ALL or VMCPUID_ALL_REVERSE.
     3284     * @param   pfnFunction         Pointer to the function to call.
     3285     * @param   cArgs               Number of arguments following in the ellipsis.
     3286     * @param   Args                Argument vector.
     3287     *
     3288     * @remarks See remarks on VMR3ReqCallVU.
     3289     */
     3290    DECLR3CALLBACKMEMBER(int, pfnVMReqCallNoWaitV,(PPDMDEVINS pDevIns, VMCPUID idDstCpu, PFNRT pfnFunction, unsigned cArgs, va_list Args));
     3291
     3292    /**
     3293     * Convenience wrapper for VMR3ReqCallU.
     3294     *
     3295     * This assumes (1) you're calling a function that returns void, (2) that you
     3296     * wish to wait for ever for it to return, and (3) that it's priority request
     3297     * that can be safely be handled during async suspend and power off.
     3298     *
     3299     * @returns VBox status code of VMR3ReqCallVU.
     3300     *
     3301     * @param   pDevIns             The device instance.
     3302     * @param   idDstCpu            The destination CPU(s). Either a specific CPU ID or
     3303     *                              one of the following special values:
     3304     *                                  VMCPUID_ANY, VMCPUID_ANY_QUEUE, VMCPUID_ALL or VMCPUID_ALL_REVERSE.
     3305     * @param   pfnFunction         Pointer to the function to call.
     3306     * @param   cArgs               Number of arguments following in the ellipsis.
     3307     * @param   Args                Argument vector.
     3308     *
     3309     * @remarks See remarks on VMR3ReqCallVU.
     3310     */
     3311    DECLR3CALLBACKMEMBER(int, pfnVMReqPriorityCallWaitV,(PPDMDEVINS pDevIns, VMCPUID idDstCpu, PFNRT pfnFunction, unsigned cArgs, va_list Args));
    32363312
    32373313    /**
    … …  
    45714647                                                                  const char *pszHandlerRC, const char *pszPfHandlerRC,
    45724648                                                                  const char *pszDesc, PPGMPHYSHANDLERTYPE phType));
     4649
     4650    /**
     4651     * Registers the guest memory range that can be used for patching.
     4652     *
     4653     * @returns VBox status code.
     4654     * @param   pDevIns             The device instance.
     4655     * @param   GCPtrPatchMem       Patch memory range.
     4656     * @param   cbPatchMem          Size of the memory range.
     4657     */
     4658    DECLR3CALLBACKMEMBER(int, pfnVMMRegisterPatchMemory, (PPDMDEVINS pDevIns, RTGCPTR GCPtrPatchMem, uint32_t cbPatchMem));
     4659
     4660    /**
     4661     * Deregisters the guest memory range that can be used for patching.
     4662     *
     4663     * @returns VBox status code.
     4664     * @param   pDevIns             The device instance.
     4665     * @param   GCPtrPatchMem       Patch memory range.
     4666     * @param   cbPatchMem          Size of the memory range.
     4667     */
     4668    DECLR3CALLBACKMEMBER(int, pfnVMMDeregisterPatchMemory, (PPDMDEVINS pDevIns, RTGCPTR GCPtrPatchMem, uint32_t cbPatchMem));
    45734669
    45744670    /** @} */
    … …  
    66586754
    66596755/**
     6756 * @copydoc PDMDEVHLPR3::pfnPhysIsGCPhysNormal
     6757 */
     6758DECLINLINE(bool) PDMDevHlpPhysIsGCPhysNormal(PPDMDEVINS pDevIns, RTGCPHYS GCPhys)
     6759{
     6760    return pDevIns->CTX_SUFF(pHlp)->pfnPhysIsGCPhysNormal(pDevIns, GCPhys);
     6761}
     6762
     6763/**
    66606764 * @copydoc PDMDEVHLPR3::pfnCpuGetGuestMicroarch
    66616765 */
    … …  
    68236927    rc = pDevIns->CTX_SUFF(pHlp)->pfnVMSetRuntimeErrorV(pDevIns, fFlags, pszErrorId, pszFormat, va);
    68246928    va_end(va);
     6929    return rc;
     6930}
     6931
     6932/**
     6933 * @copydoc PDMDEVHLPR3::pfnVMWaitForDeviceReady
     6934 */
     6935DECLINLINE(int) PDMDevHlpVMWaitForDeviceReady(PPDMDEVINS pDevIns, VMCPUID idCpu)
     6936{
     6937    return pDevIns->CTX_SUFF(pHlp)->pfnVMWaitForDeviceReady(pDevIns, idCpu);
     6938}
     6939
     6940/**
     6941 * @copydoc PDMDEVHLPR3::pfnVMNotifyCpuDeviceReady
     6942 */
     6943DECLINLINE(int) PDMDevHlpVMNotifyCpuDeviceReady(PPDMDEVINS pDevIns, VMCPUID idCpu)
     6944{
     6945    return pDevIns->CTX_SUFF(pHlp)->pfnVMNotifyCpuDeviceReady(pDevIns, idCpu);
     6946}
     6947
     6948/**
     6949 * Convenience wrapper for VMR3ReqCallU.
     6950 *
     6951 * This assumes (1) you're calling a function that returns an VBox status code
     6952 * and that you do not wish to wait for it to complete.
     6953 *
     6954 * @returns VBox status code returned by VMR3ReqCallVU.
     6955 *
     6956 * @param   pDevIns             The device instance.
     6957 * @param   idDstCpu            The destination CPU(s). Either a specific CPU ID or
     6958 *                              one of the following special values:
     6959 *                                  VMCPUID_ANY, VMCPUID_ANY_QUEUE, VMCPUID_ALL or VMCPUID_ALL_REVERSE.
     6960 * @param   pfnFunction         Pointer to the function to call.
     6961 * @param   cArgs               Number of arguments following in the ellipsis.
     6962 * @param   ...                 Argument list.
     6963 *
     6964 * @remarks See remarks on VMR3ReqCallVU.
     6965 */
     6966DECLINLINE(int) PDMDevHlpVMReqCallNoWait(PPDMDEVINS pDevIns, VMCPUID idDstCpu, PFNRT pfnFunction, unsigned cArgs, ...)
     6967{
     6968    va_list Args;
     6969    va_start(Args, cArgs);
     6970    int rc = pDevIns->CTX_SUFF(pHlp)->pfnVMReqCallNoWaitV(pDevIns, idDstCpu, pfnFunction, cArgs, Args);
     6971    va_end(Args);
     6972    return rc;
     6973}
     6974
     6975/**
     6976 * Convenience wrapper for VMR3ReqCallU.
     6977 *
     6978 * This assumes (1) you're calling a function that returns void, (2) that you
     6979 * wish to wait for ever for it to return, and (3) that it's priority request
     6980 * that can be safely be handled during async suspend and power off.
     6981 *
     6982 * @returns VBox status code of VMR3ReqCallVU.
     6983 *
     6984 * @param   pDevIns             The device instance.
     6985 * @param   idDstCpu            The destination CPU(s). Either a specific CPU ID or
     6986 *                              one of the following special values:
     6987 *                                  VMCPUID_ANY, VMCPUID_ANY_QUEUE, VMCPUID_ALL or VMCPUID_ALL_REVERSE.
     6988 * @param   pfnFunction         Pointer to the function to call.
     6989 * @param   cArgs               Number of arguments following in the ellipsis.
     6990 * @param   ...                 Argument list.
     6991 *
     6992 * @remarks See remarks on VMR3ReqCallVU.
     6993 */
     6994DECLINLINE(int) PDMDevHlpVMReqPriorityCallWait(PPDMDEVINS pDevIns, VMCPUID idDstCpu, PFNRT pfnFunction, unsigned cArgs, ...)
     6995{
     6996    va_list Args;
     6997    va_start(Args, cArgs);
     6998    int rc = pDevIns->CTX_SUFF(pHlp)->pfnVMReqPriorityCallWaitV(pDevIns, idDstCpu, pfnFunction, cArgs, Args);
     6999    va_end(Args);
    68257000    return rc;
    68267001}
    … …  
    86608835}
    86618836
     8837/**
     8838 * @copydoc PDMDEVHLPR3::pfnVMMRegisterPatchMemory
     8839 */
     8840DECLINLINE(int) PDMDevHlpVMMRegisterPatchMemory(PPDMDEVINS pDevIns, RTGCPTR GCPtrPatchMem, uint32_t cbPatchMem)
     8841{
     8842    return pDevIns->pHlpR3->pfnVMMRegisterPatchMemory(pDevIns, GCPtrPatchMem, cbPatchMem);
     8843}
     8844
     8845/**
     8846 * @copydoc PDMDEVHLPR3::pfnVMMDeregisterPatchMemory
     8847 */
     8848DECLINLINE(int) PDMDevHlpVMMDeregisterPatchMemory(PPDMDEVINS pDevIns, RTGCPTR GCPtrPatchMem, uint32_t cbPatchMem)
     8849{
     8850    return pDevIns->pHlpR3->pfnVMMDeregisterPatchMemory(pDevIns, GCPtrPatchMem, cbPatchMem);
     8851}
     8852
    86628853/** Wrapper around SSMR3GetU32 for simplifying getting enum values saved as uint32_t. */
    86638854# define PDMDEVHLP_SSM_GET_ENUM32_RET(a_pHlp, a_pSSM, a_enmDst, a_EnumType) \

  • trunk/src/VBox/Devices/Graphics/DevVGA-SVGA.cpp

    r91901 r91920  
    12571257                PVMSVGAR3STATE pSVGAState = pThisCC->svga.pSvgaR3State;
    12581258                STAM_REL_PROFILE_START(&pSVGAState->StatBusyDelayEmts, EmtDelay);
    1259                 PVM         pVM   = PDMDevHlpGetVM(pDevIns);
    12601259                VMCPUID     idCpu = PDMDevHlpGetCurrentCpuId(pDevIns);
    12611260                VMCPUSET_ATOMIC_ADD(&pSVGAState->BusyDelayedEmts, idCpu);
    … …  
    12641263                {
    12651264                    PDMDevHlpCritSectLeave(pDevIns, &pThis->CritSect); /* hack around lock order issue. */
    1266                     rc = VMR3WaitForDeviceReady(pVM, idCpu);
     1265                    rc = PDMDevHlpVMWaitForDeviceReady(pDevIns, idCpu);
    12671266                    int const rcLock = PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSect, VERR_IGNORED);
    12681267                    PDM_CRITSECT_RELEASE_ASSERT_RC_DEV(pDevIns, &pThis->CritSect, rcLock);
    … …  
    41114110    {
    41124111# ifdef VMSVGA_USE_EMT_HALT_CODE
    4113         PVM pVM = PDMDevHlpGetVM(pDevIns);
    41144112        VMCPUID idCpu = VMCpuSetFindLastPresentInternal(&pSVGAState->BusyDelayedEmts);
    41154113        if (idCpu != NIL_VMCPUID)
    41164114        {
    4117             VMR3NotifyCpuDeviceReady(pVM, idCpu);
     4115            PDMDevHlpVMNotifyCpuDeviceReady(pDevIns, idCpu);
    41184116            while (idCpu-- > 0)
    41194117                if (VMCPUSET_IS_PRESENT(&pSVGAState->BusyDelayedEmts, idCpu))
    4120                     VMR3NotifyCpuDeviceReady(pVM, idCpu);
     4118                    PDMDevHlpVMNotifyCpuDeviceReady(pDevIns, idCpu);
    41214119        }
    41224120# else

  • trunk/src/VBox/Devices/PC/DevPcArch.cpp

    r91897 r91920  
    225225static DECLCALLBACK(int) pcarchInitComplete(PPDMDEVINS pDevIns)
    226226{
    227     PVM             pVM       = PDMDevHlpGetVM(pDevIns);
    228227    int             iRegion   = 0;
    229228    RTGCPHYS const  GCPhysEnd = 0x100000;
    … …  
    231230    do
    232231    {
    233         if (!PGMPhysIsGCPhysNormal(pVM, GCPhysCur))
     232        if (!PDMDevHlpPhysIsGCPhysNormal(pDevIns, GCPhysCur))
    234233            GCPhysCur += X86_PAGE_SIZE;
    235234        else
    … …  
    238237            do
    239238                GCPhysCur += X86_PAGE_SIZE;
    240             while (GCPhysCur < GCPhysEnd && PGMPhysIsGCPhysNormal(pVM, GCPhysCur));
     239            while (GCPhysCur < GCPhysEnd && PDMDevHlpPhysIsGCPhysNormal(pDevIns, GCPhysCur));
    241240
    242241            IOMMMIOHANDLE hMmioRegion;

  • trunk/src/VBox/Devices/Storage/DevAHCI.cpp

    r90791 r91920  
    39523952    if (pThisCC->pMediaNotify)
    39533953    {
    3954         int rc = VMR3ReqCallNoWait(PDMDevHlpGetVM(pDevIns), VMCPUID_ANY,
    3955                                    (PFNRT)pThisCC->pMediaNotify->pfnEjected, 2,
    3956                                    pThisCC->pMediaNotify, pAhciPort->iLUN);
     3954        int rc = PDMDevHlpVMReqCallNoWait(pDevIns, VMCPUID_ANY,
     3955                                          (PFNRT)pThisCC->pMediaNotify->pfnEjected, 2,
     3956                                          pThisCC->pMediaNotify, pAhciPort->iLUN);
    39573957        AssertRC(rc);
    39583958    }

  • trunk/src/VBox/Devices/Storage/DevATA.cpp

    r90500 r91920  
    37893789
    37903790                    ataR3LockLeave(pDevIns, pCtl);
    3791                     rc = VMR3ReqPriorityCallWait(PDMDevHlpGetVM(pDevIns), VMCPUID_ANY,
    3792                                                  (PFNRT)pDevR3->pDrvMount->pfnUnmount, 3,
    3793                                                  pDevR3->pDrvMount, false /*=fForce*/, true /*=fEject*/);
     3791                    rc = PDMDevHlpVMReqPriorityCallWait(pDevIns, VMCPUID_ANY,
     3792                                                        (PFNRT)pDevR3->pDrvMount->pfnUnmount, 3,
     3793                                                        pDevR3->pDrvMount, false /*=fForce*/, true /*=fEject*/);
    37943794                    Assert(RT_SUCCESS(rc) || rc == VERR_PDM_MEDIA_LOCKED || rc == VERR_PDM_MEDIA_NOT_MOUNTED);
    37953795                    if (RT_SUCCESS(rc) && pThisCC->pMediaNotify)
    37963796                    {
    3797                         rc = VMR3ReqCallNoWait(PDMDevHlpGetVM(pDevIns), VMCPUID_ANY,
    3798                                                (PFNRT)pThisCC->pMediaNotify->pfnEjected, 2,
    3799                                                pThisCC->pMediaNotify, s->iLUN);
     3797                        rc = PDMDevHlpVMReqCallNoWait(pDevIns, VMCPUID_ANY,
     3798                                                      (PFNRT)pThisCC->pMediaNotify->pfnEjected, 2,
     3799                                                      pThisCC->pMediaNotify, s->iLUN);
    38003800                        AssertRC(rc);
    38013801                    }

  • trunk/src/VBox/Devices/Storage/DevBusLogic.cpp

    r90791 r91920  
    31493149    if (pThisCC->pMediaNotify)
    31503150    {
    3151         int rc = VMR3ReqCallNoWait(PDMDevHlpGetVM(pDevIns), VMCPUID_ANY,
    3152                                    (PFNRT)pThisCC->pMediaNotify->pfnEjected, 2,
    3153                                    pThisCC->pMediaNotify, pTgtDev->iLUN);
     3151        int rc = PDMDevHlpVMReqCallNoWait(pDevIns, VMCPUID_ANY,
     3152                                          (PFNRT)pThisCC->pMediaNotify->pfnEjected, 2,
     3153                                          pThisCC->pMediaNotify, pTgtDev->iLUN);
    31543154        AssertRC(rc);
    31553155    }

  • trunk/src/VBox/Devices/Storage/DevLsiLogicSCSI.cpp

    r90791 r91920  
    25122512    if (pThisCC->pMediaNotify)
    25132513    {
    2514         int rc = VMR3ReqCallNoWait(PDMDevHlpGetVM(pDevIns), VMCPUID_ANY,
    2515                                    (PFNRT)pThisCC->pMediaNotify->pfnEjected, 2,
    2516                                    pThisCC->pMediaNotify, pTgtDev->iLUN);
     2514        int rc = PDMDevHlpVMReqCallNoWait(pDevIns, VMCPUID_ANY,
     2515                                          (PFNRT)pThisCC->pMediaNotify->pfnEjected, 2,
     2516                                          pThisCC->pMediaNotify, pTgtDev->iLUN);
    25172517        AssertRC(rc);
    25182518    }

  • trunk/src/VBox/Devices/Storage/DevVirtioSCSI.cpp

    r91703 r91920  
    23212321    if (pThisCC->pMediaNotify)
    23222322    {
    2323         int rc = VMR3ReqCallNoWait(PDMDevHlpGetVM(pDevIns), VMCPUID_ANY,
    2324                                    (PFNRT)pThisCC->pMediaNotify->pfnEjected, 2,
    2325                                    pThisCC->pMediaNotify, pTarget->uTarget);
     2323        int rc = PDMDevHlpVMReqCallNoWait(pDevIns, VMCPUID_ANY,
     2324                                          (PFNRT)pThisCC->pMediaNotify->pfnEjected, 2,
     2325                                          pThisCC->pMediaNotify, pTarget->uTarget);
    23262326        AssertRC(rc);
    23272327    }

  • trunk/src/VBox/Devices/VMMDev/VMMDev.cpp

    r91897 r91920  
    12751275    AssertMsgReturn(pReq->header.size == sizeof(*pReq), ("%u\n", pReq->header.size), VERR_INVALID_PARAMETER);
    12761276
    1277     return VMMR3RegisterPatchMemory(PDMDevHlpGetVM(pDevIns), pReq->pPatchMem, pReq->cbPatchMem);
     1277    return PDMDevHlpVMMRegisterPatchMemory(pDevIns, pReq->pPatchMem, pReq->cbPatchMem);
    12781278}
    12791279
    … …  
    12911291    AssertMsgReturn(pReq->header.size == sizeof(*pReq), ("%u\n", pReq->header.size), VERR_INVALID_PARAMETER);
    12921292
    1293     return VMMR3DeregisterPatchMemory(PDMDevHlpGetVM(pDevIns), pReq->pPatchMem, pReq->cbPatchMem);
     1293    return PDMDevHlpVMMDeregisterPatchMemory(pDevIns, pReq->pPatchMem, pReq->cbPatchMem);
    12941294}
    12951295

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

    r91909 r91920  
    963963
    964964
     965/** @interface_method_impl{PDMDEVHLPR3,pfnPhysIsGCPhysNormal} */
     966static DECLCALLBACK(bool) pdmR3DevHlp_PhysIsGCPhysNormal(PPDMDEVINS pDevIns, RTGCPHYS GCPhys)
     967{
     968    PDMDEV_ASSERT_DEVINS(pDevIns);
     969    LogFlow(("pdmR3DevHlp_PhysIsGCPhysNormal: caller='%s'/%d: GCPhys=%RGp\n",
     970             pDevIns->pReg->szName, pDevIns->iInstance, GCPhys));
     971
     972    bool fNormal = PGMPhysIsGCPhysNormal(pDevIns->Internal.s.pVMR3, GCPhys);
     973
     974    Log(("pdmR3DevHlp_PhysIsGCPhysNormal: caller='%s'/%d: returns %RTbool\n", pDevIns->pReg->szName, pDevIns->iInstance, fNormal));
     975    return fNormal;
     976}
     977
     978
    965979/** @interface_method_impl{PDMDEVHLPR3,pfnCpuGetGuestMicroarch} */
    966980static DECLCALLBACK(CPUMMICROARCH) pdmR3DevHlp_CpuGetGuestMicroarch(PPDMDEVINS pDevIns)
    … …  
    12011215    PDMDEV_ASSERT_DEVINS(pDevIns);
    12021216    int rc = VMSetRuntimeErrorV(pDevIns->Internal.s.pVMR3, fFlags, pszErrorId, pszFormat, va);
     1217    return rc;
     1218}
     1219
     1220
     1221/** @interface_method_impl{PDMDEVHLPR3,pfnVMWaitForDeviceReady} */
     1222static DECLCALLBACK(int) pdmR3DevHlp_VMWaitForDeviceReady(PPDMDEVINS pDevIns, VMCPUID idCpu)
     1223{
     1224    PDMDEV_ASSERT_DEVINS(pDevIns);
     1225    LogFlow(("pdmR3DevHlp_VMWaitForDeviceReady: caller='%s'/%d: idCpu=%u\n", pDevIns->pReg->szName, pDevIns->iInstance, idCpu));
     1226
     1227    int rc = VMR3WaitForDeviceReady(pDevIns->Internal.s.pVMR3, idCpu);
     1228
     1229    LogFlow(("pdmR3DevHlp_VMWaitForDeviceReady: caller='%s'/%d: returns %Rrc\n",
     1230             pDevIns->pReg->szName, pDevIns->iInstance, rc));
     1231    return rc;
     1232}
     1233
     1234
     1235/** @interface_method_impl{PDMDEVHLPR3,pfnVMNotifyCpuDeviceReady} */
     1236static DECLCALLBACK(int) pdmR3DevHlp_VMNotifyCpuDeviceReady(PPDMDEVINS pDevIns, VMCPUID idCpu)
     1237{
     1238    PDMDEV_ASSERT_DEVINS(pDevIns);
     1239    LogFlow(("pdmR3DevHlp_VMNotifyCpuDeviceReady: caller='%s'/%d: idCpu=%u\n", pDevIns->pReg->szName, pDevIns->iInstance, idCpu));
     1240
     1241    int rc = VMR3NotifyCpuDeviceReady(pDevIns->Internal.s.pVMR3, idCpu);
     1242
     1243    LogFlow(("pdmR3DevHlp_VMNotifyCpuDeviceReady: caller='%s'/%d: returns %Rrc\n",
     1244             pDevIns->pReg->szName, pDevIns->iInstance, rc));
     1245    return rc;
     1246}
     1247
     1248
     1249/** @interface_method_impl{PDMDEVHLPR3,pfnVMReqCallNoWaitV} */
     1250static DECLCALLBACK(int) pdmR3DevHlp_VMReqCallNoWaitV(PPDMDEVINS pDevIns, VMCPUID idDstCpu, PFNRT pfnFunction, unsigned cArgs, va_list Args)
     1251{
     1252    PDMDEV_ASSERT_DEVINS(pDevIns);
     1253    LogFlow(("pdmR3DevHlp_VMReqCallNoWaitV: caller='%s'/%d: idDstCpu=%u pfnFunction=%p cArgs=%u\n",
     1254             pDevIns->pReg->szName, pDevIns->iInstance, idDstCpu, pfnFunction, cArgs));
     1255
     1256    int rc = VMR3ReqCallVU(pDevIns->Internal.s.pVMR3->pUVM, idDstCpu, NULL, 0, VMREQFLAGS_VBOX_STATUS | VMREQFLAGS_NO_WAIT,
     1257                           pfnFunction, cArgs, Args);
     1258
     1259    LogFlow(("pdmR3DevHlp_VMReqCallNoWaitV: caller='%s'/%d: returns %Rrc\n",
     1260             pDevIns->pReg->szName, pDevIns->iInstance, rc));
     1261    return rc;
     1262}
     1263
     1264
     1265/** @interface_method_impl{PDMDEVHLPR3,pfnVMReqPriorityCallWaitV} */
     1266static DECLCALLBACK(int) pdmR3DevHlp_VMReqPriorityCallWaitV(PPDMDEVINS pDevIns, VMCPUID idDstCpu, PFNRT pfnFunction, unsigned cArgs, va_list Args)
     1267{
     1268    PDMDEV_ASSERT_DEVINS(pDevIns);
     1269    LogFlow(("pdmR3DevHlp_VMReqCallNoWaitV: caller='%s'/%d: idDstCpu=%u pfnFunction=%p cArgs=%u\n",
     1270             pDevIns->pReg->szName, pDevIns->iInstance, idDstCpu, pfnFunction, cArgs));
     1271
     1272    PVMREQ pReq;
     1273    int rc = VMR3ReqCallVU(pDevIns->Internal.s.pVMR3->pUVM, idDstCpu, &pReq, RT_INDEFINITE_WAIT, VMREQFLAGS_VBOX_STATUS | VMREQFLAGS_PRIORITY,
     1274                           pfnFunction, cArgs, Args);
     1275    if (RT_SUCCESS(rc))
     1276        rc = pReq->iStatus;
     1277    VMR3ReqFree(pReq);
     1278
     1279    LogFlow(("pdmR3DevHlp_VMReqCallNoWaitV: caller='%s'/%d: returns %Rrc\n",
     1280             pDevIns->pReg->szName, pDevIns->iInstance, rc));
    12031281    return rc;
    12041282}
    … …  
    42724350    LogFlow(("pdmR3DevHlp_GetCpuId: caller='%s'/%d: returns void - *pEax=%#x *pEbx=%#x *pEcx=%#x *pEdx=%#x\n",
    42734351             pDevIns->pReg->szName, pDevIns->iInstance, *pEax, *pEbx, *pEcx, *pEdx));
     4352}
     4353
     4354
     4355/** @interface_method_impl{PDMDEVHLPR3,pfnVMMRegisterPatchMemory} */
     4356static DECLCALLBACK(int) pdmR3DevHlp_VMMRegisterPatchMemory(PPDMDEVINS pDevIns, RTGCPTR GCPtrPatchMem, uint32_t cbPatchMem)
     4357{
     4358    PDMDEV_ASSERT_DEVINS(pDevIns); RT_NOREF(pDevIns);
     4359
     4360    LogFlow(("pdmR3DevHlp_VMMRegisterPatchMemory: caller='%s'/%d: GCPtrPatchMem=%RGv cbPatchMem=%RU32\n",
     4361             pDevIns->pReg->szName, pDevIns->iInstance, GCPtrPatchMem, cbPatchMem));
     4362
     4363    int rc = VMMR3RegisterPatchMemory(pDevIns->Internal.s.pVMR3, GCPtrPatchMem, cbPatchMem);
     4364
     4365    LogFlow(("pdmR3DevHlp_VMMRegisterPatchMemory: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
     4366    return rc;
     4367}
     4368
     4369
     4370/** @interface_method_impl{PDMDEVHLPR3,pfnVMMDeregisterPatchMemory} */
     4371static DECLCALLBACK(int) pdmR3DevHlp_VMMDeregisterPatchMemory(PPDMDEVINS pDevIns, RTGCPTR GCPtrPatchMem, uint32_t cbPatchMem)
     4372{
     4373    PDMDEV_ASSERT_DEVINS(pDevIns); RT_NOREF(pDevIns);
     4374
     4375    LogFlow(("pdmR3DevHlp_VMMDeregisterPatchMemory: caller='%s'/%d: GCPtrPatchMem=%RGv cbPatchMem=%RU32\n",
     4376             pDevIns->pReg->szName, pDevIns->iInstance, GCPtrPatchMem, cbPatchMem));
     4377
     4378    int rc = VMMR3DeregisterPatchMemory(pDevIns->Internal.s.pVMR3, GCPtrPatchMem, cbPatchMem);
     4379
     4380    LogFlow(("pdmR3DevHlp_VMMDeregisterPatchMemory: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
     4381    return rc;
    42744382}
    42754383
    … …  
    44754583    pdmR3DevHlp_PhysWriteGCVirt,
    44764584    pdmR3DevHlp_PhysGCPtr2GCPhys,
     4585    pdmR3DevHlp_PhysIsGCPhysNormal,
    44774586    pdmR3DevHlp_MMHeapAlloc,
    44784587    pdmR3DevHlp_MMHeapAllocZ,
    … …  
    44864595    pdmR3DevHlp_VMSetErrorV,
    44874596    pdmR3DevHlp_VMSetRuntimeErrorV,
     4597    pdmR3DevHlp_VMWaitForDeviceReady,
     4598    pdmR3DevHlp_VMNotifyCpuDeviceReady,
     4599    pdmR3DevHlp_VMReqCallNoWaitV,
     4600    pdmR3DevHlp_VMReqPriorityCallWaitV,
    44884601    pdmR3DevHlp_DBGFStopV,
    44894602    pdmR3DevHlp_DBGFInfoRegister,
    … …  
    46334746    pdmR3DevHlp_QueryGenericUserObject,
    46344747    pdmR3DevHlp_PGMHandlerPhysicalTypeRegister,
     4748    pdmR3DevHlp_VMMRegisterPatchMemory,
     4749    pdmR3DevHlp_VMMDeregisterPatchMemory,
    46354750    PDM_DEVHLPR3_VERSION /* the end */
    46364751};
    … …  
    48384953    pdmR3DevHlp_PhysWriteGCVirt,
    48394954    pdmR3DevHlp_PhysGCPtr2GCPhys,
     4955    pdmR3DevHlp_PhysIsGCPhysNormal,
    48404956    pdmR3DevHlp_MMHeapAlloc,
    48414957    pdmR3DevHlp_MMHeapAllocZ,
    … …  
    48494965    pdmR3DevHlp_VMSetErrorV,
    48504966    pdmR3DevHlp_VMSetRuntimeErrorV,
     4967    pdmR3DevHlp_VMWaitForDeviceReady,
     4968    pdmR3DevHlp_VMNotifyCpuDeviceReady,
     4969    pdmR3DevHlp_VMReqCallNoWaitV,
     4970    pdmR3DevHlp_VMReqPriorityCallWaitV,
    48514971    pdmR3DevHlp_DBGFStopV,
    48524972    pdmR3DevHlp_DBGFInfoRegister,
    … …  
    49965116    pdmR3DevHlp_QueryGenericUserObject,
    49975117    pdmR3DevHlp_PGMHandlerPhysicalTypeRegister,
     5118    pdmR3DevHlp_VMMRegisterPatchMemory,
     5119    pdmR3DevHlp_VMMDeregisterPatchMemory,
    49985120    PDM_DEVHLPR3_VERSION /* the end */
    49995121};
    … …  
    51525274    PDMDEV_ASSERT_DEVINS(pDevIns);
    51535275    RT_NOREF(enmKind, pfnHandlerR3, pszHandlerR0, pszPfHandlerR0, pszHandlerRC, pszPfHandlerRC, pszDesc, phType);
     5276    AssertReleaseMsgFailed(("Untrusted device called trusted helper! '%s'/%d\n",
     5277                            pDevIns->pReg->szName, pDevIns->iInstance));
     5278    return VERR_ACCESS_DENIED;
     5279}
     5280
     5281
     5282/** @interface_method_impl{PDMDEVHLPR3,pfnVMMRegisterPatchMemory} */
     5283static DECLCALLBACK(int) pdmR3DevHlp_Untrusted_VMMRegisterPatchMemory(PPDMDEVINS pDevIns, RTGCPTR GCPtrPatchMem, uint32_t cbPatchMem)
     5284{
     5285    PDMDEV_ASSERT_DEVINS(pDevIns);
     5286    RT_NOREF(GCPtrPatchMem, cbPatchMem);
     5287    AssertReleaseMsgFailed(("Untrusted device called trusted helper! '%s'/%d\n",
     5288                            pDevIns->pReg->szName, pDevIns->iInstance));
     5289    return VERR_ACCESS_DENIED;
     5290}
     5291
     5292
     5293/** @interface_method_impl{PDMDEVHLPR3,pfnVMMDeregisterPatchMemory} */
     5294static DECLCALLBACK(int) pdmR3DevHlp_Untrusted_VMMDeregisterPatchMemory(PPDMDEVINS pDevIns, RTGCPTR GCPtrPatchMem, uint32_t cbPatchMem)
     5295{
     5296    PDMDEV_ASSERT_DEVINS(pDevIns);
     5297    RT_NOREF(GCPtrPatchMem, cbPatchMem);
    51545298    AssertReleaseMsgFailed(("Untrusted device called trusted helper! '%s'/%d\n",
    51555299                            pDevIns->pReg->szName, pDevIns->iInstance));
    … …  
    53585502    pdmR3DevHlp_PhysWriteGCVirt,
    53595503    pdmR3DevHlp_PhysGCPtr2GCPhys,
     5504    pdmR3DevHlp_PhysIsGCPhysNormal,
    53605505    pdmR3DevHlp_MMHeapAlloc,
    53615506    pdmR3DevHlp_MMHeapAllocZ,
    … …  
    53695514    pdmR3DevHlp_VMSetErrorV,
    53705515    pdmR3DevHlp_VMSetRuntimeErrorV,
     5516    pdmR3DevHlp_VMWaitForDeviceReady,
     5517    pdmR3DevHlp_VMNotifyCpuDeviceReady,
     5518    pdmR3DevHlp_VMReqCallNoWaitV,
     5519    pdmR3DevHlp_VMReqPriorityCallWaitV,
    53715520    pdmR3DevHlp_DBGFStopV,
    53725521    pdmR3DevHlp_DBGFInfoRegister,
    … …  
    55165665    pdmR3DevHlp_Untrusted_QueryGenericUserObject,
    55175666    pdmR3DevHlp_Untrusted_PGMHandlerPhysicalTypeRegister,
     5667    pdmR3DevHlp_Untrusted_VMMRegisterPatchMemory,
     5668    pdmR3DevHlp_Untrusted_VMMDeregisterPatchMemory,
    55185669    PDM_DEVHLPR3_VERSION /* the end */
    55195670};
注意: 瀏覽 TracChangeset 來幫助您使用更動檢視器

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