VirtualBox

Changeset 72337 in vbox


Ignore:
Timestamp:
May 25, 2018 10:00:07 AM (7 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
122793
Message:

Storage/tstVDIo: Move away from the old I/O log replay code and convert to using RTTraceLog* which the disk integrity driver uses now too

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Storage/testcase/tstVDIo.cpp

    r70777 r72337  
    3434#include <iprt/test.h>
    3535#include <iprt/system.h>
    36 
    37 #ifdef VBOX_TSTVDIO_WITH_LOG_REPLAY
    38 # include <VBox/vddbg.h>
    39 #endif
     36#include <iprt/tracelog.h>
    4037
    4138#include "VDMemDisk.h"
    … …  
    264261static DECLCALLBACK(int) vdScriptHandlerSetFileBackend(PVDSCRIPTARG paScriptArgs, void *pvUser);
    265262static DECLCALLBACK(int) vdScriptHandlerLoadPlugin(PVDSCRIPTARG paScriptArgs, void *pvUser);
    266 
    267 #ifdef VBOX_TSTVDIO_WITH_LOG_REPLAY
    268263static DECLCALLBACK(int) vdScriptHandlerIoLogReplay(PVDSCRIPTARG paScriptArgs, void *pvUser);
    269 #endif
    270264
    271265/* create action */
    … …  
    370364};
    371365
    372 #ifdef VBOX_TSTVDIO_WITH_LOG_REPLAY
    373 /* print file size action */
     366/* I/O log replay action */
    374367const VDSCRIPTTYPE g_aArgIoLogReplay[] =
    375368{
    … …  
    377370    VDSCRIPTTYPE_STRING  /* iolog */
    378371};
    379 #endif
    380372
    381373/* I/O RNG create action */
    … …  
    493485    {"close",                      VDSCRIPTTYPE_VOID, g_aArgClose,                       RT_ELEMENTS(g_aArgClose),                      vdScriptHandlerClose},
    494486    {"printfilesize",              VDSCRIPTTYPE_VOID, g_aArgPrintFileSize,               RT_ELEMENTS(g_aArgPrintFileSize),              vdScriptHandlerPrintFileSize},
    495 #ifdef VBOX_TSTVDIO_WITH_LOG_REPLAY
    496487    {"ioreplay",                   VDSCRIPTTYPE_VOID, g_aArgIoLogReplay,                 RT_ELEMENTS(g_aArgIoLogReplay),                vdScriptHandlerIoLogReplay},
    497 #endif
    498488    {"merge",                      VDSCRIPTTYPE_VOID, g_aArgMerge,                       RT_ELEMENTS(g_aArgMerge),                      vdScriptHandlerMerge},
    499489    {"compact",                    VDSCRIPTTYPE_VOID, g_aArgCompact,                     RT_ELEMENTS(g_aArgCompact),                    vdScriptHandlerCompact},
    … …  
    14081398
    14091399
    1410 #ifdef VBOX_TSTVDIO_WITH_LOG_REPLAY
    14111400static DECLCALLBACK(int) vdScriptHandlerIoLogReplay(PVDSCRIPTARG paScriptArgs, void *pvUser)
    14121401{
    … …  
    14161405    const char *pcszDisk  = paScriptArgs[0].psz;
    14171406    const char *pcszIoLog = paScriptArgs[1].psz;
     1407    size_t cbBuf = 0;
     1408    void *pvBuf = NULL;
    14181409
    14191410    pDisk = tstVDIoGetDiskByName(pGlob, pcszDisk);
    14201411    if (pDisk)
    14211412    {
    1422         VDIOLOGGER hIoLogger;
    1423 
    1424         rc = VDDbgIoLogOpen(&hIoLogger, pcszIoLog);
     1413        RTTRACELOGRDR hIoLogRdr = NIL_RTTRACELOGRDR;
     1414
     1415        rc = RTTraceLogRdrCreateFromFile(&hIoLogRdr, pcszIoLog);
    14251416        if (RT_SUCCESS(rc))
    14261417        {
    1427             uint32_t fIoLogFlags;
    1428             VDIOLOGEVENT enmEvent;
    1429             void *pvBuf = NULL;
    1430             size_t cbBuf = 0;
    1431 
    1432             fIoLogFlags = VDDbgIoLogGetFlags(hIoLogger);
    1433 
    1434             /* Loop through events. */
    1435             rc = VDDbgIoLogEventTypeGetNext(hIoLogger, &enmEvent);
    1436             while (   RT_SUCCESS(rc)
    1437                    && enmEvent != VDIOLOGEVENT_END)
     1418            RTTRACELOGRDRPOLLEVT enmEvt = RTTRACELOGRDRPOLLEVT_INVALID;
     1419
     1420            rc = RTTraceLogRdrEvtPoll(hIoLogRdr, &enmEvt, RT_INDEFINITE_WAIT);
     1421            if (RT_SUCCESS(rc))
    14381422            {
    1439                 VDDBGIOLOGREQ enmReq = VDDBGIOLOGREQ_INVALID;
    1440                 uint64_t idEvent = 0;
    1441                 bool fAsync = false;
    1442                 uint64_t off = 0;
    1443                 size_t cbIo = 0;
    1444                 Assert(enmEvent == VDIOLOGEVENT_START);
    1445 
    1446                 rc = VDDbgIoLogReqTypeGetNext(hIoLogger, &enmReq);
    1447                 if (RT_FAILURE(rc))
    1448                     break;
    1449 
    1450                 switch (enmReq)
     1423                AssertMsg(enmEvt == RTTRACELOGRDRPOLLEVT_HDR_RECVD, ("Expected a header received event but got: %#x\n", enmEvt));
     1424
     1425                /* Loop through events. */
     1426                rc = RTTraceLogRdrEvtPoll(hIoLogRdr, &enmEvt, RT_INDEFINITE_WAIT);
     1427                while (RT_SUCCESS(rc))
    14511428                {
    1452                     case VDDBGIOLOGREQ_READ:
    1453                     {
    1454                         rc = VDDbgIoLogEventGetStart(hIoLogger, &idEvent, &fAsync,
    1455                                                      &off, &cbIo, 0, NULL);
    1456                         if (   RT_SUCCESS(rc)
    1457                             && cbIo > cbBuf)
    1458                         {
    1459                             pvBuf = RTMemRealloc(pvBuf, cbIo);
    1460                             if (pvBuf)
    1461                                 cbBuf = cbIo;
    1462                             else
    1463                                 rc = VERR_NO_MEMORY;
    1464                         }
    1465 
    1466                         if (   RT_SUCCESS(rc)
    1467                             && !fAsync)
    1468                             rc = VDRead(pDisk->pVD, off, pvBuf, cbIo);
    1469                         else if (RT_SUCCESS(rc))
    1470                             rc = VERR_NOT_SUPPORTED;
    1471                         break;
    1472                     }
    1473                     case VDDBGIOLOGREQ_WRITE:
    1474                     {
    1475                         rc = VDDbgIoLogEventGetStart(hIoLogger, &idEvent, &fAsync,
    1476                                                      &off, &cbIo, cbBuf, pvBuf);
    1477                         if (rc == VERR_BUFFER_OVERFLOW)
    1478                         {
    1479                             pvBuf = RTMemRealloc(pvBuf, cbIo);
    1480                             if (pvBuf)
    1481                             {
    1482                                 cbBuf = cbIo;
    1483                                 rc = VDDbgIoLogEventGetStart(hIoLogger, &idEvent, &fAsync,
    1484                                                              &off, &cbIo, cbBuf, pvBuf);
    1485                             }
    1486                             else
    1487                                 rc = VERR_NO_MEMORY;
    1488                         }
    1489 
    1490                         if (   RT_SUCCESS(rc)
    1491                             && !fAsync)
    1492                             rc = VDWrite(pDisk->pVD, off, pvBuf, cbIo);
    1493                         else if (RT_SUCCESS(rc))
    1494                             rc = VERR_NOT_SUPPORTED;
    1495                         break;
    1496                     }
    1497                     case VDDBGIOLOGREQ_FLUSH:
    1498                     {
    1499                         rc = VDDbgIoLogEventGetStart(hIoLogger, &idEvent, &fAsync,
    1500                                                      &off, &cbIo, 0, NULL);
    1501                         if (   RT_SUCCESS(rc)
    1502                             && !fAsync)
    1503                             rc = VDFlush(pDisk->pVD);
    1504                         else if (RT_SUCCESS(rc))
    1505                             rc = VERR_NOT_SUPPORTED;
    1506                         break;
    1507                     }
    1508                     case VDDBGIOLOGREQ_DISCARD:
    1509                     {
    1510                         PRTRANGE paRanges = NULL;
    1511                         unsigned cRanges = 0;
    1512 
    1513                         rc = VDDbgIoLogEventGetStartDiscard(hIoLogger, &idEvent, &fAsync,
    1514                                                             &paRanges, &cRanges);
    1515                         if (   RT_SUCCESS(rc)
    1516                             && !fAsync)
    1517                         {
    1518                             rc = VDDiscardRanges(pDisk->pVD, paRanges, cRanges);
    1519                             RTMemFree(paRanges);
    1520                         }
    1521                         else if (RT_SUCCESS(rc))
    1522                             rc = VERR_NOT_SUPPORTED;
    1523                         break;
    1524                     }
    1525                     default:
    1526                         AssertMsgFailed(("Invalid request type %d\n", enmReq));
    1527                 }
    1528 
    1529                 if (RT_SUCCESS(rc))
    1530                 {
    1531                     /* Get matching complete event. */
    1532                     rc = VDDbgIoLogEventTypeGetNext(hIoLogger, &enmEvent);
     1429                    AssertMsg(enmEvt == RTTRACELOGRDRPOLLEVT_TRACE_EVENT_RECVD,
     1430                              ("Expected a trace event received event but got: %#x\n", enmEvt));
     1431
     1432                    RTTRACELOGRDREVT hEvt = NIL_RTTRACELOGRDREVT;
     1433                    rc = RTTraceLogRdrQueryLastEvt(hIoLogRdr, &hEvt);
     1434                    AssertRC(rc);
    15331435                    if (RT_SUCCESS(rc))
    15341436                    {
    1535                         uint64_t idEvtComplete;
    1536                         int rcReq;
    1537                         uint64_t msDuration;
    1538 
    1539                         Assert(enmEvent == VDIOLOGEVENT_COMPLETE);
    1540                         rc = VDDbgIoLogEventGetComplete(hIoLogger, &idEvtComplete, &rcReq,
    1541                                                         &msDuration, &cbIo, cbBuf, pvBuf);
    1542                         Assert(RT_FAILURE(rc) || idEvtComplete == idEvent);
     1437                        PCRTTRACELOGEVTDESC pEvtDesc = RTTraceLogRdrEvtGetDesc(hEvt);
     1438
     1439                        if (!RTStrCmp(pEvtDesc->pszId, "Read"))
     1440                        {
     1441                            RTTRACELOGEVTVAL aVals[3];
     1442                            unsigned cVals = 0;
     1443                            rc = RTTraceLogRdrEvtFillVals(hEvt, 0, &aVals[0], RT_ELEMENTS(aVals), &cVals);
     1444                            if (   RT_SUCCESS(rc)
     1445                                && cVals == 3
     1446                                && aVals[0].pItemDesc->enmType == RTTRACELOGTYPE_BOOL
     1447                                && aVals[1].pItemDesc->enmType == RTTRACELOGTYPE_UINT64
     1448                                && aVals[2].pItemDesc->enmType == RTTRACELOGTYPE_SIZE)
     1449                            {
     1450                                bool     fAsync = aVals[0].u.f;
     1451                                uint64_t off    = aVals[1].u.u64;
     1452                                size_t   cbIo   = (size_t)aVals[2].u.sz;
     1453
     1454                                if (cbIo > cbBuf)
     1455                                {
     1456                                    pvBuf = RTMemRealloc(pvBuf, cbIo);
     1457                                    if (pvBuf)
     1458                                        cbBuf = cbIo;
     1459                                    else
     1460                                        rc = VERR_NO_MEMORY;
     1461                                }
     1462
     1463                                if (   RT_SUCCESS(rc)
     1464                                    && !fAsync)
     1465                                    rc = VDRead(pDisk->pVD, off, pvBuf, cbIo);
     1466                                else if (RT_SUCCESS(rc))
     1467                                    rc = VERR_NOT_SUPPORTED;
     1468                            }
     1469                        }
     1470                        else if (!RTStrCmp(pEvtDesc->pszId, "Write"))
     1471                        {
     1472                            RTTRACELOGEVTVAL aVals[3];
     1473                            unsigned cVals = 0;
     1474                            rc = RTTraceLogRdrEvtFillVals(hEvt, 0, &aVals[0], RT_ELEMENTS(aVals), &cVals);
     1475                            if (   RT_SUCCESS(rc)
     1476                                && cVals == 3
     1477                                && aVals[0].pItemDesc->enmType == RTTRACELOGTYPE_BOOL
     1478                                && aVals[1].pItemDesc->enmType == RTTRACELOGTYPE_UINT64
     1479                                && aVals[2].pItemDesc->enmType == RTTRACELOGTYPE_SIZE)
     1480                            {
     1481                                bool     fAsync = aVals[0].u.f;
     1482                                uint64_t off    = aVals[1].u.u64;
     1483                                size_t   cbIo   = (size_t)aVals[2].u.sz;
     1484
     1485                                if (cbIo > cbBuf)
     1486                                {
     1487                                    pvBuf = RTMemRealloc(pvBuf, cbIo);
     1488                                    if (pvBuf)
     1489                                        cbBuf = cbIo;
     1490                                    else
     1491                                        rc = VERR_NO_MEMORY;
     1492                                }
     1493
     1494                                if (   RT_SUCCESS(rc)
     1495                                    && !fAsync)
     1496                                    rc = VDWrite(pDisk->pVD, off, pvBuf, cbIo);
     1497                                else if (RT_SUCCESS(rc))
     1498                                    rc = VERR_NOT_SUPPORTED;
     1499                            }
     1500                        }
     1501                        else if (!RTStrCmp(pEvtDesc->pszId, "Flush"))
     1502                        {
     1503                            RTTRACELOGEVTVAL Val;
     1504                            unsigned cVals = 0;
     1505                            rc = RTTraceLogRdrEvtFillVals(hEvt, 0, &Val, 1, &cVals);
     1506                            if (   RT_SUCCESS(rc)
     1507                                && cVals == 1
     1508                                && Val.pItemDesc->enmType == RTTRACELOGTYPE_BOOL)
     1509                            {
     1510                                bool fAsync = Val.u.f;
     1511
     1512                                if (   RT_SUCCESS(rc)
     1513                                    && !fAsync)
     1514                                    rc = VDFlush(pDisk->pVD);
     1515                                else if (RT_SUCCESS(rc))
     1516                                    rc = VERR_NOT_SUPPORTED;
     1517                            }
     1518                        }
     1519                        else if (!RTStrCmp(pEvtDesc->pszId, "Discard"))
     1520                        {}
     1521                        else
     1522                            AssertMsgFailed(("Invalid event ID: %s\n", pEvtDesc->pszId));
     1523
     1524                        if (RT_SUCCESS(rc))
     1525                        {
     1526                            rc = RTTraceLogRdrEvtPoll(hIoLogRdr, &enmEvt, RT_INDEFINITE_WAIT);
     1527                            if (RT_SUCCESS(rc))
     1528                            {
     1529                                AssertMsg(enmEvt == RTTRACELOGRDRPOLLEVT_TRACE_EVENT_RECVD,
     1530                                          ("Expected a trace event received event but got: %#x\n", enmEvt));
     1531
     1532                                hEvt = NIL_RTTRACELOGRDREVT;
     1533                                rc = RTTraceLogRdrQueryLastEvt(hIoLogRdr, &hEvt);
     1534                                if (RT_SUCCESS(rc))
     1535                                {
     1536                                    pEvtDesc = RTTraceLogRdrEvtGetDesc(hEvt);
     1537                                    AssertMsg(!RTStrCmp(pEvtDesc->pszId, "Complete"),
     1538                                              ("Expected a completion event but got: %s\n", pEvtDesc->pszId));
     1539                                }
     1540                            }
     1541                        }
    15431542                    }
     1543
     1544                    if (RT_FAILURE(rc))
     1545                        break;
     1546
     1547                    rc = RTTraceLogRdrEvtPoll(hIoLogRdr, &enmEvt, RT_INDEFINITE_WAIT);
    15441548                }
    1545 
    1546                 if (RT_SUCCESS(rc))
    1547                     rc = VDDbgIoLogEventTypeGetNext(hIoLogger, &enmEvent);
    15481549            }
    15491550
    1550             VDDbgIoLogDestroy(hIoLogger);
     1551            RTTraceLogRdrDestroy(hIoLogRdr);
    15511552        }
    15521553    }
    … …  
    15541555        rc = VERR_NOT_FOUND;
    15551556
    1556     return rc;
    1557 }
    1558 #endif /* VBOX_TSTVDIO_WITH_LOG_REPLAY */
     1557    if (pvBuf)
     1558        RTMemFree(pvBuf);
     1559
     1560    return rc;
     1561}
    15591562
    15601563
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