VirtualBox

Changeset 81628 in vbox for trunk


Ignore:
Timestamp:
Nov 2, 2019 7:40:09 AM (5 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
134385
Message:

Storage/DevVirtioSCSI.cpp Fixed leaks found with Sanitizer. Worked on save/live exec code but that is untested, due host crash on crash on Linux that needs to be fixed first. See BugRef:9440, Comment #119

Location:
trunk/src/VBox/Devices
Files:
3 edited

Legend:

Unmodified
Added
Removed

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

    r81591 r81628  
    3333#include <iprt/assert.h>
    3434#include <iprt/string.h>
     35#include <VBox/sup.h>
    3536#include "../build/VBoxDD.h"
    3637#include <VBox/scsi.h>
    … …  
    7677             VIRTIOSCSI_HOST_SCSI_FEATURES_NONE
    7778
    78 /*
    79  * TEMPORARY NOTE: following parameter is set to 1 for early development. Will be increased later
    80  */
    81 //#define VIRTIOSCSI_REQ_QUEUE_CNT                    2            /**< Number of req queues exposed by dev.            */
    82 //#define VIRTIOSCSI_QUEUE_CNT                        VIRTIOSCSI_REQ_QUEUE_CNT + 2
    83 //#define VIRTIOSCSI_MAX_LUN                          256          /* < VirtIO specification, section 5.6.4             */
    84 //#define VIRTIOSCSI_MAX_COMMANDS_PER_LUN             1            /* < T.B.D. What is a good value for this?           */
    85 //#define VIRTIOSCSI_MAX_SEG_COUNT                    1024         /* < T.B.D. What is a good value for this?           */
    86 //#define VIRTIOSCSI_MAX_SECTORS_HINT                 0x10000      /* < VirtIO specification, section 5.6.4             */
    87 //#define VIRTIOSCSI_MAX_CHANNEL_HINT                 0            /* < VirtIO specification, section 5.6.4 should be 0 */
    88 //#define VIRTIOSCSI_SAVED_STATE_MINOR_VERSION        0x01         /**< SSM version #                                   */
    89 
    90 
    91 #define VIRTIOSCSI_REQ_QUEUE_CNT                    1            /**< Number of req queues exposed by dev.            */
     79#define VIRTIOSCSI_REQ_QUEUE_CNT                    1            /**< T.B.D. Consider increasing                      */
    9280#define VIRTIOSCSI_QUEUE_CNT                        VIRTIOSCSI_REQ_QUEUE_CNT + 2
    9381#define VIRTIOSCSI_MAX_LUN                          256          /* < VirtIO specification, section 5.6.4             */
    94 #define VIRTIOSCSI_MAX_COMMANDS_PER_LUN             128            /* < T.B.D. What is a good value for this?           */
    95 #define VIRTIOSCSI_MAX_SEG_COUNT                    126         /* < T.B.D. What is a good value for this?           */
     82#define VIRTIOSCSI_MAX_COMMANDS_PER_LUN             128          /* < T.B.D. What is a good value for this?           */
     83#define VIRTIOSCSI_MAX_SEG_COUNT                    126          /* < T.B.D. What is a good value for this?           */
    9684#define VIRTIOSCSI_MAX_SECTORS_HINT                 0x10000      /* < VirtIO specification, section 5.6.4             */
    9785#define VIRTIOSCSI_MAX_CHANNEL_HINT                 0            /* < VirtIO specification, section 5.6.4 should be 0 */
    … …  
    11199
    112100/**
    113  * VirtIO SCSI Host Device device-specific queue indicies
    114  *
    115  * Virtqs (and their indices) are specified for a SCSI Host Device as described in the VirtIO 1.0 specification
    116  * section 5.6. Thus there is no need to explicitly indicate the number of queues needed by this device. The number
    117  * of req queues is variable and determined by virtio_scsi_config.num_queues. See VirtIO 1.0 spec section 5.6.4
     101 * VirtIO SCSI Host Device device-specific queue indicies.
     102 * (Note: # of request queues is determined by virtio_scsi_config.num_queues. VirtIO 1.0, 5.6.4)
    118103 */
    119104#define CONTROLQ_IDX                                0            /**< Spec-defined Index of control queue             */
    … …  
    124109#define CBQUEUENAME(qIdx) RTStrNLen(QUEUENAME(qIdx), sizeof(QUEUENAME(qIdx)))
    125110
    126 
    127111#define IS_REQ_QUEUE(qIdx) (qIdx >= VIRTQ_REQ_BASE && qIdx < VIRTIOSCSI_QUEUE_CNT)
    128112
    … …  
    130114 * Resolves to boolean true if uOffset matches a field offset and size exactly,
    131115 * (or if 64-bit field, if it accesses either 32-bit part as a 32-bit access)
    132  * It is *assumed* this critereon is mandated by section 4.1.3.1 of the VirtIO 1.0 spec)
    133  * This macro can be re-written to allow unaligned access to a field (within bounds).
     116 * Assumption is this critereon is mandated by VirtIO 1.0, Section 4.1.3.1)
     117 * (Easily re-written to allow unaligned bounded access to a field).
    134118 *
    135119 * @param   member   - Member of VIRTIO_PCI_COMMON_CFG_T
    … …  
    178162            pMediaExTxDirEnumValue == PDMMEDIAEXIOREQSCSITXDIR_TO_DEVICE
    179163/**
    180  * The following struct is the VirtIO SCSI Host Device device-specific configuration described
    181  * in section 5.6.4 of the VirtIO 1.0 spec. The VBox VirtIO framework calls back to this driver
    182  * to handle MMIO accesses to the device-specific configuration parameters whenever any bytes in the
    183  * device-specific region areaccessed, since which the generic portion shouldn't know anything about
    184  * the device-specific VirtIO cfg data.
     164 * VirtIO SCSI Host Device device-specific configuration (see VirtIO 1.0, section 5.6.4)
     165 * VBox VirtIO framework issues callback to this client (device) to handle MMIO accesses
     166 * to the device-specific configuration parameters.
    185167 */
    186168typedef struct virtio_scsi_config
    … …  
    510492
    511493    /** Set if events missed due to lack of bufs avail on eventq */
    512     bool                            fEventsMissed;
     494    bool                           fEventsMissed;
    513495
    514496    /** VirtIO Host SCSI device runtime configuration parameters */
    … …  
    516498
    517499    /** True if the guest/driver and VirtIO framework are in the ready state */
    518     unsigned                        fVirtioReady;
     500    uint32_t                        fVirtioReady;
    519501
    520502    /** True if VIRTIO_SCSI_F_T10_PI was negotiated */
    521     unsigned                        fHasT10pi;
     503    uint32_t                        fHasT10pi;
    522504
    523505    /** True if VIRTIO_SCSI_F_T10_PI was negotiated */
    524     unsigned                        fHasHotplug;
     506    uint32_t                        fHasHotplug;
    525507
    526508    /** True if VIRTIO_SCSI_F_T10_PI was negotiated */
    527     unsigned                        fHasInOutBufs;
     509    uint32_t                        fHasInOutBufs;
    528510
    529511    /** True if VIRTIO_SCSI_F_T10_PI was negotiated */
    530     unsigned                        fHasLunChange;
     512    uint32_t                        fHasLunChange;
    531513
    532514    /** True if in the process of resetting */
    533     unsigned                        fResetting;
     515    uint32_t                        fResetting;
    534516
    535517    /** True if in the process of quiescing I/O */
    536     unsigned                        fQuiescing;
     518    uint32_t                        fQuiescing;
    537519
    538520} VIRTIOSCSI, *PVIRTIOSCSI;
    … …  
    591573    switch (vboxRc)
    592574    {
    593         case VIRTIOSCSI_S_OK:                           return "OK";
     575        case VIRTIOSCSI_S_OK:                           return "OK/COMPLETE";
    594576        case VIRTIOSCSI_S_OVERRUN:                      return "OVERRRUN";
    595577        case VIRTIOSCSI_S_ABORTED:                      return "ABORTED";
    … …  
    600582        case VIRTIOSCSI_S_NEXUS_FAILURE:                return "NEXUS FAILURE";
    601583        case VIRTIOSCSI_S_BUSY:                         return "BUSY";
    602         case VIRTIOSCSI_S_FAILURE:                      return "FAILURE";
    603         default:                                        return "<unknown>";
    604     }
    605 }
    606 
    607 DECLINLINE(const char *) virtioGetCtrlRespText(uint32_t vboxRc)
    608 {
    609     switch (vboxRc)
    610     {
    611         case VIRTIOSCSI_S_OK:                           return "OK/COMPLETE";
    612         case VIRTIOSCSI_S_BAD_TARGET:                   return "BAD TARGET";
    613         case VIRTIOSCSI_S_BUSY:                         return "BUSY";
    614         case VIRTIOSCSI_S_NEXUS_FAILURE:                return "NEXUS FAILURE";
    615         case VIRTIOSCSI_S_TRANSPORT_FAILURE:            return "TRANSPORT FAILURE";
    616         case VIRTIOSCSI_S_TARGET_FAILURE:               return "TARGET FAILURE";
    617584        case VIRTIOSCSI_S_FAILURE:                      return "FAILURE";
    618585        case VIRTIOSCSI_S_INCORRECT_LUN:                return "INCORRECT LUN";
    … …  
    651618
    652619typedef struct VIRTIOSCSIREQ *PVIRTIOSCSIREQ;
    653 
    654 #ifdef BOOTABLE_SUPPORT_TBD
    655 /** @callback_method_impl{FNIOMIOPORTIN} */
    656 static DECLCALLBACK(int) virtioScsiBiosIoPortRead(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT uPort, uint8_t *pbDst,
    657                                                     uint32_t *pcTransfers, unsigned cb);
    658 {
    659 }
    660 /** @callback_method_impl{FNIOMIOPORTOUT} */
    661 static DECLCALLBACK(int) virtioScsiBiosIoPortWrite(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT uPort, uint32_t u32, unsigned cb);
    662 {
    663 }
    664 /** @callback_method_impl{FNIOMIOPORTOUTSTRING} */
    665 static DECLCALLBACK(int) virtioScsiBiosIoPortWriteStr(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT uPort, const uint8_t *pbSrc,
    666                                                         uint32_t *pcTransfers, unsigned cb);
    667 {
    668 }
    669 /** @callback_method_impl{FNIOMIOPORTINSTRING} */
    670 static DECLCALLBACK(int) virtioScsiBiosIoPortReadStr(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT uPort, uint8_t *pbDst,
    671                                                        uint32_t *pcTransfers, unsigned cb);
    672 {
    673 }
    674 #endif
    675620
    676621static int virtioScsiSendEvent(PVIRTIOSCSI pThis, uint16_t uTarget, uint32_t uEventType, uint32_t uReason)
    … …  
    768713    AssertReturn(abSenseBuf, VERR_NO_MEMORY);
    769714
    770     const char *pszCtrlRespText = virtioGetCtrlRespText(pRespHdr->uResponse);
     715    const char *pszCtrlRespText = virtioGetReqRespText(pRespHdr->uResponse);
    771716    Log2Func(("   status: %s    response: %s\n",
    772717              SCSIStatusText(pRespHdr->uStatus),  pszCtrlRespText));
    … …  
    803748}
    804749
     750static void virtioSenseKeyToVirtioResp(struct REQ_RESP_HDR *respHdr, uint8_t uSenseKey)
     751{
     752    switch (uSenseKey)
     753    {
     754        case SCSI_SENSE_ABORTED_COMMAND:
     755            respHdr->uResponse = VIRTIOSCSI_S_ABORTED;
     756            break;
     757        case SCSI_SENSE_COPY_ABORTED:
     758            respHdr->uResponse = VIRTIOSCSI_S_ABORTED;
     759            break;
     760        case SCSI_SENSE_UNIT_ATTENTION:
     761            respHdr->uResponse = VIRTIOSCSI_S_TARGET_FAILURE;
     762            break;
     763        case SCSI_SENSE_HARDWARE_ERROR:
     764            respHdr->uResponse = VIRTIOSCSI_S_TARGET_FAILURE;
     765            break;
     766        case SCSI_SENSE_NOT_READY:
     767            respHdr->uResponse = VIRTIOSCSI_S_BUSY; /* e.g. re-tryable */
     768            break;
     769        default:
     770            respHdr->uResponse = VIRTIOSCSI_S_FAILURE;
     771            break;
     772    }
     773}
    805774/**
    806775 * @interface_method_impl{PDMIMEDIAEXPORT,pfnIoReqCompleteNotify}
    … …  
    847816            {
    848817                if (pReq->uStatus != SCSI_STATUS_CHECK_CONDITION)
    849                 {
    850818                    respHdr.uResponse = VIRTIOSCSI_S_OK;
    851                     break;
    852                 }
    853                 uint8_t uSenseKey = pReq->pbSense[2];
    854                 switch (uSenseKey)
    855                 {
    856                     case SCSI_SENSE_ABORTED_COMMAND:
    857                         respHdr.uResponse = VIRTIOSCSI_S_ABORTED;
    858                         break;
    859                     case SCSI_SENSE_COPY_ABORTED:
    860                         respHdr.uResponse = VIRTIOSCSI_S_ABORTED;
    861                         break;
    862                     case SCSI_SENSE_UNIT_ATTENTION:
    863                         respHdr.uResponse = VIRTIOSCSI_S_TARGET_FAILURE;
    864                         break;
    865                     case SCSI_SENSE_HARDWARE_ERROR:
    866                         respHdr.uResponse = VIRTIOSCSI_S_TARGET_FAILURE;
    867                         break;
    868                     case SCSI_SENSE_NOT_READY:
    869                         respHdr.uResponse = VIRTIOSCSI_S_BUSY; /* e.g. re-tryable */
    870                         break;
    871                     default:
    872                         respHdr.uResponse = VIRTIOSCSI_S_FAILURE;
    873                         break;
    874                 }
     819                else
     820                    virtioSenseKeyToVirtioResp(&respHdr, pReq->pbSense[2]);
    875821                break;
    876822            }
    877823            case SCSI_STATUS_CHECK_CONDITION:
    878                 {
    879                     uint8_t uSenseKey = pReq->pbSense[2];
    880                     switch (uSenseKey)
    881                     {
    882                         case SCSI_SENSE_ABORTED_COMMAND:
    883                             respHdr.uResponse = VIRTIOSCSI_S_ABORTED;
    884                             break;
    885                         case SCSI_SENSE_COPY_ABORTED:
    886                             respHdr.uResponse = VIRTIOSCSI_S_ABORTED;
    887                             break;
    888                         case SCSI_SENSE_UNIT_ATTENTION:
    889                             respHdr.uResponse = VIRTIOSCSI_S_TARGET_FAILURE;
    890                             break;
    891                         case SCSI_SENSE_HARDWARE_ERROR:
    892                             respHdr.uResponse = VIRTIOSCSI_S_TARGET_FAILURE;
    893                             break;
    894                         case SCSI_SENSE_NOT_READY:
    895                             respHdr.uResponse = VIRTIOSCSI_S_BUSY; /* e.g. re-tryable */
    896                             break;
    897                         default:
    898                             respHdr.uResponse = VIRTIOSCSI_S_FAILURE;
    899                             break;
    900                     }
    901                 }
     824                virtioSenseKeyToVirtioResp(&respHdr, pReq->pbSense[2]);
    902825                break;
    903826
    … …  
    948871
    949872        virtioScsiReqErr(pThis, pReq->qIdx, pReq->pDescChain, &respHdr, abSense);
    950         return VINF_SUCCESS;
    951873    }
    952874    else
    … …  
    11341056        respHdr.uResidual = cbDataIn + cbDataOut;
    11351057        virtioScsiReqErr(pThis, qIdx, pDescChain, &respHdr, NULL);
     1058        RTMemFree(pVirtqReq);
    11361059        return VINF_SUCCESS;
    11371060    }
    … …  
    11491072        respHdr.uResidual = cbDataOut + cbDataIn;
    11501073        virtioScsiReqErr(pThis, qIdx, pDescChain, &respHdr, abSense);
     1074        RTMemFree(pVirtqReq);
    11511075        return VINF_SUCCESS;
    11521076    }
    … …  
    11631087        respHdr.uResidual = cbDataIn + cbDataOut;
    11641088        virtioScsiReqErr(pThis, qIdx, pDescChain, &respHdr , abSense);
     1089        RTMemFree(pVirtqReq);
    11651090        return VINF_SUCCESS;
    11661091    }
    … …  
    11771102        respHdr.uResidual = cbDataIn + cbDataOut;
    11781103        virtioScsiReqErr(pThis, qIdx, pDescChain, &respHdr , abSense);
     1104        RTMemFree(pVirtqReq);
    11791105        return VINF_SUCCESS;
    11801106    }
    … …  
    11901116                                  PDMIMEDIAEX_F_SUSPEND_ON_RECOVERABLE_ERR);
    11911117
    1192     AssertMsgRCReturn(rc, ("Failed to allocate I/O request, rc=%Rrc\n", rc), rc);
     1118    if (RT_FAILURE(rc))
     1119    {
     1120        RTMemFree(pVirtqReq);
     1121        virtioScsiFreeReq(pTarget, NULL);
     1122        AssertMsgRCReturn(rc, ("Failed to allocate I/O request, rc=%Rrc\n", rc), rc);
     1123    }
    11931124
    11941125    pReq->hIoReq      = hIoReq;
    … …  
    12401171        virtioScsiReqErr(pThis, qIdx, pDescChain, &respHdr, abSense);
    12411172        virtioScsiFreeReq(pTarget, pReq);
    1242         return VINF_SUCCESS;
    1243     }
    1244 
     1173    }
     1174
     1175    RTMemFree(pVirtqReq);
    12451176    return VINF_SUCCESS;
    12461177}
    … …  
    13251256                case VIRTIOSCSI_T_TMF_QUERY_TASK:
    13261257                    uResponse = VIRTIOSCSI_S_FUNCTION_REJECTED;
    1327                     //uResponse = VIRTIOSCSI_S_FUNCTION_SUCCEEDED;
    13281258                    break;
    13291259                case VIRTIOSCSI_T_TMF_QUERY_TASK_SET:
    13301260                    uResponse = VIRTIOSCSI_S_FUNCTION_REJECTED;
    1331                     //uResponse = VIRTIOSCSI_S_FUNCTION_SUCCEEDED;
    13321261                    break;
    13331262                default:
    … …  
    14391368    }
    14401369
    1441     const char *pszCtrlRespText = virtioGetCtrlRespText(uResponse);
     1370    const char *pszCtrlRespText = virtioGetReqRespText(uResponse);
    14421371    LogFunc(("Response code: %s\n", pszCtrlRespText));
    14431372    RT_NOREF(pszCtrlRespText);
    … …  
    14871416                AssertLogRelMsgReturn(RT_SUCCESS(rc) || rc == VERR_INTERRUPTED, ("%Rrc\n", rc), rc);
    14881417                if (RT_UNLIKELY(pThread->enmState != PDMTHREADSTATE_RUNNING))
    1489                     break;
     1418                    return VINF_SUCCESS;
    14901419                Log6Func(("%s worker woken\n", QUEUENAME(qIdx)));
    14911420                ASMAtomicWriteBool(&pWorker->fNotified, false);
    … …  
    17161645static DECLCALLBACK(int) virtioScsiLiveExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSM, uint32_t uPass)
    17171646{
    1718     LogFunc(("callback"));
     1647LogFunc(("LIVE EXEC!!\n"));
    17191648    PVIRTIOSCSI pThis = PDMDEVINS_2_DATA(pDevIns, PVIRTIOSCSI);
    17201649    RT_NOREF(pThis);
    … …  
    17271656static DECLCALLBACK(int) virtioScsiLoadExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass)
    17281657{
    1729     LogFunc(("callback"));
     1658LogFunc(("LOAD EXEC!!\n"));
    17301659    PVIRTIOSCSI pThis = PDMDEVINS_2_DATA(pDevIns, PVIRTIOSCSI);
    1731     RT_NOREF(pThis);
     1660    SSMR3GetU32(pSSM, &pThis->virtioScsiConfig.uNumQueues);
     1661    SSMR3GetU32(pSSM, &pThis->virtioScsiConfig.uSegMax);
     1662    SSMR3GetU32(pSSM, &pThis->virtioScsiConfig.uMaxSectors);
     1663    SSMR3GetU32(pSSM, &pThis->virtioScsiConfig.uCmdPerLun);
     1664    SSMR3GetU32(pSSM, &pThis->virtioScsiConfig.uEventInfoSize);
     1665    SSMR3GetU32(pSSM, &pThis->virtioScsiConfig.uSenseSize);
     1666    SSMR3GetU32(pSSM, &pThis->virtioScsiConfig.uCdbSize);
     1667    SSMR3GetU16(pSSM, &pThis->virtioScsiConfig.uMaxChannel);
     1668    SSMR3GetU16(pSSM, &pThis->virtioScsiConfig.uMaxTarget);
     1669    SSMR3GetU32(pSSM, &pThis->virtioScsiConfig.uMaxLun);
     1670    SSMR3GetU32(pSSM, &pThis->uAsyncEvtsEnabled);
     1671    SSMR3GetU32(pSSM, (uint32_t *)&pThis->cActiveReqs);
     1672    SSMR3GetBool(pSSM, &pThis->fEventsMissed);
     1673    SSMR3GetU32(pSSM, &pThis->fVirtioReady);
     1674    SSMR3GetU32(pSSM, &pThis->fHasT10pi);
     1675    SSMR3GetU32(pSSM, &pThis->fHasHotplug);
     1676    SSMR3GetU32(pSSM, &pThis->fHasInOutBufs);
     1677    SSMR3GetU32(pSSM, &pThis->fHasLunChange);
     1678    SSMR3GetU32(pSSM, &pThis->fResetting);
     1679    SSMR3GetU32(pSSM, &pThis->fQuiescing);
    17321680    RT_NOREF(uPass);
    1733     RT_NOREF(pSSM);
    17341681    RT_NOREF(uVersion);
    17351682    return VINF_SSM_DONT_CALL_AGAIN;
    … …  
    17391686static DECLCALLBACK(int) virtioScsiSaveExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSM)
    17401687{
    1741     LogFunc(("callback"));
     1688LogFunc(("SAVE EXEC!!\n"));
    17421689    PVIRTIOSCSI pThis = PDMDEVINS_2_DATA(pDevIns, PVIRTIOSCSI);
    17431690
    1744     RT_NOREF(pThis);
    1745     RT_NOREF(pSSM);
     1691    SSMR3PutU32(pSSM, pThis->virtioScsiConfig.uNumQueues);
     1692    SSMR3PutU32(pSSM, pThis->virtioScsiConfig.uSegMax);
     1693    SSMR3PutU32(pSSM, pThis->virtioScsiConfig.uMaxSectors);
     1694    SSMR3PutU32(pSSM, pThis->virtioScsiConfig.uCmdPerLun);
     1695    SSMR3PutU32(pSSM, pThis->virtioScsiConfig.uEventInfoSize);
     1696    SSMR3PutU32(pSSM, pThis->virtioScsiConfig.uSenseSize);
     1697    SSMR3PutU32(pSSM, pThis->virtioScsiConfig.uCdbSize);
     1698    SSMR3PutU16(pSSM, pThis->virtioScsiConfig.uMaxChannel);
     1699    SSMR3PutU16(pSSM, pThis->virtioScsiConfig.uMaxTarget);
     1700    SSMR3PutU32(pSSM, pThis->virtioScsiConfig.uMaxLun);
     1701    SSMR3PutU32(pSSM, pThis->uAsyncEvtsEnabled);
     1702    SSMR3PutU32(pSSM, (uint32_t)pThis->cActiveReqs);
     1703    SSMR3PutBool(pSSM, pThis->fEventsMissed);
     1704    SSMR3PutU32(pSSM, pThis->fVirtioReady);
     1705    SSMR3PutU32(pSSM, pThis->fHasT10pi);
     1706    SSMR3PutU32(pSSM, pThis->fHasHotplug);
     1707    SSMR3PutU32(pSSM, pThis->fHasInOutBufs);
     1708    SSMR3PutU32(pSSM, pThis->fHasLunChange);
     1709    SSMR3PutU32(pSSM, pThis->fResetting);
     1710    SSMR3PutU32(pSSM, pThis->fQuiescing);
     1711
    17461712    return VINF_SUCCESS;
    17471713}
    … …  
    23162282    {
    23172283        rc = virtioQueueAttach(pThis->hVirtio, qIdx, QUEUENAME(qIdx));
    2318         AssertMsgReturn(rc == VINF_SUCCESS, ("Failed to attach queue %s\n", QUEUENAME(qIdx)), rc);
    23192284        pThis->fQueueAttached[qIdx] = (rc == VINF_SUCCESS);
    23202285
    … …  
    23362301         }
    23372302    }
    2338 
    2339 #ifdef BOOTABLE_SUPPORT_TBD
    2340     if (fBootable)
    2341     {
    2342         /* Register I/O port space for BIOS access. */
    2343         rc = PDMDevHlpIOPortRegister(pDevIns, VIRTIOSCSI_BIOS_IO_PORT, 4, NULL,
    2344                                      virtioScsiBiosIoPortWrite, virtioScsiBiosIoPortRead,
    2345                                      virtioScsiBiosIoPortWriteStr, virtioScsiBiosIoPortReadStr,
    2346                                      "virtio-scsi BIOS");
    2347         if (RT_FAILURE(rc))
    2348             return PDMDEV_SET_ERROR(pDevIns, rc, N_("virtio-scsi cannot register BIOS I/O handlers"));
    2349     }
    2350 #endif
    23512303
    23522304    /* Initialize per device instance. */
    … …  
    24562408    /* .uReserved0 = */             0,
    24572409    /* .szName = */                 "virtio-scsi",
     2410
    24582411#ifdef VIRTIOSCSI_GC_SUPPORT
    24592412    /* .fFlags = */                 PDM_DEVREG_FLAGS_DEFAULT_BITS | PDM_DEVREG_FLAGS_RZ

  • trunk/src/VBox/Devices/VirtIO/Virtio_1_0.cpp

    r81402 r81628  
    278278         pVirtq->uUsedIdx,  QUEUENAME(qIdx), uUsedIdx));
    279279
     280    RTMemFree((void *)pDescChain->pSgPhysSend->paSegs);
     281    RTMemFree(pDescChain->pSgPhysSend);
    280282    RTMemFree((void *)pSgPhysReturn->paSegs);
    281283    RTMemFree(pSgPhysReturn);
    … …  
    314316static void virtioQueueNotified(PVIRTIOSTATE pVirtio, uint16_t qIdx, uint16_t uNotifyIdx)
    315317{
    316     Assert(uNotifyIdx == qIdx);
    317     (void)uNotifyIdx;
     318    /* See VirtIO 1.0, section 4.1.5.2 It implies that qIdx and uNotifyIdx should match.
     319     * Disregarding this notification may cause throughput to stop, however there's no way to know
     320     * which was queue was intended for wake-up if the two parameters disagree. */
     321
     322    AssertMsg(uNotifyIdx == qIdx,
     323        ("Notification param disagreement. Guest kicked virtq %d's notify addr w/non-corresponding virtq idx %d\n",
     324            qIdx, uNotifyIdx));
     325
     326//    AssertMsgReturn(uNotifyIdx == qIdx,
     327//        ("Notification param disagreement. Guest kicked virtq %d's notify addr w/non-corresponding virtq idx %d\n",
     328//            qIdx, uNotifyIdx));
     329    RT_NOREF(uNotifyIdx);
    318330
    319331    PVIRTQSTATE pVirtq = &pVirtio->virtqState[qIdx];
    320332    Log6Func(("%s\n", pVirtq->szVirtqName));
    321     (void)pVirtq;
     333    RT_NOREF(pVirtq);
    322334
    323335    /** Inform client */
    … …  
    470482    pVirtio->uISR                   = 0;
    471483
     484    virtioLowerInterrupt(pVirtio);
    472485
    473486    if (!pVirtio->fMsiSupport)  /* VirtIO 1.0, 4.1.4.3 and 4.1.5.1.2 */
    … …  
    827840        uint16_t qIdx = uNotifyBaseOffset / VIRTIO_NOTIFY_OFFSET_MULTIPLIER;
    828841        uint16_t uAvailDescIdx = *(uint16_t *)pv;
     842
    829843        virtioQueueNotified(pVirtio, qIdx, uAvailDescIdx);
    830844    }
    … …  
    12601274    rc = SSMR3PutU32(pSSM,    pVirtio->uDriverFeaturesSelect);
    12611275    rc = SSMR3PutU32(pSSM,    pVirtio->uNumQueues);
    1262     rc = SSMR3PutU32(pSSM,    pVirtio->cbDevSpecificCfg);
    1263     rc = SSMR3PutU64(pSSM,    pVirtio->uDeviceFeatures);
    12641276    rc = SSMR3PutU64(pSSM,    pVirtio->uDriverFeatures);
    1265     rc = SSMR3PutU64(pSSM,    (uint64_t)pVirtio->pDevSpecificCfg);
    1266     rc = SSMR3PutU64(pSSM,    (uint64_t)pVirtio->virtioCallbacks.pfnVirtioStatusChanged);
    1267     rc = SSMR3PutU64(pSSM,    (uint64_t)pVirtio->virtioCallbacks.pfnVirtioQueueNotified);
    1268     rc = SSMR3PutU64(pSSM,    (uint64_t)pVirtio->virtioCallbacks.pfnVirtioDevCapRead);
    1269     rc = SSMR3PutU64(pSSM,    (uint64_t)pVirtio->virtioCallbacks.pfnVirtioDevCapWrite);
    1270     rc = SSMR3PutU64(pSSM,    (uint64_t)pVirtio->virtioCallbacks.pfnSSMDevLiveExec);
    1271     rc = SSMR3PutU64(pSSM,    (uint64_t)pVirtio->virtioCallbacks.pfnSSMDevSaveExec);
    1272     rc = SSMR3PutU64(pSSM,    (uint64_t)pVirtio->virtioCallbacks.pfnSSMDevLoadExec);
    1273     rc = SSMR3PutU64(pSSM,    (uint64_t)pVirtio->virtioCallbacks.pfnSSMDevLoadDone);
    1274     rc = SSMR3PutGCPhys(pSSM, pVirtio->pGcPhysCommonCfg);
    1275     rc = SSMR3PutGCPhys(pSSM, pVirtio->pGcPhysNotifyCap);
    1276     rc = SSMR3PutGCPhys(pSSM, pVirtio->pGcPhysIsrCap);
    1277     rc = SSMR3PutGCPhys(pSSM, pVirtio->pGcPhysDeviceCap);
    1278     rc = SSMR3PutGCPhys(pSSM, pVirtio->pGcPhysPciCapBase);
    12791277
    12801278    for (uint16_t i = 0; i < pVirtio->uNumQueues; i++)
    … …  
    13161314        rc = SSMR3GetU32(pSSM,   &pVirtio->uDriverFeaturesSelect);
    13171315        rc = SSMR3GetU32(pSSM,   &pVirtio->uNumQueues);
    1318         rc = SSMR3GetU32(pSSM,   &pVirtio->cbDevSpecificCfg);
    1319         rc = SSMR3GetU64(pSSM,   &pVirtio->uDeviceFeatures);
    13201316        rc = SSMR3GetU64(pSSM,   &pVirtio->uDriverFeatures);
    1321         rc = SSMR3GetU64(pSSM,   (uint64_t *)&pVirtio->pDevSpecificCfg);
    1322         rc = SSMR3GetU64(pSSM,   (uint64_t *)&pVirtio->virtioCallbacks.pfnVirtioStatusChanged);
    1323         rc = SSMR3GetU64(pSSM,   (uint64_t *)&pVirtio->virtioCallbacks.pfnVirtioQueueNotified);
    1324         rc = SSMR3GetU64(pSSM,   (uint64_t *)&pVirtio->virtioCallbacks.pfnVirtioDevCapRead);
    1325         rc = SSMR3GetU64(pSSM,   (uint64_t *)&pVirtio->virtioCallbacks.pfnVirtioDevCapWrite);
    1326         rc = SSMR3GetU64(pSSM,   (uint64_t *)&pVirtio->virtioCallbacks.pfnSSMDevLiveExec);
    1327         rc = SSMR3GetU64(pSSM,   (uint64_t *)&pVirtio->virtioCallbacks.pfnSSMDevSaveExec);
    1328         rc = SSMR3GetU64(pSSM,   (uint64_t *)&pVirtio->virtioCallbacks.pfnSSMDevLoadExec);
    1329         rc = SSMR3GetU64(pSSM,   (uint64_t *)&pVirtio->virtioCallbacks.pfnSSMDevLoadDone);
    1330         rc = SSMR3GetGCPhys(pSSM, &pVirtio->pGcPhysCommonCfg);
    1331         rc = SSMR3GetGCPhys(pSSM, &pVirtio->pGcPhysNotifyCap);
    1332         rc = SSMR3GetGCPhys(pSSM, &pVirtio->pGcPhysIsrCap);
    1333         rc = SSMR3GetGCPhys(pSSM, &pVirtio->pGcPhysDeviceCap);
    1334         rc = SSMR3GetGCPhys(pSSM, &pVirtio->pGcPhysPciCapBase);
     1317
    13351318
    13361319        for (uint16_t i = 0; i < pVirtio->uNumQueues; i++)

  • trunk/src/VBox/Devices/VirtIO/Virtio_1_0_impl.h

    r81122 r81628  
    465465{
    466466    AssertMsg(pVirtio->uDeviceStatus & VIRTIO_STATUS_DRIVER_OK, ("Called with guest driver not ready\n"));
     467    RT_UNTRUSTED_VALIDATED_FENCE(); /* VirtIO 1.0, Section 3.2.1.4.1 */
    467468    PDMDevHlpPCIPhysWrite(pVirtio->CTX_SUFF(pDevIns),
    468469                          pVirtio->pGcPhysQueueUsed[qIdx] + RT_UOFFSETOF(VIRTQ_USED_T, fFlags),
    … …  
    473474{
    474475    uint16_t uAvailEventIdx;
     476    RT_UNTRUSTED_VALIDATED_FENCE(); /* VirtIO 1.0, Section 3.2.1.4.1 */
    475477    /** VirtIO 1.0 uAvailEventIdx (avail_event) immediately follows ring */
    476478    AssertMsg(pVirtio->uDeviceStatus & VIRTIO_STATUS_DRIVER_OK, ("Called with guest driver not ready\n"));
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