VirtualBox

Changeset 26240 in vbox


Ignore:
Timestamp:
Feb 4, 2010 3:35:02 PM (15 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
57288
Message:

AsyncCompletion: Cleanup

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

Legend:

Unmodified
Added
Removed

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

    r26181 r26240  
    5353#include "PDMAsyncCompletionFileInternal.h"
    5454
     55/**
     56 * A I/O memory context.
     57 */
     58typedef struct PDMIOMEMCTX
     59{
     60    /** Pointer to the scatter/gather list. */
     61    PCPDMDATASEG   paDataSeg;
     62    /** Number of segments. */
     63    size_t         cSegments;
     64    /** Current segment we are in. */
     65    unsigned       iSegIdx;
     66    /** Pointer to the current buffer. */
     67    uint8_t       *pbBuf;
     68    /** Number of bytes left in the current buffer. */
     69    size_t         cbBufLeft;
     70} PDMIOMEMCTX, *PPDMIOMEMCTX;
     71
    5572#ifdef VBOX_STRICT
    5673# define PDMACFILECACHE_IS_CRITSECT_OWNER(Cache) \
    … …  
    6986static void pdmacFileCacheTaskCompleted(PPDMACTASKFILE pTask, void *pvUser);
    7087
     88/**
     89 * Decrement the reference counter of the given cache entry.
     90 *
     91 * @returns nothing.
     92 * @param   pEntry    The entry to release.
     93 */
    7194DECLINLINE(void) pdmacFileEpCacheEntryRelease(PPDMACFILECACHEENTRY pEntry)
    7295{
    … …  
    7598}
    7699
     100/**
     101 * Increment the reference counter of the given cache entry.
     102 *
     103 * @returns nothing.
     104 * @param   pEntry    The entry to reference.
     105 */
    77106DECLINLINE(void) pdmacFileEpCacheEntryRef(PPDMACFILECACHEENTRY pEntry)
    78107{
    … …  
    80109}
    81110
     111/**
     112 * Initialize a I/O memory context.
     113 *
     114 * @returns nothing
     115 * @param   pIoMemCtx    Pointer to a unitialized I/O memory context.
     116 * @param   paDataSeg    Pointer to the S/G list.
     117 * @param   cSegments    Number of segments in the S/G list.
     118 */
     119DECLINLINE(void) pdmIoMemCtxInit(PPDMIOMEMCTX pIoMemCtx, PCPDMDATASEG paDataSeg, size_t cSegments)
     120{
     121    AssertMsg((cSegments > 0) && paDataSeg, ("Trying to initialize a I/O memory context without a S/G list\n"));
     122
     123    pIoMemCtx->paDataSeg = paDataSeg;
     124    pIoMemCtx->cSegments = cSegments;
     125    pIoMemCtx->iSegIdx   = 0;
     126    pIoMemCtx->pbBuf     = (uint8_t *)paDataSeg[0].pvSeg;
     127    pIoMemCtx->cbBufLeft = paDataSeg[0].cbSeg;
     128}
     129
     130/**
     131 * Return a buffer from the I/O memory context.
     132 *
     133 * @returns Pointer to the buffer
     134 * @param   pIoMemCtx    Pointer to the I/O memory context.
     135 * @param   pcbData      Pointer to the amount of byte requested.
     136 *                       If the current buffer doesn't have enough bytes left
     137 *                       the amount is returned in the variable.
     138 */
     139DECLINLINE(uint8_t *) pdmIoMemCtxGetBuffer(PPDMIOMEMCTX pIoMemCtx, size_t *pcbData)
     140{
     141    size_t cbData = RT_MIN(*pcbData, pIoMemCtx->cbBufLeft);
     142    uint8_t *pbBuf = pIoMemCtx->pbBuf;
     143
     144    pIoMemCtx->cbBufLeft -= cbData;
     145
     146    /* Advance to the next segment if required. */
     147    if (!pIoMemCtx->cbBufLeft)
     148    {
     149        pIoMemCtx->iSegIdx++;
     150
     151        if (RT_UNLIKELY(pIoMemCtx->iSegIdx == pIoMemCtx->cSegments))
     152        {
     153            pIoMemCtx->cbBufLeft = 0;
     154            pIoMemCtx->pbBuf     = NULL;
     155        }
     156        else
     157        {
     158            pIoMemCtx->pbBuf     = (uint8_t *)pIoMemCtx->paDataSeg[pIoMemCtx->iSegIdx].pvSeg;
     159            pIoMemCtx->cbBufLeft = pIoMemCtx->paDataSeg[pIoMemCtx->iSegIdx].cbSeg;
     160        }
     161
     162        *pcbData = cbData;
     163    }
     164    else
     165        pIoMemCtx->pbBuf += cbData;
     166
     167    return pbBuf;
     168}
     169
     170#ifdef PDMACFILECACHE_WITH_LRULIST_CHECKS
    82171/**
    83172 * Checks consistency of a LRU list.
    … …  
    89178static void pdmacFileCacheCheckList(PPDMACFILELRULIST pList, PPDMACFILECACHEENTRY pNotInList)
    90179{
    91 #ifdef PDMACFILECACHE_WITH_LRULIST_CHECKS
    92180    PPDMACFILECACHEENTRY pCurr = pList->pHead;
    93181
    … …  
    112200        pCurr = pCurr->pNext;
    113201    }
    114 #endif
    115 }
     202}
     203#endif
    116204
    117205/**
    … …  
    129217
    130218    AssertPtr(pList);
     219
     220#ifdef PDMACFILECACHE_WITH_LRULIST_CHECKS
    131221    pdmacFileCacheCheckList(pList, NULL);
     222#endif
    132223
    133224    pPrev = pEntry->pPrev;
    … …  
    161252    pEntry->pNext    = NULL;
    162253    pList->cbCached -= pEntry->cbData;
     254#ifdef PDMACFILECACHE_WITH_LRULIST_CHECKS
    163255    pdmacFileCacheCheckList(pList, pEntry);
     256#endif
    164257}
    165258
    … …  
    175268{
    176269    LogFlowFunc((": Adding entry %#p to list %#p\n", pEntry, pList));
     270#ifdef PDMACFILECACHE_WITH_LRULIST_CHECKS
    177271    pdmacFileCacheCheckList(pList, NULL);
     272#endif
    178273
    179274    /* Remove from old list if needed */
    … …  
    194289    pList->cbCached += pEntry->cbData;
    195290    pEntry->pList    = pList;
     291#ifdef PDMACFILECACHE_WITH_LRULIST_CHECKS
    196292    pdmacFileCacheCheckList(pList, NULL);
     293#endif
    197294}
    198295
    … …  
    11241221
    11251222/**
    1126  * Advances the current segment buffer by the number of bytes transfered
    1127  * or gets the next segment.
    1128  */
    1129 #define ADVANCE_SEGMENT_BUFFER(BytesTransfered) \
    1130     do \
    1131     { \
    1132         cbSegLeft -= BytesTransfered; \
    1133         if (!cbSegLeft) \
    1134         { \
    1135             iSegCurr++; \
    1136             cbSegLeft = paSegments[iSegCurr].cbSeg; \
    1137             pbSegBuf  = (uint8_t *)paSegments[iSegCurr].pvSeg; \
    1138         } \
    1139         else \
    1140             pbSegBuf += BytesTransfered; \
    1141     } \
    1142     while (0)
     1223 * Copies data to a buffer described by a I/O memory context.
     1224 *
     1225 * @returns nothing.
     1226 * @param   pIoMemCtx    The I/O memory context to copy the data into.
     1227 * @param   pbData       Pointer to the data data to copy.
     1228 * @param   cbData       Amount of data to copy.
     1229 */
     1230static void pdmacFileEpCacheCopyToIoMemCtx(PPDMIOMEMCTX pIoMemCtx,
     1231                                           uint8_t *pbData,
     1232                                           size_t cbData)
     1233{
     1234    while (cbData)
     1235    {
     1236        size_t cbCopy = cbData;
     1237        uint8_t *pbBuf = pdmIoMemCtxGetBuffer(pIoMemCtx, &cbCopy);
     1238
     1239        AssertPtr(pbBuf);
     1240
     1241        memcpy(pbBuf, pbData, cbCopy);
     1242
     1243        cbData -= cbCopy;
     1244        pbData += cbCopy;
     1245    }
     1246}
     1247
     1248/**
     1249 * Copies data from a buffer described by a I/O memory context.
     1250 *
     1251 * @returns nothing.
     1252 * @param   pIoMemCtx    The I/O memory context to copy the data from.
     1253 * @param   pbData       Pointer to the destination buffer.
     1254 * @param   cbData       Amount of data to copy.
     1255 */
     1256static void pdmacFileEpCacheCopyFromIoMemCtx(PPDMIOMEMCTX pIoMemCtx,
     1257                                             uint8_t *pbData,
     1258                                             size_t cbData)
     1259{
     1260    while (cbData)
     1261    {
     1262        size_t cbCopy = cbData;
     1263        uint8_t *pbBuf = pdmIoMemCtxGetBuffer(pIoMemCtx, &cbCopy);
     1264
     1265        AssertPtr(pbBuf);
     1266
     1267        memcpy(pbData, pbBuf, cbCopy);
     1268
     1269        cbData -= cbCopy;
     1270        pbData += cbCopy;
     1271    }
     1272}
     1273
     1274/**
     1275 * Add a buffer described by the I/O memory context
     1276 * to the entry waiting for completion.
     1277 *
     1278 * @returns nothing.
     1279 * @param   pEntry    The entry to add the buffer to.
     1280 * @param   pTask     Task associated with the buffer.
     1281 * @param   pIoMemCtx The memory context to use.
     1282 * @param   OffDiff   Offset from the start of the buffer
     1283 *                    in the entry.
     1284 * @param   cbData    Amount of data to wait for onthis entry.
     1285 * @param   fWrite    Flag whether the task waits because it wants to write
     1286 *                    to the cache entry.
     1287 */
     1288static void pdmacFileEpCacheEntryWaitersAdd(PPDMACFILECACHEENTRY pEntry,
     1289                                            PPDMASYNCCOMPLETIONTASKFILE pTask,
     1290                                            PPDMIOMEMCTX pIoMemCtx,
     1291                                            RTFOFF OffDiff,
     1292                                            size_t cbData,
     1293                                            bool fWrite)
     1294{
     1295    while (cbData)
     1296    {
     1297        PPDMACFILETASKSEG pSeg  = (PPDMACFILETASKSEG)RTMemAllocZ(sizeof(PDMACFILETASKSEG));
     1298        size_t            cbSeg = cbData;
     1299        uint8_t          *pbBuf = pdmIoMemCtxGetBuffer(pIoMemCtx, &cbSeg);
     1300
     1301        pSeg->pTask      = pTask;
     1302        pSeg->uBufOffset = OffDiff;
     1303        pSeg->cbTransfer = cbSeg;
     1304        pSeg->pvBuf      = pbBuf;
     1305        pSeg->fWrite     = fWrite;
     1306
     1307        pdmacFileEpCacheEntryAddWaitingSegment(pEntry, pSeg);
     1308
     1309        cbData   -= cbSeg;
     1310        OffDiff  += cbSeg;
     1311    }
     1312}
     1313
     1314/**
     1315 * Passthrough a part of a request directly to the I/O manager
     1316 * handling the endpoint.
     1317 *
     1318 * @returns nothing.
     1319 * @param   pEndpoint          The endpoint.
     1320 * @param   pTask              The task.
     1321 * @param   pIoMemCtx          The I/O memory context to use.
     1322 * @param   offStart           Offset to start transfer from.
     1323 * @param   cbData             Amount of data to transfer.
     1324 * @param   enmTransferType    The transfer type (read/write)
     1325 */
     1326static void pdmacFileEpCacheRequestPassthrough(PPDMASYNCCOMPLETIONENDPOINTFILE pEndpoint,
     1327                                               PPDMASYNCCOMPLETIONTASKFILE pTask,
     1328                                               PPDMIOMEMCTX pIoMemCtx,
     1329                                               RTFOFF offStart, size_t cbData,
     1330                                               PDMACTASKFILETRANSFER enmTransferType)
     1331{
     1332    while (cbData)
     1333    {
     1334        size_t         cbSeg = cbData;
     1335        uint8_t       *pbBuf = pdmIoMemCtxGetBuffer(pIoMemCtx, &cbSeg);
     1336        PPDMACTASKFILE pIoTask = pdmacFileTaskAlloc(pEndpoint);
     1337        AssertPtr(pIoTask);
     1338
     1339        pIoTask->pEndpoint       = pEndpoint;
     1340        pIoTask->enmTransferType = enmTransferType;
     1341        pIoTask->Off             = offStart;
     1342        pIoTask->DataSeg.cbSeg   = cbSeg;
     1343        pIoTask->DataSeg.pvSeg   = pbBuf;
     1344        pIoTask->pvUser          = pTask;
     1345        pIoTask->pfnCompleted    = pdmacFileEpTaskCompleted;
     1346
     1347        offStart += cbSeg;
     1348        cbData   -= cbSeg;
     1349
     1350        /* Send it off to the I/O manager. */
     1351        pdmacFileEpAddTask(pEndpoint, pIoTask);
     1352    }
     1353}
    11431354
    11441355/**
    … …  
    11691380    ASMAtomicWriteBool(&pTask->fCompleted, true);
    11701381
    1171     int iSegCurr       = 0;
    1172     uint8_t *pbSegBuf  = (uint8_t *)paSegments[iSegCurr].pvSeg;
    1173     size_t   cbSegLeft = paSegments[iSegCurr].cbSeg;
     1382    /* Init the I/O memory context */
     1383    PDMIOMEMCTX IoMemCtx;
     1384    pdmIoMemCtxInit(&IoMemCtx, paSegments, cSegments);
    11741385
    11751386    while (cbRead)
    … …  
    12011412
    12021413            cbToRead = RT_MIN(pEntry->cbData - OffDiff, cbRead);
     1414
     1415            AssertMsg(off + cbToRead <= pEntry->Core.Key + pEntry->Core.KeyLast,
     1416                      ("Buffer of cache entry exceeded off=%RTfoff cbToRead=%z\n",
     1417                       off, cbToRead));
     1418
    12031419            cbRead  -= cbToRead;
     1420            off     += cbToRead;
    12041421
    12051422            if (!cbRead)
    … …  
    12201437            {
    12211438#endif
    1222                 if(pdmacFileEpCacheEntryFlagIsSetClearAcquireLock(pEndpointCache, pEntry,
    1223                                                                   PDMACFILECACHE_ENTRY_IS_DEPRECATED,
    1224                                                                   0))
     1439                if (pdmacFileEpCacheEntryFlagIsSetClearAcquireLock(pEndpointCache, pEntry,
     1440                                                                   PDMACFILECACHE_ENTRY_IS_DEPRECATED,
     1441                                                                   0))
    12251442                {
    12261443                    /* Entry is deprecated. Read data from the new buffer. */
    1227                     while (cbToRead)
    1228                     {
    1229                         size_t cbCopy = RT_MIN(cbSegLeft, cbToRead);
    1230 
    1231                         memcpy(pbSegBuf, pEntry->pbDataReplace + OffDiff, cbCopy);
    1232 
    1233                         ADVANCE_SEGMENT_BUFFER(cbCopy);
    1234 
    1235                         cbToRead -= cbCopy;
    1236                         off      += cbCopy;
    1237                         OffDiff  += cbCopy;
    1238                         ASMAtomicSubS32(&pTask->cbTransferLeft, cbCopy);
    1239                     }
     1444                    pdmacFileEpCacheCopyToIoMemCtx(&IoMemCtx, pEntry->pbDataReplace + OffDiff, cbToRead);
     1445                    ASMAtomicSubS32(&pTask->cbTransferLeft, cbToRead);
    12401446                    RTSemRWReleaseWrite(pEndpointCache->SemRWEntries);
    12411447                }
    … …  
    12471453                    {
    12481454                        /* Entry didn't completed yet. Append to the list */
    1249                         while (cbToRead)
    1250                         {
    1251                             PPDMACFILETASKSEG pSeg = (PPDMACFILETASKSEG)RTMemAllocZ(sizeof(PDMACFILETASKSEG));
    1252 
    1253                             pSeg->pTask      = pTask;
    1254                             pSeg->uBufOffset = OffDiff;
    1255                             pSeg->cbTransfer = RT_MIN(cbToRead, cbSegLeft);
    1256                             pSeg->pvBuf      = pbSegBuf;
    1257                             pSeg->fWrite     = false;
    1258 
    1259                             ADVANCE_SEGMENT_BUFFER(pSeg->cbTransfer);
    1260 
    1261                             pdmacFileEpCacheEntryAddWaitingSegment(pEntry, pSeg);
    1262 
    1263                             off      += pSeg->cbTransfer;
    1264                             cbToRead -= pSeg->cbTransfer;
    1265                             OffDiff  += pSeg->cbTransfer;
    1266                         }
     1455                        pdmacFileEpCacheEntryWaitersAdd(pEntry, pTask,
     1456                                                        &IoMemCtx,
     1457                                                        OffDiff, cbToRead,
     1458                                                        false /* fWrite */);
    12671459                        RTSemRWReleaseWrite(pEndpointCache->SemRWEntries);
    12681460                    }
    … …  
    12701462                    {
    12711463                        /* Read as much as we can from the entry. */
    1272                         while (cbToRead)
    1273                         {
    1274                             size_t cbCopy = RT_MIN(cbSegLeft, cbToRead);
    1275 
    1276                             memcpy(pbSegBuf, pEntry->pbData + OffDiff, cbCopy);
    1277 
    1278                             ADVANCE_SEGMENT_BUFFER(cbCopy);
    1279 
    1280                             cbToRead -= cbCopy;
    1281                             off      += cbCopy;
    1282                             OffDiff  += cbCopy;
    1283                             ASMAtomicSubS32(&pTask->cbTransferLeft, cbCopy);
    1284                         }
     1464                        pdmacFileEpCacheCopyToIoMemCtx(&IoMemCtx, pEntry->pbData + OffDiff, cbToRead);
     1465                        ASMAtomicSubS32(&pTask->cbTransferLeft, cbToRead);
    12851466                    }
    12861467                }
    … …  
    13301511                AssertPtr(pEntry->pbData);
    13311512
    1332                 while (cbToRead)
    1333                 {
    1334                     PPDMACFILETASKSEG pSeg = (PPDMACFILETASKSEG)RTMemAllocZ(sizeof(PDMACFILETASKSEG));
    1335 
    1336                     AssertMsg(off >= pEntry->Core.Key,
    1337                                 ("Overflow in calculation off=%RTfoff OffsetAligned=%RTfoff\n",
    1338                                 off, pEntry->Core.Key));
    1339 
    1340                     pSeg->pTask      = pTask;
    1341                     pSeg->uBufOffset = OffDiff;
    1342                     pSeg->cbTransfer = RT_MIN(cbToRead, cbSegLeft);
    1343                     pSeg->pvBuf      = pbSegBuf;
    1344 
    1345                     ADVANCE_SEGMENT_BUFFER(pSeg->cbTransfer);
    1346 
    1347                     pdmacFileEpCacheEntryAddWaitingSegment(pEntry, pSeg);
    1348 
    1349                     off      += pSeg->cbTransfer;
    1350                     OffDiff  += pSeg->cbTransfer;
    1351                     cbToRead -= pSeg->cbTransfer;
    1352                 }
    1353 
     1513                pdmacFileEpCacheEntryWaitersAdd(pEntry, pTask,
     1514                                                &IoMemCtx,
     1515                                                OffDiff, cbToRead,
     1516                                                false /* fWrite */);
    13541517                pdmacFileCacheReadFromEndpoint(pEntry);
    13551518            }
     1519
     1520            /* Release the entry finally. */
    13561521            pdmacFileEpCacheEntryRelease(pEntry);
    13571522        }
    … …  
    14361601
    14371602                pdmacFileEpCacheInsertEntry(pEndpointCache, pEntryNew);
    1438                 uint32_t uBufOffset = 0;
    1439 
    1440                 while (cbToRead)
    1441                 {
    1442                     PPDMACFILETASKSEG pSeg = (PPDMACFILETASKSEG)RTMemAllocZ(sizeof(PDMACFILETASKSEG));
    1443 
    1444                     pSeg->pTask      = pTask;
    1445                     pSeg->uBufOffset = uBufOffset;
    1446                     pSeg->cbTransfer = RT_MIN(cbToRead, cbSegLeft);
    1447                     pSeg->pvBuf      = pbSegBuf;
    1448 
    1449                     ADVANCE_SEGMENT_BUFFER(pSeg->cbTransfer);
    1450 
    1451                     pdmacFileEpCacheEntryAddWaitingSegment(pEntryNew, pSeg);
    1452 
    1453                     off        += pSeg->cbTransfer;
    1454                     cbToRead   -= pSeg->cbTransfer;
    1455                     uBufOffset += pSeg->cbTransfer;
    1456                 }
     1603
     1604                AssertMsg(   (off >= pEntryNew->Core.Key)
     1605                          && (off + cbToRead <= pEntryNew->Core.Key + pEntryNew->Core.KeyLast),
     1606                          ("Overflow in calculation off=%RTfoff OffsetAligned=%RTfoff\n",
     1607                           off, pEntry->Core.Key));
     1608
     1609                pdmacFileEpCacheEntryWaitersAdd(pEntryNew, pTask,
     1610                                                &IoMemCtx, 0, cbToRead,
     1611                                                false /* fWrite */);
     1612                off += cbToRead;
    14571613
    14581614                pdmacFileCacheReadFromEndpoint(pEntryNew);
    … …  
    14671623                LogFlow(("Couldn't evict %u bytes from the cache. Remaining request will be passed through\n", cbToRead));
    14681624
    1469                 while (cbToRead)
    1470                 {
    1471                     PPDMACTASKFILE pIoTask = pdmacFileTaskAlloc(pEndpoint);
    1472                     AssertPtr(pIoTask);
    1473 
    1474                     pIoTask->pEndpoint       = pEndpoint;
    1475                     pIoTask->enmTransferType = PDMACTASKFILETRANSFER_READ;
    1476                     pIoTask->Off             = off;
    1477                     pIoTask->DataSeg.cbSeg   = RT_MIN(cbToRead, cbSegLeft);
    1478                     pIoTask->DataSeg.pvSeg   = pbSegBuf;
    1479                     pIoTask->pvUser          = pTask;
    1480                     pIoTask->pfnCompleted    = pdmacFileEpTaskCompleted;
    1481 
    1482                     off      += pIoTask->DataSeg.cbSeg;
    1483                     cbToRead -= pIoTask->DataSeg.cbSeg;
    1484 
    1485                     ADVANCE_SEGMENT_BUFFER(pIoTask->DataSeg.cbSeg);
    1486 
    1487                     /* Send it off to the I/O manager. */
    1488                     pdmacFileEpAddTask(pEndpoint, pIoTask);
    1489                 }
     1625                pdmacFileEpCacheRequestPassthrough(pEndpoint, pTask,
     1626                                                   &IoMemCtx, off, cbToRead,
     1627                                                   PDMACTASKFILETRANSFER_READ);
    14901628            }
    14911629        }
    … …  
    15321670    ASMAtomicWriteBool(&pTask->fCompleted, true);
    15331671
    1534     int iSegCurr       = 0;
    1535     uint8_t *pbSegBuf  = (uint8_t *)paSegments[iSegCurr].pvSeg;
    1536     size_t   cbSegLeft = paSegments[iSegCurr].cbSeg;
     1672    /* Init the I/O memory context */
     1673    PDMIOMEMCTX IoMemCtx;
     1674    pdmIoMemCtxInit(&IoMemCtx, paSegments, cSegments);
    15371675
    15381676    while (cbWrite)
    … …  
    15551693            cbToWrite = RT_MIN(pEntry->cbData - OffDiff, cbWrite);
    15561694            cbWrite  -= cbToWrite;
     1695            off      += cbToWrite;
    15571696
    15581697            if (!cbWrite)
    … …  
    15841723
    15851724                    /* Update the data from the write. */
    1586                     while (cbToWrite)
    1587                     {
    1588                         size_t cbCopy = RT_MIN(cbSegLeft, cbToWrite);
    1589 
    1590                         memcpy(pEntry->pbDataReplace + OffDiff, pbSegBuf, cbCopy);
    1591 
    1592                         ADVANCE_SEGMENT_BUFFER(cbCopy);
    1593 
    1594                         cbToWrite-= cbCopy;
    1595                         off      += cbCopy;
    1596                         OffDiff  += cbCopy;
    1597                         ASMAtomicSubS32(&pTask->cbTransferLeft, cbCopy);
    1598                     }
     1725                    pdmacFileEpCacheCopyFromIoMemCtx(&IoMemCtx,
     1726                                                     pEntry->pbDataReplace + OffDiff,
     1727                                                     cbToWrite);
     1728                    ASMAtomicSubS32(&pTask->cbTransferLeft, cbToWrite);
    15991729                    RTSemRWReleaseWrite(pEndpointCache->SemRWEntries);
    16001730                }
    … …  
    16191749                        {
    16201750                            /* The data isn't written to the file yet */
    1621                             while (cbToWrite)
    1622                             {
    1623                                 PPDMACFILETASKSEG pSeg = (PPDMACFILETASKSEG)RTMemAllocZ(sizeof(PDMACFILETASKSEG));
    1624 
    1625                                 pSeg->pTask      = pTask;
    1626                                 pSeg->uBufOffset = OffDiff;
    1627                                 pSeg->cbTransfer = RT_MIN(cbToWrite, cbSegLeft);
    1628                                 pSeg->pvBuf      = pbSegBuf;
    1629                                 pSeg->fWrite     = true;
    1630 
    1631                                 ADVANCE_SEGMENT_BUFFER(pSeg->cbTransfer);
    1632 
    1633                                 pdmacFileEpCacheEntryAddWaitingSegment(pEntry, pSeg);
    1634 
    1635                                 off       += pSeg->cbTransfer;
    1636                                 OffDiff   += pSeg->cbTransfer;
    1637                                 cbToWrite -= pSeg->cbTransfer;
    1638                             }
     1751                            pdmacFileEpCacheEntryWaitersAdd(pEntry, pTask,
     1752                                                            &IoMemCtx,
     1753                                                            OffDiff, cbToWrite,
     1754                                                            true /* fWrite */);
    16391755                            STAM_COUNTER_INC(&pEndpointCache->StatWriteDeferred);
    16401756                        }
    … …  
    16441760                            pEntry->fFlags |= PDMACFILECACHE_ENTRY_IS_DEPRECATED;
    16451761
    1646 #if 1
    16471762                            /* Copy the data before the update. */
    16481763                            if (OffDiff)
    … …  
    16541769                                       pEntry->pbData + OffDiff + cbToWrite,
    16551770                                       (pEntry->cbData - OffDiff - cbToWrite));
    1656 #else
    1657                             /* A safer method but probably slower. */
    1658                             memcpy(pEntry->pbDataReplace, pEntry->pbData, pEntry->cbData);
    1659 #endif
    16601771
    16611772                            /* Update the data from the write. */
    1662                             while (cbToWrite)
    1663                             {
    1664                                 size_t cbCopy = RT_MIN(cbSegLeft, cbToWrite);
    1665 
    1666                                 memcpy(pEntry->pbDataReplace + OffDiff, pbSegBuf, cbCopy);
    1667 
    1668                                 ADVANCE_SEGMENT_BUFFER(cbCopy);
    1669 
    1670                                 cbToWrite-= cbCopy;
    1671                                 off      += cbCopy;
    1672                                 OffDiff  += cbCopy;
    1673                                 ASMAtomicSubS32(&pTask->cbTransferLeft, cbCopy);
    1674                             }
     1773                            pdmacFileEpCacheCopyFromIoMemCtx(&IoMemCtx,
     1774                                                             pEntry->pbDataReplace + OffDiff,
     1775                                                             cbToWrite);
     1776                            ASMAtomicSubS32(&pTask->cbTransferLeft, cbToWrite);
    16751777
    16761778                            /* We are done here. A new write is initiated if the current request completes. */
    … …  
    16891791                                                                          0))
    16901792                        {
    1691                             while (cbToWrite)
    1692                             {
    1693                                 PPDMACFILETASKSEG pSeg = (PPDMACFILETASKSEG)RTMemAllocZ(sizeof(PDMACFILETASKSEG));
    1694 
    1695                                 pSeg->pTask      = pTask;
    1696                                 pSeg->uBufOffset = OffDiff;
    1697                                 pSeg->cbTransfer = RT_MIN(cbToWrite, cbSegLeft);
    1698                                 pSeg->pvBuf      = pbSegBuf;
    1699                                 pSeg->fWrite     = true;
    1700 
    1701                                 ADVANCE_SEGMENT_BUFFER(pSeg->cbTransfer);
    1702 
    1703                                 pdmacFileEpCacheEntryAddWaitingSegment(pEntry, pSeg);
    1704 
    1705                                 off       += pSeg->cbTransfer;
    1706                                 OffDiff   += pSeg->cbTransfer;
    1707                                 cbToWrite -= pSeg->cbTransfer;
    1708                             }
     1793                            pdmacFileEpCacheEntryWaitersAdd(pEntry, pTask,
     1794                                                            &IoMemCtx,
     1795                                                            OffDiff, cbToWrite,
     1796                                                            true /* fWrite */);
    17091797                            STAM_COUNTER_INC(&pEndpointCache->StatWriteDeferred);
    17101798                            RTSemRWReleaseWrite(pEndpointCache->SemRWEntries);
    … …  
    17131801                        {
    17141802                            /* Write as much as we can into the entry and update the file. */
    1715                             while (cbToWrite)
    1716                             {
    1717                                 size_t cbCopy = RT_MIN(cbSegLeft, cbToWrite);
    1718 
    1719                                 memcpy(pEntry->pbData + OffDiff, pbSegBuf, cbCopy);
    1720 
    1721                                 ADVANCE_SEGMENT_BUFFER(cbCopy);
    1722 
    1723                                 cbToWrite-= cbCopy;
    1724                                 off      += cbCopy;
    1725                                 OffDiff  += cbCopy;
    1726                                 ASMAtomicSubS32(&pTask->cbTransferLeft, cbCopy);
    1727                             }
     1803                            pdmacFileEpCacheCopyFromIoMemCtx(&IoMemCtx,
     1804                                                             pEntry->pbData + OffDiff,
     1805                                                             cbToWrite);
     1806                            ASMAtomicSubS32(&pTask->cbTransferLeft, cbToWrite);
    17281807
    17291808                            pEntry->fFlags |= PDMACFILECACHE_ENTRY_IS_DIRTY;
    … …  
    17751854                AssertPtr(pEntry->pbData);
    17761855
    1777                 while (cbToWrite)
    1778                 {
    1779                     PPDMACFILETASKSEG pSeg = (PPDMACFILETASKSEG)RTMemAllocZ(sizeof(PDMACFILETASKSEG));
    1780 
    1781                     AssertMsg(off >= pEntry->Core.Key,
    1782                                 ("Overflow in calculation off=%RTfoff OffsetAligned=%RTfoff\n",
    1783                                 off, pEntry->Core.Key));
    1784 
    1785                     pSeg->pTask      = pTask;
    1786                     pSeg->uBufOffset = OffDiff;
    1787                     pSeg->cbTransfer = RT_MIN(cbToWrite, cbSegLeft);
    1788                     pSeg->pvBuf      = pbSegBuf;
    1789                     pSeg->fWrite     = true;
    1790 
    1791                     ADVANCE_SEGMENT_BUFFER(pSeg->cbTransfer);
    1792 
    1793                     pdmacFileEpCacheEntryAddWaitingSegment(pEntry, pSeg);
    1794 
    1795                     off       += pSeg->cbTransfer;
    1796                     OffDiff   += pSeg->cbTransfer;
    1797                     cbToWrite -= pSeg->cbTransfer;
    1798                 }
    1799 
     1856                pdmacFileEpCacheEntryWaitersAdd(pEntry, pTask,
     1857                                                &IoMemCtx,
     1858                                                OffDiff, cbToWrite,
     1859                                                true /* fWrite */);
    18001860                STAM_COUNTER_INC(&pEndpointCache->StatWriteDeferred);
    18011861                pdmacFileCacheReadFromEndpoint(pEntry);
    … …  
    18751935                pdmacFileEpCacheInsertEntry(pEndpointCache, pEntryNew);
    18761936
    1877                 off   += cbToWrite;
    1878                 pbBuf  = pEntryNew->pbData;
    1879 
    1880                 while (cbToWrite)
    1881                 {
    1882                     size_t cbCopy = RT_MIN(cbSegLeft, cbToWrite);
    1883 
    1884                     memcpy(pbBuf, pbSegBuf, cbCopy);
    1885 
    1886                     ADVANCE_SEGMENT_BUFFER(cbCopy);
    1887 
    1888                     cbToWrite -= cbCopy;
    1889                     pbBuf     += cbCopy;
    1890                     ASMAtomicSubS32(&pTask->cbTransferLeft, cbCopy);
    1891                 }
     1937                pdmacFileEpCacheCopyFromIoMemCtx(&IoMemCtx,
     1938                                                 pEntryNew->pbData,
     1939                                                 cbToWrite);
     1940                off += cbToWrite;
     1941                ASMAtomicSubS32(&pTask->cbTransferLeft, cbToWrite);
    18921942
    18931943                pEntryNew->fFlags |= PDMACFILECACHE_ENTRY_IS_DIRTY;
    … …  
    19031953                LogFlow(("Couldn't evict %u bytes from the cache. Remaining request will be passed through\n", cbToWrite));
    19041954
    1905                 while (cbToWrite)
    1906                 {
    1907                     PPDMACTASKFILE pIoTask = pdmacFileTaskAlloc(pEndpoint);
    1908                     AssertPtr(pIoTask);
    1909 
    1910                     pIoTask->pEndpoint       = pEndpoint;
    1911                     pIoTask->enmTransferType = PDMACTASKFILETRANSFER_WRITE;
    1912                     pIoTask->Off             = off;
    1913                     pIoTask->DataSeg.cbSeg   = RT_MIN(cbToWrite, cbSegLeft);
    1914                     pIoTask->DataSeg.pvSeg   = pbSegBuf;
    1915                     pIoTask->pvUser          = pTask;
    1916                     pIoTask->pfnCompleted    = pdmacFileEpTaskCompleted;
    1917 
    1918                     off       += pIoTask->DataSeg.cbSeg;
    1919                     cbToWrite -= pIoTask->DataSeg.cbSeg;
    1920 
    1921                     ADVANCE_SEGMENT_BUFFER(pIoTask->DataSeg.cbSeg);
    1922 
    1923                     /* Send it off to the I/O manager. */
    1924                     pdmacFileEpAddTask(pEndpoint, pIoTask);
    1925                 }
     1955                pdmacFileEpCacheRequestPassthrough(pEndpoint, pTask,
     1956                                                   &IoMemCtx, off, cbToWrite,
     1957                                                   PDMACTASKFILETRANSFER_WRITE);
    19261958            }
    19271959        }
    … …  
    19321964    if (ASMAtomicReadS32(&pTask->cbTransferLeft) == 0
    19331965        && !ASMAtomicXchgBool(&pTask->fCompleted, true))
    1934     {
    19351966        pdmR3AsyncCompletionCompleteTask(&pTask->Core, false);
    1936 
    1937         /* Complete a pending flush if all writes have completed */
    1938         if (!ASMAtomicReadU32(&pEndpointCache->cWritesOutstanding))
    1939         {
    1940             PPDMASYNCCOMPLETIONTASKFILE pTaskFlush = (PPDMASYNCCOMPLETIONTASKFILE)ASMAtomicXchgPtr((void * volatile *)&pEndpointCache->pTaskFlush, NULL);
    1941             if (pTaskFlush)
    1942                 pdmR3AsyncCompletionCompleteTask(&pTaskFlush->Core, true);
    1943         }
    1944     }
    19451967    else
    19461968        rc = VINF_AIO_TASK_PENDING;
    … …  
    19501972    return rc;
    19511973}
    1952 
    1953 #undef ADVANCE_SEGMENT_BUFFER
    19541974
    19551975int pdmacFileEpCacheFlush(PPDMASYNCCOMPLETIONENDPOINTFILE pEndpoint, PPDMASYNCCOMPLETIONTASKFILE pTask)

  • trunk/src/VBox/VMM/testcase/tstPDMAsyncCompletionStress.cpp

    r23973 r26240  
    159159PDMACTESTFILE g_aTestFiles[NR_OPEN_ENDPOINTS];
    160160
     161static void tstPDMACStressTestFileTaskCompleted(PVM pVM, void *pvUser, void *pvUser2);
     162
    161163static void tstPDMACStressTestFileVerify(PPDMACTESTFILE pTestFile, PPDMACTESTFILETASK pTestTask)
    162164{
    … …  
    351353                AssertRC(rc);
    352354
     355                if (rc != VINF_AIO_TASK_PENDING)
     356                    tstPDMACStressTestFileTaskCompleted(pVM, pTask, pTestFile);
     357
    353358                cTasksStarted++;
    354359            }
Note: See TracChangeset for help on using the changeset viewer.

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