VirtualBox

Changeset 24740 in vbox


Ignore:
Timestamp:
Nov 17, 2009 9:44:14 PM (15 years ago)
Author:
vboxsync
Message:

VMM, PDM: Need a AsyncNotificationCompleted helper so we can skip the poll mess.

Location:
trunk
Files:
8 edited

Legend:

Unmodified
Added
Removed

  • trunk/include/VBox/pdmdev.h

    r24730 r24740  
    24202420    DECLR3CALLBACKMEMBER(int, pfnSetAsyncNotification, (PPDMDEVINS pDevIns, PFNPDMDEVASYNCNOTIFY pfnAsyncNotify));
    24212421
     2422    /**
     2423     * Notify EMT(0) that the device has completed the asynchronous notification
     2424     * handling.
     2425     *
     2426     * This can be called at any time, spurious calls will simply be ignored.
     2427     *
     2428     * @param   pDevIns             The device instance.
     2429     * @thread  Any
     2430     */
     2431    DECLR3CALLBACKMEMBER(void, pfnAsyncNotificationCompleted, (PPDMDEVINS pDevIns));
     2432
    24222433    /** Space reserved for future members.
    24232434     * @{ */
    … …  
    37393750
    37403751/**
     3752 * @copydoc PDMDEVHLPR3::pfnAsyncNotificationCompleted
     3753 */
     3754DECLINLINE(void) PDMDevHlpAsyncNotificationCompleted(PPDMDEVINS pDevIns)
     3755{
     3756    pDevIns->pDevHlpR3->pfnAsyncNotificationCompleted(pDevIns);
     3757}
     3758
     3759/**
    37413760 * @copydoc PDMDEVHLPR3::pfnVMState
    37423761 */

  • trunk/include/VBox/pdmdrv.h

    r24730 r24740  
    711711
    712712    /**
     713     * Notify EMT(0) that the driver has completed the asynchronous notification
     714     * handling.
     715     *
     716     * This can be called at any time, spurious calls will simply be ignored.
     717     *
     718     * @param   pDrvIns             The driver instance.
     719     * @thread  Any
     720     */
     721    DECLR3CALLBACKMEMBER(void, pfnAsyncNotificationCompleted, (PPDMDRVINS pDrvIns));
     722
     723    /**
    713724     * Creates a PDM thread.
    714725     *
    … …  
    10391050
    10401051/**
     1052 * @copydoc PDMDRVHLP::pfnSetAsyncNotification
     1053 */
     1054DECLINLINE(int) PDMDrvHlpSetAsyncNotification(PPDMDRVINS pDrvIns, PFNPDMDRVASYNCNOTIFY pfnAsyncNotify)
     1055{
     1056    return pDrvIns->pDrvHlp->pfnSetAsyncNotification(pDrvIns, pfnAsyncNotify);
     1057}
     1058
     1059/**
     1060 * @copydoc PDMDRVHLP::pfnAsyncNotificationCompleted
     1061 */
     1062DECLINLINE(void) PDMDrvHlpAsyncNotificationCompleted(PPDMDRVINS pDrvIns)
     1063{
     1064    pDrvIns->pDrvHlp->pfnAsyncNotificationCompleted(pDrvIns);
     1065}
     1066
     1067/**
    10411068 * @copydoc PDMDRVHLP::pfnPDMThreadCreate
    10421069 */

  • trunk/include/VBox/pdmusb.h

    r24730 r24740  
    586586     */
    587587    DECLR3CALLBACKMEMBER(int, pfnSetAsyncNotification, (PPDMUSBINS pUSbIns, PFNPDMUSBASYNCNOTIFY pfnAsyncNotify));
     588
     589    /**
     590     * Notify EMT(0) that the device has completed the asynchronous notification
     591     * handling.
     592     *
     593     * This can be called at any time, spurious calls will simply be ignored.
     594     *
     595     * @param   pUSBIns             The USB device instance.
     596     * @thread  Any
     597     */
     598    DECLR3CALLBACKMEMBER(void, pfnAsyncNotificationCompleted, (PPDMUSBINS pUsbIns));
    588599
    589600    /** Just a safety precaution. */
    … …  
    728739}
    729740
     741/**
     742 * @copydoc PDMUSBHLP::pfnSetAsyncNotification
     743 */
     744DECLINLINE(int) PDMUsbHlpSetAsyncNotification(PPDMUSBINS pUsbIns, PFNPDMUSBASYNCNOTIFY pfnAsyncNotify)
     745{
     746    return pUsbIns->pUsbHlp->pfnSetAsyncNotification(pUsbIns, pfnAsyncNotify);
     747}
     748
     749/**
     750 * @copydoc PDMUSBHLP::pfnAsyncNotificationCompleted
     751 */
     752DECLINLINE(void) PDMUsbHlpAsyncNotificationCompleted(PPDMUSBINS pUsbIns)
     753{
     754    pUsbIns->pUsbHlp->pfnAsyncNotificationCompleted(pUsbIns);
     755}
     756
    730757#endif /* IN_RING3 */
    731758

  • trunk/include/VBox/vmapi.h

    r24508 r24740  
    398398/** @} */
    399399
    400 VMMR3DECL(int)  VMR3WaitHalted(PVM pVM, PVMCPU pVCpu, bool fIgnoreInterrupts);
    401 VMMR3DECL(int)  VMR3WaitU(PUVMCPU pUVMCpu);
     400VMMR3DECL(int)              VMR3WaitHalted(PVM pVM, PVMCPU pVCpu, bool fIgnoreInterrupts);
     401VMMR3DECL(int)              VMR3WaitU(PUVMCPU pUVMCpu);
     402VMMR3_INT_DECL(int)         VMR3AsyncPdmNotificationWaitU(PUVMCPU pUVCpu);
     403VMMR3_INT_DECL(void)        VMR3AsyncPdmNotificationWakeupU(PUVM pUVM);
    402404VMMR3DECL(RTCPUID)          VMR3GetVMCPUId(PVM pVM);
    403405VMMR3DECL(RTTHREAD)         VMR3GetVMCPUThread(PVM pVM);

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

    r24730 r24740  
    11351135                         pDrvIns->pDrvReg->szDriverName, pDrvIns->iInstance, iLun, pszDeviceName, iDevInstance));
    11361136                pDrvIns->pDrvReg->pfnSuspend(pDrvIns);
     1137                if (pDrvIns->Internal.s.pfnAsyncNotify)
     1138                    LogFlow(("PDMR3Suspend: Async notification started - driver '%s'/%d on LUN#%d of device '%s'/%d\n",
     1139                             pDrvIns->pDrvReg->szDriverName, pDrvIns->iInstance, iLun, pszDeviceName, iDevInstance));
    11371140            }
    11381141            else if (pDrvIns->Internal.s.pfnAsyncNotify(pDrvIns))
    … …  
    11711174                LogFlow(("PDMR3Suspend: Notifying - device '%s'/%d\n", pUsbIns->pUsbReg->szDeviceName, pUsbIns->iInstance));
    11721175                pUsbIns->pUsbReg->pfnVMSuspend(pUsbIns);
     1176                if (pUsbIns->Internal.s.pfnAsyncNotify)
     1177                    LogFlow(("PDMR3Suspend: Async notification started - device '%s'/%d\n", pUsbIns->pUsbReg->szDeviceName, pUsbIns->iInstance));
    11731178            }
    11741179            else if (pUsbIns->Internal.s.pfnAsyncNotify(pUsbIns))
    … …  
    12041209                LogFlow(("PDMR3Suspend: Notifying - device '%s'/%d\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance));
    12051210                pDevIns->pDevReg->pfnSuspend(pDevIns);
     1211                if (pDevIns->Internal.s.pfnAsyncNotify)
     1212                    LogFlow(("PDMR3Suspend: Async notification started - device '%s'/%d\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance));
    12061213            }
    12071214            else if (pDevIns->Internal.s.pfnAsyncNotify(pDevIns))
    … …  
    12411248     */
    12421249    unsigned cAsync;
    1243     for (;;)
     1250    for (unsigned iLoop = 0; ; iLoop++)
    12441251    {
    12451252        /*
    … …  
    12931300        /** @todo This is utterly nuts and completely unsafe... will get back to it in a
    12941301         *        bit I hope... */
    1295         int rc = VMR3ReqProcessU(pVM->pUVM, VMCPUID_ANY);
    1296         AssertReleaseRC(rc == VINF_SUCCESS);
     1302        int rc = VMR3AsyncPdmNotificationWaitU(&pVM->pUVM->aCpus[0]);
     1303        AssertReleaseMsg(rc == VINF_SUCCESS, ("%Rrc\n", rc));
     1304        rc = VMR3ReqProcessU(pVM->pUVM, VMCPUID_ANY);
     1305        AssertReleaseMsg(rc == VINF_SUCCESS, ("%Rrc\n", rc));
     1306        rc = VMR3ReqProcessU(pVM->pUVM, 0/*idDstCpu*/);
     1307        AssertReleaseMsg(rc == VINF_SUCCESS, ("%Rrc\n", rc));
    12971308    }
    12981309
    … …  
    14561467                         pDrvIns->pDrvReg->szDriverName, pDrvIns->iInstance, iLun, pszDeviceName, iDevInstance));
    14571468                pDrvIns->pDrvReg->pfnPowerOff(pDrvIns);
     1469                if (pDrvIns->Internal.s.pfnAsyncNotify)
     1470                    LogFlow(("PDMR3PowerOff: Async notification started - driver '%s'/%d on LUN#%d of device '%s'/%d\n",
     1471                             pDrvIns->pDrvReg->szDriverName, pDrvIns->iInstance, iLun, pszDeviceName, iDevInstance));
    14581472            }
    14591473            else if (pDrvIns->Internal.s.pfnAsyncNotify(pDrvIns))
    … …  
    14921506                LogFlow(("PDMR3PowerOff: Notifying - device '%s'/%d\n", pUsbIns->pUsbReg->szDeviceName, pUsbIns->iInstance));
    14931507                pUsbIns->pUsbReg->pfnVMPowerOff(pUsbIns);
     1508                if (pUsbIns->Internal.s.pfnAsyncNotify)
     1509                    LogFlow(("PDMR3PowerOff: Async notification started - device '%s'/%d\n", pUsbIns->pUsbReg->szDeviceName, pUsbIns->iInstance));
    14941510            }
    14951511            else if (pUsbIns->Internal.s.pfnAsyncNotify(pUsbIns))
    … …  
    15251541                LogFlow(("PDMR3PowerOff: Notifying - device '%s'/%d\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance));
    15261542                pDevIns->pDevReg->pfnPowerOff(pDevIns);
     1543                if (pDevIns->Internal.s.pfnAsyncNotify)
     1544                    LogFlow(("PDMR3PowerOff: Async notification started - device '%s'/%d\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance));
    15271545            }
    15281546            else if (pDevIns->Internal.s.pfnAsyncNotify(pDevIns))
    … …  
    16071625        /** @todo This is utterly nuts and completely unsafe... will get back to it in a
    16081626         *        bit I hope... */
    1609         int rc = VMR3ReqProcessU(pVM->pUVM, VMCPUID_ANY);
    1610         AssertReleaseRC(rc == VINF_SUCCESS);
     1627        int rc = VMR3AsyncPdmNotificationWaitU(&pVM->pUVM->aCpus[0]);
     1628        AssertReleaseMsg(rc == VINF_SUCCESS, ("%Rrc\n", rc));
     1629        rc = VMR3ReqProcessU(pVM->pUVM, VMCPUID_ANY);
     1630        AssertReleaseMsg(rc == VINF_SUCCESS, ("%Rrc\n", rc));
     1631        rc = VMR3ReqProcessU(pVM->pUVM, 0/*idDstCpu*/);
     1632        AssertReleaseMsg(rc == VINF_SUCCESS, ("%Rrc\n", rc));
    16111633    }
    16121634

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

    r24730 r24740  
    23352335    PDMDEV_ASSERT_DEVINS(pDevIns);
    23362336    VM_ASSERT_EMT0(pDevIns->Internal.s.pVMR3);
    2337     LogFlow(("pdmR3DevHlp_SetAsyncNotification: caller='%s'/%d: pfnAsyncNotify\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, pfnAsyncNotify));
     2337    LogFlow(("pdmR3DevHlp_SetAsyncNotification: caller='%s'/%d: pfnAsyncNotify=%p\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, pfnAsyncNotify));
    23382338
    23392339    int rc = VINF_SUCCESS;
    … …  
    23542354    LogFlow(("pdmR3DevHlp_SetAsyncNotification: caller='%s'/%d: returns %Rrc\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, rc));
    23552355    return rc;
     2356}
     2357
     2358
     2359/** @copydoc PDMDEVHLPR3::pfnAsyncNotificationCompleted */
     2360static DECLCALLBACK(void) pdmR3DevHlp_AsyncNotificationCompleted(PPDMDEVINS pDevIns)
     2361{
     2362    PDMDEV_ASSERT_DEVINS(pDevIns);
     2363    PVM pVM = pDevIns->Internal.s.pVMR3;
     2364
     2365    VMSTATE enmVMState = VMR3GetState(pVM);
     2366    if (   enmVMState == VMSTATE_SUSPENDING
     2367        || enmVMState == VMSTATE_SUSPENDING_EXT_LS
     2368        || enmVMState == VMSTATE_SUSPENDING_LS
     2369        || enmVMState == VMSTATE_POWERING_OFF
     2370        || enmVMState == VMSTATE_POWERING_OFF_LS)
     2371    {
     2372        LogFlow(("pdmR3DevHlp_AsyncNotificationCompleted: caller='%s'/%d:\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance));
     2373        VMR3AsyncPdmNotificationWakeupU(pVM->pUVM);
     2374    }
     2375    else
     2376        LogFlow(("pdmR3DevHlp_AsyncNotificationCompleted: caller='%s'/%d: enmVMState=%d\n", pDevIns->pDevReg->szDeviceName, pDevIns->iInstance, enmVMState));
    23562377}
    23572378
    … …  
    28662887    pdmR3DevHlp_PhysGCPtr2GCPhys,
    28672888    pdmR3DevHlp_SetAsyncNotification,
     2889    pdmR3DevHlp_AsyncNotificationCompleted,
    28682890    0,
    28692891    0,
    … …  
    33323354    pdmR3DevHlp_PhysGCPtr2GCPhys,
    33333355    pdmR3DevHlp_SetAsyncNotification,
     3356    pdmR3DevHlp_AsyncNotificationCompleted,
    33343357    0,
    33353358    0,

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

    r24730 r24740  
    10461046
    10471047
     1048/** @copydoc PDMDRVHLP::pfnAsyncNotificationCompleted */
     1049static DECLCALLBACK(void) pdmR3DrvHlp_AsyncNotificationCompleted(PPDMDRVINS pDrvIns)
     1050{
     1051    PDMDRV_ASSERT_DRVINS(pDrvIns);
     1052    PVM pVM = pDrvIns->Internal.s.pVM;
     1053
     1054    VMSTATE enmVMState = VMR3GetState(pVM);
     1055    if (   enmVMState == VMSTATE_SUSPENDING
     1056        || enmVMState == VMSTATE_SUSPENDING_EXT_LS
     1057        || enmVMState == VMSTATE_SUSPENDING_LS
     1058        || enmVMState == VMSTATE_POWERING_OFF
     1059        || enmVMState == VMSTATE_POWERING_OFF_LS)
     1060    {
     1061        LogFlow(("pdmR3DrvHlp_AsyncNotificationCompleted: caller='%s'/%d:\n", pDrvIns->pDrvReg->szDriverName, pDrvIns->iInstance));
     1062        VMR3AsyncPdmNotificationWakeupU(pVM->pUVM);
     1063    }
     1064    else
     1065        LogFlow(("pdmR3DrvHlp_AsyncNotificationCompleted: caller='%s'/%d: enmVMState=%d\n", pDrvIns->pDrvReg->szDriverName, pDrvIns->iInstance, enmVMState));
     1066}
     1067
     1068
    10481069/** @copydoc PDMDRVHLP::pfnPDMThreadCreate */
    10491070static DECLCALLBACK(int) pdmR3DrvHlp_PDMThreadCreate(PPDMDRVINS pDrvIns, PPPDMTHREAD ppThread, void *pvUser, PFNPDMTHREADDRV pfnThread,
    … …  
    11141135    pdmR3DrvHlp_USBRegisterHub,
    11151136    pdmR3DrvHlp_SetAsyncNotification,
     1137    pdmR3DrvHlp_AsyncNotificationCompleted,
    11161138    pdmR3DrvHlp_PDMThreadCreate,
    11171139#ifdef VBOX_WITH_PDM_ASYNC_COMPLETION

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

    r23190 r24740  
    11011101
    11021102/**
     1103 * Interface that PDMR3Suspend, PDMR3PowerOff and PDMR3Reset uses when they wait
     1104 * for the handling of asynchronous notifications to complete.
     1105 *
     1106 * @returns VINF_SUCCESS unless a fatal error occurred. In the latter
     1107 *          case an appropriate status code is returned.
     1108 * @param   pUVCpu              Pointer to the user mode VMCPU structure.
     1109 * @thread  The emulation thread.
     1110 */
     1111VMMR3_INT_DECL(int) VMR3AsyncPdmNotificationWaitU(PUVMCPU pUVCpu)
     1112{
     1113    LogFlow(("VMR3AsyncPdmNotificationWaitU:\n"));
     1114    return VMR3WaitU(pUVCpu);
     1115}
     1116
     1117
     1118/**
     1119 * Interface that PDM the helper asynchronous notification completed methods
     1120 * uses for EMT0 when it is waiting inside VMR3AsyncPdmNotificationWaitU().
     1121 *
     1122 * @param   pUVM                Pointer to the user mode VM structure.
     1123 */
     1124VMMR3_INT_DECL(void) VMR3AsyncPdmNotificationWakeupU(PUVM pUVM)
     1125{
     1126    LogFlow(("VMR3AsyncPdmNotificationWakeupU:\n"));
     1127    VM_FF_SET(pUVM->pVM, VM_FF_REQUEST); /* this will have to do for now. */
     1128    g_aHaltMethods[pUVM->vm.s.iHaltMethod].pfnNotifyCpuFF(&pUVM->aCpus[0], 0 /*fFlags*/);
     1129}
     1130
     1131
     1132/**
    11031133 * Rendezvous callback that will be called once.
    11041134 *
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