VirtualBox

Changeset 91955 in vbox


Ignore:
Timestamp:
Oct 21, 2021 2:26:20 PM (3 years ago)
Author:
vboxsync
Message:

VMM,Devices: Eliminate direct calls to PDMR3AsyncCompletion* and PDMR3BlkCache* and use the device helper callbacks, bugref:10074 [build fix]

Location:
trunk
Files:
3 edited

Legend:

Unmodified
Added
Removed

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

    r91945 r91955  
    12821282                                                                const char *pszDesc));
    12831283
     1284    /** @name Exported PDM Async Completion Functions
     1285     * @{ */
     1286    DECLR3CALLBACKMEMBER(int, pfnAsyncCompletionTemplateDestroy,(PPDMASYNCCOMPLETIONTEMPLATE pTemplate));
     1287    DECLR3CALLBACKMEMBER(int, pfnAsyncCompletionEpCreateForFile,(PPPDMASYNCCOMPLETIONENDPOINT ppEndpoint,
     1288                                                                 const char *pszFilename, uint32_t fFlags,
     1289                                                                 PPDMASYNCCOMPLETIONTEMPLATE pTemplate));
     1290    DECLR3CALLBACKMEMBER(void, pfnAsyncCompletionEpClose,(PPDMASYNCCOMPLETIONENDPOINT pEndpoint));
     1291    DECLR3CALLBACKMEMBER(int, pfnAsyncCompletionEpGetSize,(PPDMASYNCCOMPLETIONENDPOINT pEndpoint, uint64_t *pcbSize));
     1292    DECLR3CALLBACKMEMBER(int, pfnAsyncCompletionEpSetSize,(PPDMASYNCCOMPLETIONENDPOINT pEndpoint, uint64_t cbSize));
     1293    DECLR3CALLBACKMEMBER(int, pfnAsyncCompletionEpSetBwMgr,(PPDMASYNCCOMPLETIONENDPOINT pEndpoint, const char *pszBwMgr));
     1294    DECLR3CALLBACKMEMBER(int, pfnAsyncCompletionEpFlush,(PPDMASYNCCOMPLETIONENDPOINT pEndpoint, void *pvUser, PPPDMASYNCCOMPLETIONTASK ppTask));
     1295    DECLR3CALLBACKMEMBER(int, pfnAsyncCompletionEpRead,(PPDMASYNCCOMPLETIONENDPOINT pEndpoint, RTFOFF off,
     1296                                                        PCRTSGSEG paSegments, unsigned cSegments,
     1297                                                        size_t cbRead, void *pvUser,
     1298                                                        PPPDMASYNCCOMPLETIONTASK ppTask));
     1299    DECLR3CALLBACKMEMBER(int, pfnAsyncCompletionEpWrite,(PPDMASYNCCOMPLETIONENDPOINT pEndpoint, RTFOFF off,
     1300                                                         PCRTSGSEG paSegments, unsigned cSegments,
     1301                                                         size_t cbWrite, void *pvUser,
     1302                                                         PPPDMASYNCCOMPLETIONTASK ppTask));
     1303    /** @} */
     1304
     1305
    12841306    /**
    12851307     * Attaches network filter driver to a bandwidth group.
    … …  
    14211443                                                  PFNPDMBLKCACHEXFERENQUEUEDISCARDDRV pfnXferEnqueueDiscard,
    14221444                                                  const char *pcszId));
     1445
     1446    /** @name Exported PDM Block Cache Functions
     1447     * @{ */
     1448    DECLR3CALLBACKMEMBER(void,     pfnBlkCacheRelease,(PPDMBLKCACHE pBlkCache));
     1449    DECLR3CALLBACKMEMBER(int,      pfnBlkCacheClear,(PPDMBLKCACHE pBlkCache));
     1450    DECLR3CALLBACKMEMBER(int,      pfnBlkCacheSuspend,(PPDMBLKCACHE pBlkCache));
     1451    DECLR3CALLBACKMEMBER(int,      pfnBlkCacheResume,(PPDMBLKCACHE pBlkCache));
     1452    DECLR3CALLBACKMEMBER(void,     pfnBlkCacheIoXferComplete,(PPDMBLKCACHE pBlkCache, PPDMBLKCACHEIOXFER hIoXfer, int rcIoXfer));
     1453    DECLR3CALLBACKMEMBER(int,      pfnBlkCacheRead,(PPDMBLKCACHE pBlkCache, uint64_t off, PCRTSGBUF pSgBuf, size_t cbRead, void *pvUser));
     1454    DECLR3CALLBACKMEMBER(int,      pfnBlkCacheWrite,(PPDMBLKCACHE pBlkCache, uint64_t off, PCRTSGBUF pSgBuf, size_t cbRead, void *pvUser));
     1455    DECLR3CALLBACKMEMBER(int,      pfnBlkCacheFlush,(PPDMBLKCACHE pBlkCache, void *pvUser));
     1456    DECLR3CALLBACKMEMBER(int,      pfnBlkCacheDiscard,(PPDMBLKCACHE pBlkCache, PCRTRANGE paRanges, unsigned cRanges, void *pvUser));
     1457    /** @} */
     1458
    14231459    /**
    14241460     * Gets the reason for the most recent VM suspend.
    … …  
    14791515} PDMDRVHLPR3;
    14801516/** Current DRVHLP version number. */
    1481 #define PDM_DRVHLPR3_VERSION                    PDM_VERSION_MAKE(0xf0fb, 12, 0)
     1517#define PDM_DRVHLPR3_VERSION                    PDM_VERSION_MAKE(0xf0fb, 13, 0)
    14821518
    14831519
    … …  
    20302066{
    20312067    return pDrvIns->pHlpR3->pfnAsyncCompletionTemplateCreate(pDrvIns, ppTemplate, pfnCompleted, pvTemplateUser, pszDesc);
     2068}
     2069
     2070/**
     2071 * @copydoc PDMDRVHLPR3::pfnAsyncCompletionTemplateDestroy
     2072 */
     2073DECLINLINE(int) PDMDrvHlpAsyncCompletionTemplateDestroy(PPDMDRVINS pDrvIns, PPDMASYNCCOMPLETIONTEMPLATE pTemplate)
     2074{
     2075    return pDrvIns->pHlpR3->pfnAsyncCompletionTemplateDestroy(pTemplate);
     2076}
     2077
     2078/**
     2079 * @copydoc PDMDRVHLPR3::pfnAsyncCompletionEpCreateForFile
     2080 */
     2081DECLINLINE(int) PDMDrvHlpAsyncCompletionEpCreateForFile(PPDMDRVINS pDrvIns, PPPDMASYNCCOMPLETIONENDPOINT ppEndpoint,
     2082                                                        const char *pszFilename, uint32_t fFlags,
     2083                                                        PPDMASYNCCOMPLETIONTEMPLATE pTemplate)
     2084{
     2085    return pDrvIns->pHlpR3->pfnAsyncCompletionEpCreateForFile(ppEndpoint, pszFilename, fFlags, pTemplate);
     2086}
     2087
     2088/**
     2089 * @copydoc PDMDRVHLPR3::pfnAsyncCompletionEpClose
     2090 */
     2091DECLINLINE(void) PDMDrvHlpAsyncCompletionEpClose(PPDMDRVINS pDrvIns, PPDMASYNCCOMPLETIONENDPOINT pEndpoint)
     2092{
     2093    pDrvIns->pHlpR3->pfnAsyncCompletionEpClose(pEndpoint);
     2094}
     2095
     2096/**
     2097 * @copydoc PDMDRVHLPR3::pfnAsyncCompletionEpGetSize
     2098 */
     2099DECLINLINE(int) PDMDrvHlpAsyncCompletionEpGetSize(PPDMDRVINS pDrvIns, PPDMASYNCCOMPLETIONENDPOINT pEndpoint, uint64_t *pcbSize)
     2100{
     2101    return pDrvIns->pHlpR3->pfnAsyncCompletionEpGetSize(pEndpoint, pcbSize);
     2102}
     2103
     2104/**
     2105 * @copydoc PDMDRVHLPR3::pfnAsyncCompletionEpSetSize
     2106 */
     2107DECLINLINE(int) PDMDrvHlpAsyncCompletionEpSetSize(PPDMDRVINS pDrvIns, PPDMASYNCCOMPLETIONENDPOINT pEndpoint, uint64_t cbSize)
     2108{
     2109    return pDrvIns->pHlpR3->pfnAsyncCompletionEpSetSize(pEndpoint, cbSize);
     2110}
     2111
     2112/**
     2113 * @copydoc PDMDRVHLPR3::pfnAsyncCompletionEpSetBwMgr
     2114 */
     2115DECLINLINE(int) PDMDrvHlpAsyncCompletionEpSetBwMgr(PPDMDRVINS pDrvIns, PPDMASYNCCOMPLETIONENDPOINT pEndpoint, const char *pszBwMgr)
     2116{
     2117    return pDrvIns->pHlpR3->pfnAsyncCompletionEpSetBwMgr(pEndpoint, pszBwMgr);
     2118}
     2119
     2120/**
     2121 * @copydoc PDMDRVHLPR3::pfnAsyncCompletionEpFlush
     2122 */
     2123DECLINLINE(int) PDMDrvHlpAsyncCompletionEpFlush(PPDMDRVINS pDrvIns, PPDMASYNCCOMPLETIONENDPOINT pEndpoint, void *pvUser,
     2124                                                PPPDMASYNCCOMPLETIONTASK ppTask)
     2125{
     2126    return pDrvIns->pHlpR3->pfnAsyncCompletionEpFlush(pEndpoint, pvUser, ppTask);
     2127}
     2128
     2129/**
     2130 * @copydoc PDMDRVHLPR3::pfnAsyncCompletionEpRead
     2131 */
     2132DECLINLINE(int) PDMDrvHlpAsyncCompletionEpRead(PPDMDRVINS pDrvIns, PPDMASYNCCOMPLETIONENDPOINT pEndpoint, RTFOFF off,
     2133                                               PCRTSGSEG paSegments, unsigned cSegments,
     2134                                               size_t cbRead, void *pvUser,
     2135                                               PPPDMASYNCCOMPLETIONTASK ppTask)
     2136{
     2137    return pDrvIns->pHlpR3->pfnAsyncCompletionEpRead(pEndpoint, off, paSegments, cSegments, cbRead, pvUser, ppTask);
     2138}
     2139
     2140/**
     2141 * @copydoc PDMDRVHLPR3::pfnAsyncCompletionEpWrite
     2142 */
     2143DECLINLINE(int) PDMDrvHlpAsyncCompletionEpWrite(PPDMDRVINS pDrvIns, PPDMASYNCCOMPLETIONENDPOINT pEndpoint, RTFOFF off,
     2144                                                PCRTSGSEG paSegments, unsigned cSegments,
     2145                                                size_t cbWrite, void *pvUser,
     2146                                                PPPDMASYNCCOMPLETIONTASK ppTask)
     2147{
     2148    return pDrvIns->pHlpR3->pfnAsyncCompletionEpRead(pEndpoint, off, paSegments, cSegments, cbWrite, pvUser, ppTask);
    20322149}
    20332150# endif
    … …  
    22002317
    22012318/**
     2319 * @copydoc PDMDRVHLPR3::pfnBlkCacheRelease
     2320 */
     2321DECLINLINE(void) PDMDrvHlpBlkCacheRelease(PPDMDRVINS pDrvIns, PPDMBLKCACHE pBlkCache)
     2322{
     2323    pDrvIns->pHlpR3->pfnBlkCacheRelease(pBlkCache);
     2324}
     2325
     2326/**
     2327 * @copydoc PDMDRVHLPR3::pfnBlkCacheClear
     2328 */
     2329DECLINLINE(int) PDMDrvHlpBlkCacheClear(PPDMDRVINS pDrvIns, PPDMBLKCACHE pBlkCache)
     2330{
     2331    return pDrvIns->pHlpR3->pfnBlkCacheClear(pBlkCache);
     2332}
     2333
     2334/**
     2335 * @copydoc PDMDRVHLPR3::pfnBlkCacheSuspend
     2336 */
     2337DECLINLINE(int) PDMDrvHlpBlkCacheSuspend(PPDMDRVINS pDrvIns, PPDMBLKCACHE pBlkCache)
     2338{
     2339    return pDrvIns->pHlpR3->pfnBlkCacheSuspend(pBlkCache);
     2340}
     2341
     2342/**
     2343 * @copydoc PDMDRVHLPR3::pfnBlkCacheResume
     2344 */
     2345DECLINLINE(int) PDMDrvHlpBlkCacheResume(PPDMDRVINS pDrvIns, PPDMBLKCACHE pBlkCache)
     2346{
     2347    return pDrvIns->pHlpR3->pfnBlkCacheResume(pBlkCache);
     2348}
     2349
     2350/**
     2351 * @copydoc PDMDRVHLPR3::pfnBlkCacheIoXferComplete
     2352 */
     2353DECLINLINE(void) PDMDrvHlpBlkCacheIoXferComplete(PPDMDRVINS pDrvIns, PPDMBLKCACHE pBlkCache,
     2354                                                 PPDMBLKCACHEIOXFER hIoXfer, int rcIoXfer)
     2355{
     2356    return pDrvIns->pHlpR3->pfnBlkCacheIoXferComplete(pBlkCache, hIoXfer, rcIoXfer);
     2357}
     2358
     2359/**
     2360 * @copydoc PDMDRVHLPR3::pfnBlkCacheRead
     2361 */
     2362DECLINLINE(int) PDMDrvHlpBlkCacheRead(PPDMDRVINS pDrvIns, PPDMBLKCACHE pBlkCache, uint64_t off,
     2363                                      PCRTSGBUF pSgBuf, size_t cbRead, void *pvUser)
     2364{
     2365    return pDrvIns->pHlpR3->pfnBlkCacheRead(pBlkCache, off, pSgBuf, cbRead, pvUser);
     2366}
     2367
     2368/**
     2369 * @copydoc PDMDRVHLPR3::pfnBlkCacheWrite
     2370 */
     2371DECLINLINE(int) PDMDrvHlpBlkCacheWrite(PPDMDRVINS pDrvIns, PPDMBLKCACHE pBlkCache, uint64_t off,
     2372                                      PCRTSGBUF pSgBuf, size_t cbRead, void *pvUser)
     2373{
     2374    return pDrvIns->pHlpR3->pfnBlkCacheWrite(pBlkCache, off, pSgBuf, cbRead, pvUser);
     2375}
     2376
     2377/**
     2378 * @copydoc PDMDRVHLPR3::pfnBlkCacheFlush
     2379 */
     2380DECLINLINE(int) PDMDrvHlpBlkCacheFlush(PPDMDRVINS pDrvIns, PPDMBLKCACHE pBlkCache, void *pvUser)
     2381{
     2382    return pDrvIns->pHlpR3->pfnBlkCacheFlush(pBlkCache, pvUser);
     2383}
     2384
     2385/**
     2386 * @copydoc PDMDRVHLPR3::pfnBlkCacheDiscard
     2387 */
     2388DECLINLINE(int) PDMDrvHlpBlkCacheDiscard(PPDMDRVINS pDrvIns, PPDMBLKCACHE pBlkCache, PCRTRANGE paRanges,
     2389                                         unsigned cRanges, void *pvUser)
     2390{
     2391    return pDrvIns->pHlpR3->pfnBlkCacheDiscard(pBlkCache, paRanges, cRanges, pvUser);
     2392}
     2393
     2394/**
    22022395 * @copydoc PDMDRVHLPR3::pfnVMGetSuspendReason
    22032396 */

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

    r91937 r91955  
    128128typedef struct DRVVDSTORAGEBACKEND
    129129{
     130    /** The virtual disk driver instance. */
     131    PVBOXDISK                   pVD;
    130132    /** PDM async completion end point. */
    131133    PPDMASYNCCOMPLETIONENDPOINT pEndpoint;
    … …  
    647649    if (pStorageBackend)
    648650    {
     651        pStorageBackend->pVD            = pThis;
    649652        pStorageBackend->fSyncIoPending = false;
    650653        pStorageBackend->rcReqLast      = VINF_SUCCESS;
    … …  
    670673                    fFlags |= PDMACEP_FILE_FLAGS_HOST_CACHE_ENABLED;
    671674
    672                 rc = PDMR3AsyncCompletionEpCreateForFile(&pStorageBackend->pEndpoint,
    673                                                          pszLocation, fFlags,
    674                                                          pStorageBackend->pTemplate);
     675                rc = PDMDrvHlpAsyncCompletionEpCreateForFile(pThis->pDrvIns,
     676                                                             &pStorageBackend->pEndpoint,
     677                                                             pszLocation, fFlags,
     678                                                             pStorageBackend->pTemplate);
    675679
    676680                if (RT_SUCCESS(rc))
    677681                {
    678682                    if (pThis->pszBwGroup)
    679                         rc = PDMR3AsyncCompletionEpSetBwMgr(pStorageBackend->pEndpoint, pThis->pszBwGroup);
     683                        rc = PDMDrvHlpAsyncCompletionEpSetBwMgr(pThis->pDrvIns, pStorageBackend->pEndpoint, pThis->pszBwGroup);
    680684
    681685                    if (RT_SUCCESS(rc))
    … …  
    687691                    }
    688692
    689                     PDMR3AsyncCompletionEpClose(pStorageBackend->pEndpoint);
     693                    PDMDrvHlpAsyncCompletionEpClose(pThis->pDrvIns, pStorageBackend->pEndpoint);
    690694                }
    691695
    692                 PDMR3AsyncCompletionTemplateDestroy(pStorageBackend->pTemplate);
     696                PDMDrvHlpAsyncCompletionTemplateDestroy(pThis->pDrvIns, pStorageBackend->pTemplate);
    693697            }
    694698            RTSemEventDestroy(pStorageBackend->EventSem);
    … …  
    706710    RT_NOREF(pvUser);
    707711    PDRVVDSTORAGEBACKEND pStorageBackend = (PDRVVDSTORAGEBACKEND)pStorage;
     712    PVBOXDISK pThis = pStorageBackend->pVD;
    708713
    709714    /*
    … …  
    714719     */
    715720
    716     PDMR3AsyncCompletionEpClose(pStorageBackend->pEndpoint);
    717     PDMR3AsyncCompletionTemplateDestroy(pStorageBackend->pTemplate);
     721    PDMDrvHlpAsyncCompletionEpClose(pThis->pDrvIns, pStorageBackend->pEndpoint);
     722    PDMDrvHlpAsyncCompletionTemplateDestroy(pThis->pDrvIns, pStorageBackend->pTemplate);
    718723    RTSemEventDestroy(pStorageBackend->EventSem);
    719724    RTMemFree(pStorageBackend);
    … …  
    726731    RT_NOREF(pvUser);
    727732    PDRVVDSTORAGEBACKEND pStorageBackend = (PDRVVDSTORAGEBACKEND)pStorage;
     733    PVBOXDISK pThis = pStorageBackend->pVD;
    728734    RTSGSEG DataSeg;
    729735    PPDMASYNCCOMPLETIONTASK pTask;
    … …  
    734740    DataSeg.pvSeg = pvBuf;
    735741
    736     int rc = PDMR3AsyncCompletionEpRead(pStorageBackend->pEndpoint, uOffset, &DataSeg, 1, cbRead, NULL, &pTask);
     742    int rc = PDMDrvHlpAsyncCompletionEpRead(pThis->pDrvIns, pStorageBackend->pEndpoint, uOffset, &DataSeg, 1, cbRead, NULL, &pTask);
    737743    if (RT_FAILURE(rc))
    738744        return rc;
    … …  
    758764    RT_NOREF(pvUser);
    759765    PDRVVDSTORAGEBACKEND pStorageBackend = (PDRVVDSTORAGEBACKEND)pStorage;
     766    PVBOXDISK pThis = pStorageBackend->pVD;
    760767    RTSGSEG DataSeg;
    761768    PPDMASYNCCOMPLETIONTASK pTask;
    … …  
    766773    DataSeg.pvSeg = (void *)pvBuf;
    767774
    768     int rc = PDMR3AsyncCompletionEpWrite(pStorageBackend->pEndpoint, uOffset, &DataSeg, 1, cbWrite, NULL, &pTask);
     775    int rc = PDMDrvHlpAsyncCompletionEpWrite(pThis->pDrvIns, pStorageBackend->pEndpoint, uOffset, &DataSeg, 1, cbWrite, NULL, &pTask);
    769776    if (RT_FAILURE(rc))
    770777        return rc;
    … …  
    789796    RT_NOREF(pvUser);
    790797    PDRVVDSTORAGEBACKEND pStorageBackend = (PDRVVDSTORAGEBACKEND)pStorage;
     798    PVBOXDISK pThis = pStorageBackend->pVD;
    791799    PPDMASYNCCOMPLETIONTASK pTask;
    792800
    … …  
    796804    Assert(!fOld); NOREF(fOld);
    797805
    798     int rc = PDMR3AsyncCompletionEpFlush(pStorageBackend->pEndpoint, NULL, &pTask);
     806    int rc = PDMDrvHlpAsyncCompletionEpFlush(pThis->pDrvIns, pStorageBackend->pEndpoint, NULL, &pTask);
    799807    if (RT_FAILURE(rc))
    800808        return rc;
    … …  
    820828    RT_NOREF(pvUser);
    821829    PDRVVDSTORAGEBACKEND pStorageBackend = (PDRVVDSTORAGEBACKEND)pStorage;
    822 
    823     int rc = PDMR3AsyncCompletionEpRead(pStorageBackend->pEndpoint, uOffset, paSegments, (unsigned)cSegments, cbRead,
    824                                         pvCompletion, (PPPDMASYNCCOMPLETIONTASK)ppTask);
     830    PVBOXDISK pThis = pStorageBackend->pVD;
     831
     832    int rc = PDMDrvHlpAsyncCompletionEpRead(pThis->pDrvIns, pStorageBackend->pEndpoint,
     833                                            uOffset, paSegments, (unsigned)cSegments, cbRead,
     834                                            pvCompletion, (PPPDMASYNCCOMPLETIONTASK)ppTask);
    825835    if (rc == VINF_AIO_TASK_PENDING)
    826836        rc = VERR_VD_ASYNC_IO_IN_PROGRESS;
    … …  
    836846    RT_NOREF(pvUser);
    837847    PDRVVDSTORAGEBACKEND pStorageBackend = (PDRVVDSTORAGEBACKEND)pStorage;
    838 
    839     int rc = PDMR3AsyncCompletionEpWrite(pStorageBackend->pEndpoint, uOffset, paSegments, (unsigned)cSegments, cbWrite,
    840                                          pvCompletion, (PPPDMASYNCCOMPLETIONTASK)ppTask);
     848    PVBOXDISK pThis = pStorageBackend->pVD;
     849
     850    int rc = PDMDrvHlpAsyncCompletionEpWrite(pThis->pDrvIns, pStorageBackend->pEndpoint,
     851                                             uOffset, paSegments, (unsigned)cSegments, cbWrite,
     852                                             pvCompletion, (PPPDMASYNCCOMPLETIONTASK)ppTask);
    841853    if (rc == VINF_AIO_TASK_PENDING)
    842854        rc = VERR_VD_ASYNC_IO_IN_PROGRESS;
    … …  
    850862    RT_NOREF(pvUser);
    851863    PDRVVDSTORAGEBACKEND pStorageBackend = (PDRVVDSTORAGEBACKEND)pStorage;
    852 
    853     int rc = PDMR3AsyncCompletionEpFlush(pStorageBackend->pEndpoint, pvCompletion,
    854                                          (PPPDMASYNCCOMPLETIONTASK)ppTask);
     864    PVBOXDISK pThis = pStorageBackend->pVD;
     865
     866    int rc = PDMDrvHlpAsyncCompletionEpFlush(pThis->pDrvIns, pStorageBackend->pEndpoint, pvCompletion,
     867                                             (PPPDMASYNCCOMPLETIONTASK)ppTask);
    855868    if (rc == VINF_AIO_TASK_PENDING)
    856869        rc = VERR_VD_ASYNC_IO_IN_PROGRESS;
    … …  
    863876    RT_NOREF(pvUser);
    864877    PDRVVDSTORAGEBACKEND pStorageBackend = (PDRVVDSTORAGEBACKEND)pStorage;
    865 
    866     return PDMR3AsyncCompletionEpGetSize(pStorageBackend->pEndpoint, pcbSize);
     878    PVBOXDISK pThis = pStorageBackend->pVD;
     879
     880    return PDMDrvHlpAsyncCompletionEpGetSize(pThis->pDrvIns, pStorageBackend->pEndpoint, pcbSize);
    867881}
    868882
    … …  
    871885    RT_NOREF(pvUser);
    872886    PDRVVDSTORAGEBACKEND pStorageBackend = (PDRVVDSTORAGEBACKEND)pStorage;
    873 
    874     return PDMR3AsyncCompletionEpSetSize(pStorageBackend->pEndpoint, cbSize);
     887    PVBOXDISK pThis = pStorageBackend->pVD;
     888
     889    return PDMDrvHlpAsyncCompletionEpSetSize(pThis->pDrvIns, pStorageBackend->pEndpoint, cbSize);
    875890}
    876891
    … …  
    21812196
    21822197    AssertPtr(pThis->pBlkCache);
    2183     PDMR3BlkCacheIoXferComplete(pThis->pBlkCache, (PPDMBLKCACHEIOXFER)pvUser2, rcReq);
     2198    PDMDrvHlpBlkCacheIoXferComplete(pThis->pDrvIns, pThis->pBlkCache, (PPDMBLKCACHEIOXFER)pvUser2, rcReq);
    21842199}
    21852200
    … …  
    22232238
    22242239    if (rc == VINF_VD_ASYNC_IO_FINISHED)
    2225         PDMR3BlkCacheIoXferComplete(pThis->pBlkCache, hIoXfer, VINF_SUCCESS);
     2240        PDMDrvHlpBlkCacheIoXferComplete(pThis->pDrvIns, pThis->pBlkCache, hIoXfer, VINF_SUCCESS);
    22262241    else if (RT_FAILURE(rc) && rc != VERR_VD_ASYNC_IO_IN_PROGRESS)
    2227         PDMR3BlkCacheIoXferComplete(pThis->pBlkCache, hIoXfer, rc);
     2242        PDMDrvHlpBlkCacheIoXferComplete(pThis->pDrvIns, pThis->pBlkCache, hIoXfer, rc);
    22282243
    22292244    return VINF_SUCCESS;
    … …  
    22412256
    22422257    if (rc == VINF_VD_ASYNC_IO_FINISHED)
    2243         PDMR3BlkCacheIoXferComplete(pThis->pBlkCache, hIoXfer, VINF_SUCCESS);
     2258        PDMDrvHlpBlkCacheIoXferComplete(pThis->pDrvIns, pThis->pBlkCache, hIoXfer, VINF_SUCCESS);
    22442259    else if (RT_FAILURE(rc) && rc != VERR_VD_ASYNC_IO_IN_PROGRESS)
    2245         PDMR3BlkCacheIoXferComplete(pThis->pBlkCache, hIoXfer, rc);
     2260        PDMDrvHlpBlkCacheIoXferComplete(pThis->pDrvIns, pThis->pBlkCache, hIoXfer, rc);
    22462261
    22472262    return VINF_SUCCESS;
    … …  
    27352750        if (pThis->pBlkCache)
    27362751        {
    2737             rc = PDMR3BlkCacheRead(pThis->pBlkCache, pIoReq->ReadWrite.offStart,
    2738                                    pIoReq->ReadWrite.pSgBuf, cbReqIo, pIoReq);
     2752            rc = PDMDrvHlpBlkCacheRead(pThis->pDrvIns, pThis->pBlkCache, pIoReq->ReadWrite.offStart,
     2753                                       pIoReq->ReadWrite.pSgBuf, cbReqIo, pIoReq);
    27392754            if (rc == VINF_SUCCESS)
    27402755                rc = VINF_VD_ASYNC_IO_FINISHED;
    … …  
    27842799        if (pThis->pBlkCache)
    27852800        {
    2786             rc = PDMR3BlkCacheWrite(pThis->pBlkCache, pIoReq->ReadWrite.offStart,
    2787                                     pIoReq->ReadWrite.pSgBuf, cbReqIo, pIoReq);
     2801            rc = PDMDrvHlpBlkCacheWrite(pThis->pDrvIns, pThis->pBlkCache, pIoReq->ReadWrite.offStart,
     2802                                        pIoReq->ReadWrite.pSgBuf, cbReqIo, pIoReq);
    27882803            if (rc == VINF_SUCCESS)
    27892804                rc = VINF_VD_ASYNC_IO_FINISHED;
    … …  
    28472862            if (pThis->pBlkCache)
    28482863            {
    2849                 rc = PDMR3BlkCacheFlush(pThis->pBlkCache, pIoReq);
     2864                rc = PDMDrvHlpBlkCacheFlush(pThis->pDrvIns, pThis->pBlkCache, pIoReq);
    28502865                if (rc == VINF_SUCCESS)
    28512866                    rc = VINF_VD_ASYNC_IO_FINISHED;
    … …  
    28932908        if (pThis->pBlkCache)
    28942909        {
    2895             rc = PDMR3BlkCacheDiscard(pThis->pBlkCache, pIoReq->Discard.paRanges, pIoReq->Discard.cRanges, pIoReq);
     2910            rc = PDMDrvHlpBlkCacheDiscard(pThis->pDrvIns, pThis->pBlkCache,
     2911                                          pIoReq->Discard.paRanges, pIoReq->Discard.cRanges,
     2912                                          pIoReq);
    28962913            if (rc == VINF_SUCCESS)
    28972914                rc = VINF_VD_ASYNC_IO_FINISHED;
    … …  
    42674284    if (RT_VALID_PTR(pThis->pBlkCache))
    42684285    {
    4269         PDMR3BlkCacheRelease(pThis->pBlkCache);
     4286        PDMDrvHlpBlkCacheRelease(pThis->pDrvIns, pThis->pBlkCache);
    42704287        pThis->pBlkCache = NULL;
    42714288    }
    … …  
    43174334    if (pThis->pBlkCache)
    43184335    {
    4319         int rc = PDMR3BlkCacheResume(pThis->pBlkCache);
     4336        int rc = PDMDrvHlpBlkCacheResume(pThis->pDrvIns, pThis->pBlkCache);
    43204337        AssertRC(rc);
    43214338    }
    … …  
    44244441    if (pThis->pBlkCache)
    44254442    {
    4426         int rc = PDMR3BlkCacheSuspend(pThis->pBlkCache);
     4443        int rc = PDMDrvHlpBlkCacheSuspend(pThis->pDrvIns, pThis->pBlkCache);
    44274444        AssertRC(rc);
    44284445    }
    … …  
    44524469    if (pThis->pBlkCache)
    44534470    {
    4454         int rc = PDMR3BlkCacheClear(pThis->pBlkCache);
     4471        int rc = PDMDrvHlpBlkCacheClear(pThis->pDrvIns, pThis->pBlkCache);
    44554472        AssertRC(rc);
    44564473    }

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

    r91945 r91955  
    22382238    PDMR3ThreadResume,
    22392239    pdmR3DrvHlp_AsyncCompletionTemplateCreate,
     2240    PDMR3AsyncCompletionTemplateDestroy,
     2241    PDMR3AsyncCompletionEpCreateForFile,
     2242    PDMR3AsyncCompletionEpClose,
     2243    PDMR3AsyncCompletionEpGetSize,
     2244    PDMR3AsyncCompletionEpSetSize,
     2245    PDMR3AsyncCompletionEpSetBwMgr,
     2246    PDMR3AsyncCompletionEpFlush,
     2247    PDMR3AsyncCompletionEpRead,
     2248    PDMR3AsyncCompletionEpWrite,
    22402249    pdmR3DrvHlp_NetShaperAttach,
    22412250    pdmR3DrvHlp_NetShaperDetach,
    … …  
    22582267    pdmR3DrvHlp_CallR0,
    22592268    pdmR3DrvHlp_BlkCacheRetain,
     2269    PDMR3BlkCacheRelease,
     2270    PDMR3BlkCacheClear,
     2271    PDMR3BlkCacheSuspend,
     2272    PDMR3BlkCacheResume,
     2273    PDMR3BlkCacheIoXferComplete,
     2274    PDMR3BlkCacheRead,
     2275    PDMR3BlkCacheWrite,
     2276    PDMR3BlkCacheFlush,
     2277    PDMR3BlkCacheDiscard,
    22602278    pdmR3DrvHlp_VMGetSuspendReason,
    22612279    pdmR3DrvHlp_VMGetResumeReason,
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