VirtualBox

Changeset 100371 in vbox for trunk/src/VBox/Devices


Ignore:
Timestamp:
Jul 5, 2023 7:47:33 AM (21 months ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
158108
Message:

Devices/VirtIO,DevVirtioNet,DevVirtioSCSI: Get rid of VIRTIO_VBUF_ON_STACK which is the default for quite some time now to make the code more straight forward, bugref:10459

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

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Devices/Network/DevVirtioNet.cpp

    r99889 r100371  
    20072007        {
    20082008            cbHdrEnqueued = cbPktHdr;
    2009 #ifdef VIRTIO_VBUF_ON_STACK
    20102009            int rc = virtioCoreR3VirtqAvailBufGet(pDevIns, &pThis->Virtio, pRxVirtq->uIdx, pVirtqBuf, true);
    2011 #else /* !VIRTIO_VBUF_ON_STACK */
    2012             virtioCoreR3VirtqBufRelease(&pThis->Virtio, pVirtqBuf);
    2013             int rc = virtioCoreR3VirtqAvailBufGet(pDevIns, &pThis->Virtio, pRxVirtq->uIdx, &pVirtqBuf, true);
    2014 #endif /* !VIRTIO_VBUF_ON_STACK */
    2015 
    20162010            AssertMsgReturn(rc == VINF_SUCCESS || rc == VERR_NOT_AVAILABLE, ("%Rrc\n", rc), rc);
    2017 
    2018 #ifdef VIRTIO_VBUF_ON_STACK
    20192011            AssertMsgReturn(rc == VINF_SUCCESS && pVirtqBuf->cbPhysReturn,
    20202012                            ("Not enough Rx buffers in queue to accomodate ethernet packet\n"),
    20212013                            VERR_INTERNAL_ERROR);
    2022 #else /* !VIRTIO_VBUF_ON_STACK */
    2023             AssertMsgReturnStmt(rc == VINF_SUCCESS && pVirtqBuf->cbPhysReturn,
    2024                                 ("Not enough Rx buffers in queue to accomodate ethernet packet\n"),
    2025                                 virtioCoreR3VirtqBufRelease(&pThis->Virtio, pVirtqBuf),
    2026                                 VERR_INTERNAL_ERROR);
    2027 #endif /* !VIRTIO_VBUF_ON_STACK */
    20282014            cbBufRemaining = pVirtqBuf->cbPhysReturn;
    20292015        }
    … …  
    20342020    AssertMsgRCReturn(rc, ("Failure updating descriptor count in pkt hdr in guest physical memory\n"), rc);
    20352021
    2036 #ifndef VIRTIO_VBUF_ON_STACK
    2037     virtioCoreR3VirtqBufRelease(&pThis->Virtio, pVirtqBuf);
    2038 #endif /* !VIRTIO_VBUF_ON_STACK */
    20392022    virtioCoreVirtqUsedRingSync(pDevIns, &pThis->Virtio, pRxVirtq->uIdx);
    20402023    Log7(("\n"));
    … …  
    20622045{
    20632046    RT_NOREF(pThisCC);
    2064 #ifdef VIRTIO_VBUF_ON_STACK
    20652047    VIRTQBUF_T VirtqBuf;
    20662048
    … …  
    20702052    PVIRTQBUF pVirtqBuf = &VirtqBuf;
    20712053    int rc = virtioCoreR3VirtqAvailBufGet(pDevIns, &pThis->Virtio, pRxVirtq->uIdx, pVirtqBuf, true);
    2072 #else /* !VIRTIO_VBUF_ON_STACK */
    2073     PVIRTQBUF pVirtqBuf;
    2074     int rc = virtioCoreR3VirtqAvailBufGet(pDevIns, &pThis->Virtio, pRxVirtq->uIdx, &pVirtqBuf, true);
    2075 #endif /* !VIRTIO_VBUF_ON_STACK */
    2076 
    20772054    AssertMsgReturn(rc == VINF_SUCCESS || rc == VERR_NOT_AVAILABLE, ("%Rrc\n", rc), rc);
    2078 
    2079 #ifdef VIRTIO_VBUF_ON_STACK
    20802055    AssertMsgReturn(rc == VINF_SUCCESS && pVirtqBuf->cbPhysReturn,
    20812056                    ("Not enough Rx buffers or capacity to accommodate ethernet packet\n"),
    20822057                    VERR_INTERNAL_ERROR);
    2083 #else /* !VIRTIO_VBUF_ON_STACK */
    2084     AssertMsgReturnStmt(rc == VINF_SUCCESS && pVirtqBuf->cbPhysReturn,
    2085                         ("Not enough Rx buffers or capacity to accommodate ethernet packet\n"),
    2086                         virtioCoreR3VirtqBufRelease(&pThis->Virtio, pVirtqBuf),
    2087                         VERR_INTERNAL_ERROR);
    2088 #endif /* !VIRTIO_VBUF_ON_STACK */
     2058
    20892059    /*
    20902060     * Try to do fast (e.g. single-buffer) copy to guest, even if MRG_RXBUF feature is enabled
    … …  
    20992069        if (rc == VINF_SUCCESS)
    21002070            rc = virtioCoreR3VirtqUsedBufPut(pDevIns, &pThis->Virtio, pRxVirtq->uIdx, cb, pvBuf, pVirtqBuf, cbPktHdr + cb /* cbEnqueue */);
    2101 #ifndef VIRTIO_VBUF_ON_STACK
    2102         virtioCoreR3VirtqBufRelease(&pThis->Virtio, pVirtqBuf);
    2103 #endif /* !VIRTIO_VBUF_ON_STACK */
    21042071        virtioCoreVirtqUsedRingSync(pDevIns, &pThis->Virtio, pRxVirtq->uIdx);
    21052072        AssertMsgReturn(rc == VINF_SUCCESS, ("%Rrc\n", rc), rc);
    … …  
    27722739
    27732740    int rc;
    2774 #ifdef VIRTIO_VBUF_ON_STACK
    27752741    VIRTQBUF_T VirtqBuf;
    27762742
    … …  
    27802746    PVIRTQBUF pVirtqBuf = &VirtqBuf;
    27812747    while ((rc = virtioCoreR3VirtqAvailBufPeek(pVirtio->pDevInsR3, pVirtio, pTxVirtq->uIdx, pVirtqBuf)) == VINF_SUCCESS)
    2782 #else /* !VIRTIO_VBUF_ON_STACK */
    2783     PVIRTQBUF pVirtqBuf = NULL;
    2784     while ((rc = virtioCoreR3VirtqAvailBufPeek(pVirtio->pDevInsR3, pVirtio, pTxVirtq->uIdx, &pVirtqBuf)) == VINF_SUCCESS)
    2785 #endif /* !VIRTIO_VBUF_ON_STACK */
    27862748    {
    27872749        Log10Func(("[%s] fetched descriptor chain from %s\n", pThis->szInst, pTxVirtq->szName));
    … …  
    27962758                        VERR_INTERNAL_ERROR);
    27972759
    2798 #ifdef VIRTIO_VBUF_ON_STACK
    27992760        VIRTIONETPKTHDR PktHdr;
    28002761        PVIRTIONETPKTHDR pPktHdr = &PktHdr;
    2801 #else /* !VIRTIO_VBUF_ON_STACK */
    2802         PVIRTIONETPKTHDR pPktHdr = (PVIRTIONETPKTHDR)RTMemAllocZ(pThis->cbPktHdr);
    2803         AssertMsgReturn(pPktHdr, ("Out of Memory\n"), VERR_NO_MEMORY);
    2804 #endif /* !VIRTIO_VBUF_ON_STACK */
    28052762
    28062763        /* Compute total frame size from guest (including virtio-net pkt hdr) */
    … …  
    28772834                Log4Func(("Failed to allocate S/G buffer: frame size=%u rc=%Rrc\n", uFrameSize, rc));
    28782835                /* Stop trying to fetch TX descriptors until we get more bandwidth. */
    2879 #ifndef VIRTIO_VBUF_ON_STACK
    2880                 virtioCoreR3VirtqBufRelease(pVirtio, pVirtqBuf);
    2881 #endif /* !VIRTIO_VBUF_ON_STACK */
    28822836                break;
    28832837            }
    … …  
    28902844        }
    28912845
    2892 #ifndef VIRTIO_VBUF_ON_STACK
    2893         virtioCoreR3VirtqBufRelease(pVirtio, pVirtqBuf);
    2894         pVirtqBuf = NULL;
    2895 #endif /* !VIRTIO_VBUF_ON_STACK */
    28962846        /* Before we break the loop we need to check if the queue is empty,
    28972847         * re-enable notifications, and then re-check again to avoid missing
    … …  
    31823132        {
    31833133            Log10Func(("[%s] %s worker woken. Fetching desc chain\n", pThis->szInst, pVirtq->szName));
    3184 #ifdef VIRTIO_VBUF_ON_STACK
    31853134            VIRTQBUF_T VirtqBuf;
    31863135            PVIRTQBUF pVirtqBuf = &VirtqBuf;
    31873136            int rc = virtioCoreR3VirtqAvailBufGet(pDevIns, &pThis->Virtio, pVirtq->uIdx, pVirtqBuf, true);
    3188 #else /* !VIRTIO_VBUF_ON_STACK */
    3189             PVIRTQBUF pVirtqBuf = NULL;
    3190             int rc = virtioCoreR3VirtqAvailBufGet(pDevIns, &pThis->Virtio, pVirtq->uIdx, &pVirtqBuf, true);
    3191 #endif /* !VIRTIO_VBUF_ON_STACK */
    31923137            if (rc == VERR_NOT_AVAILABLE)
    31933138            {
    … …  
    31963141            }
    31973142            virtioNetR3Ctrl(pDevIns, pThis, pThisCC, pVirtqBuf);
    3198 #ifndef VIRTIO_VBUF_ON_STACK
    3199             virtioCoreR3VirtqBufRelease(&pThis->Virtio, pVirtqBuf);
    3200 #endif /* !VIRTIO_VBUF_ON_STACK */
    32013143        }
    32023144        else /* Must be Tx queue */

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

    r99739 r100371  
    16481648             for (int i = 0; i < pWorkerR3->cRedoDescs; i++)
    16491649             {
    1650 #ifdef VIRTIO_VBUF_ON_STACK
    16511650                PVIRTQBUF pVirtqBuf = virtioCoreR3VirtqBufAlloc();
    16521651                if (!pVirtqBuf)
    … …  
    16571656                int rc = virtioCoreR3VirtqAvailBufGet(pDevIns, &pThis->Virtio, uVirtqNbr,
    16581657                                                    pWorkerR3->auRedoDescs[i], pVirtqBuf);
    1659 #else /* !VIRTIO_VBUF_ON_STACK */
    1660                   PVIRTQBUF pVirtqBuf;
    1661                   int rc = virtioCoreR3VirtqAvailBufGet(pDevIns, &pThis->Virtio, uVirtqNbr,
    1662                                                         pWorkerR3->auRedoDescs[i], &pVirtqBuf);
    1663 #endif /* !VIRTIO_VBUF_ON_STACK */
    1664                   if (RT_FAILURE(rc))
    1665                       LogRel(("Error fetching desc chain to redo, %Rrc", rc));
    1666 
    1667                   rc = virtioScsiR3ReqSubmit(pDevIns, pThis, pThisCC, uVirtqNbr, pVirtqBuf);
    1668                   if (RT_FAILURE(rc))
    1669                       LogRel(("Error submitting req packet, resetting %Rrc", rc));
     1658                if (RT_FAILURE(rc))
     1659                    LogRel(("Error fetching desc chain to redo, %Rrc", rc));
     1660
     1661                rc = virtioScsiR3ReqSubmit(pDevIns, pThis, pThisCC, uVirtqNbr, pVirtqBuf);
     1662                if (RT_FAILURE(rc))
     1663                    LogRel(("Error submitting req packet, resetting %Rrc", rc));
    16701664
    16711665                  virtioCoreR3VirtqBufRelease(&pThis->Virtio, pVirtqBuf);
    … …  
    16741668
    16751669             Log6Func(("fetching next descriptor chain from %s\n", VIRTQNAME(uVirtqNbr)));
    1676 #ifdef VIRTIO_VBUF_ON_STACK
    16771670            PVIRTQBUF pVirtqBuf = virtioCoreR3VirtqBufAlloc();
    16781671            if (!pVirtqBuf)
    … …  
    16801673            else
    16811674            {
    1682              int rc = virtioCoreR3VirtqAvailBufGet(pDevIns, &pThis->Virtio, uVirtqNbr, pVirtqBuf, true);
    1683 #else /* !VIRTIO_VBUF_ON_STACK */
    1684              PVIRTQBUF pVirtqBuf = NULL;
    1685              int rc = virtioCoreR3VirtqAvailBufGet(pDevIns, &pThis->Virtio, uVirtqNbr, &pVirtqBuf, true);
    1686 #endif /* !VIRTIO_VBUF_ON_STACK */
    1687              if (rc == VERR_NOT_AVAILABLE)
    1688              {
    1689                  Log6Func(("Nothing found in %s\n", VIRTQNAME(uVirtqNbr)));
    1690                  virtioCoreR3VirtqBufRelease(&pThis->Virtio, pVirtqBuf);
    1691                  continue;
    1692              }
    1693 
    1694              AssertRC(rc);
    1695              if (uVirtqNbr == CONTROLQ_IDX)
    1696                  virtioScsiR3Ctrl(pDevIns, pThis, pThisCC, uVirtqNbr, pVirtqBuf);
    1697              else /* request queue index */
    1698              {
    1699                  rc = virtioScsiR3ReqSubmit(pDevIns, pThis, pThisCC, uVirtqNbr, pVirtqBuf);
    1700                  if (RT_FAILURE(rc))
    1701                      LogRel(("Error submitting req packet, resetting %Rrc", rc));
    1702              }
    1703 
    1704              virtioCoreR3VirtqBufRelease(&pThis->Virtio, pVirtqBuf);
    1705 #ifdef VIRTIO_VBUF_ON_STACK
     1675                int rc = virtioCoreR3VirtqAvailBufGet(pDevIns, &pThis->Virtio, uVirtqNbr, pVirtqBuf, true);
     1676                if (rc == VERR_NOT_AVAILABLE)
     1677                {
     1678                    Log6Func(("Nothing found in %s\n", VIRTQNAME(uVirtqNbr)));
     1679                    virtioCoreR3VirtqBufRelease(&pThis->Virtio, pVirtqBuf);
     1680                    continue;
     1681                }
     1682
     1683                AssertRC(rc);
     1684                if (uVirtqNbr == CONTROLQ_IDX)
     1685                    virtioScsiR3Ctrl(pDevIns, pThis, pThisCC, uVirtqNbr, pVirtqBuf);
     1686                else /* request queue index */
     1687                {
     1688                    rc = virtioScsiR3ReqSubmit(pDevIns, pThis, pThisCC, uVirtqNbr, pVirtqBuf);
     1689                    if (RT_FAILURE(rc))
     1690                        LogRel(("Error submitting req packet, resetting %Rrc", rc));
     1691                }
     1692
     1693                virtioCoreR3VirtqBufRelease(&pThis->Virtio, pVirtqBuf);
    17061694            }
    1707 #endif /* VIRTIO_VBUF_ON_STACK */
    17081695        }
    17091696    }

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

    r99775 r100371  
    635635    uint16_t uUsedIdxShadow  = pVirtq->uUsedIdxShadow;
    636636
    637 #ifdef VIRTIO_VBUF_ON_STACK
    638637    VIRTQBUF_T VirtqBuf;
    639638    PVIRTQBUF pVirtqBuf = &VirtqBuf;
    640 #else /* !VIRTIO_VBUF_ON_STACK */
    641     PVIRTQBUF pVirtqBuf = NULL;
    642 #endif /* !VIRTIO_VBUF_ON_STACK */
    643 
    644639    bool fEmpty = IS_VIRTQ_EMPTY(pDevIns, pVirtio, pVirtq);
    645640
    … …  
    649644    if (!fEmpty)
    650645    {
    651 #ifdef VIRTIO_VBUF_ON_STACK
    652646        virtioCoreR3VirtqAvailBufPeek(pDevIns,  pVirtio, uVirtq, pVirtqBuf);
    653 #else /* !VIRTIO_VBUF_ON_STACK */
    654         virtioCoreR3VirtqAvailBufPeek(pDevIns,  pVirtio, uVirtq, &pVirtqBuf);
    655 #endif /* !VIRTIO_VBUF_ON_STACK */
    656647        cSendSegs   = pVirtqBuf->pSgPhysSend ? pVirtqBuf->pSgPhysSend->cSegs : 0;
    657648        cReturnSegs = pVirtqBuf->pSgPhysReturn ? pVirtqBuf->pSgPhysReturn->cSegs : 0;
    … …  
    704695}
    705696
    706 #ifdef VIRTIO_VBUF_ON_STACK
     697
    707698/** API Function: See header file */
    708699PVIRTQBUF virtioCoreR3VirtqBufAlloc(void)
    … …  
    714705    return pVirtqBuf;
    715706}
    716 #endif /* VIRTIO_VBUF_ON_STACK */
     707
    717708
    718709/** API Function: See header file */
    … …  
    788779
    789780/** API function: See Header file  */
    790 #ifdef VIRTIO_VBUF_ON_STACK
    791781int virtioCoreR3VirtqAvailBufPeek(PPDMDEVINS pDevIns, PVIRTIOCORE pVirtio, uint16_t uVirtq, PVIRTQBUF pVirtqBuf)
    792782{
    793783    return virtioCoreR3VirtqAvailBufGet(pDevIns, pVirtio, uVirtq, pVirtqBuf, false);
    794784}
    795 #else /* !VIRTIO_VBUF_ON_STACK */
    796 int virtioCoreR3VirtqAvailBufPeek(PPDMDEVINS pDevIns, PVIRTIOCORE pVirtio, uint16_t uVirtq,
    797                          PPVIRTQBUF ppVirtqBuf)
    798 {
    799     return virtioCoreR3VirtqAvailBufGet(pDevIns, pVirtio, uVirtq, ppVirtqBuf, false);
    800 }
    801 #endif /* !VIRTIO_VBUF_ON_STACK */
     785
    802786
    803787/** API function: See Header file  */
    … …  
    821805
    822806/** API Function: See header file */
    823 #ifdef VIRTIO_VBUF_ON_STACK
    824807int virtioCoreR3VirtqAvailBufGet(PPDMDEVINS pDevIns, PVIRTIOCORE pVirtio, uint16_t uVirtq,
    825808                                 uint16_t uHeadIdx, PVIRTQBUF pVirtqBuf)
    826 #else /* !VIRTIO_VBUF_ON_STACK */
    827 int virtioCoreR3VirtqAvailBufGet(PPDMDEVINS pDevIns, PVIRTIOCORE pVirtio, uint16_t uVirtq,
    828                              uint16_t uHeadIdx, PPVIRTQBUF ppVirtqBuf)
    829 #endif /* !VIRTIO_VBUF_ON_STACK */
    830 {
    831 #ifndef VIRTIO_VBUF_ON_STACK
    832     AssertReturn(ppVirtqBuf, VERR_INVALID_POINTER);
    833     *ppVirtqBuf = NULL;
    834 #endif /* !VIRTIO_VBUF_ON_STACK */
    835 
     809{
    836810    AssertMsgReturn(uVirtq < RT_ELEMENTS(pVirtio->aVirtqueues),
    837811                        ("uVirtq out of range"), VERR_INVALID_PARAMETER);
    … …  
    850824     * Allocate and initialize the descriptor chain structure.
    851825     */
    852 #ifndef VIRTIO_VBUF_ON_STACK
    853     PVIRTQBUF pVirtqBuf = (PVIRTQBUF)RTMemAllocZ(sizeof(VIRTQBUF_T));
    854     AssertReturn(pVirtqBuf, VERR_NO_MEMORY);
    855 #endif /* !VIRTIO_VBUF_ON_STACK */
    856826    pVirtqBuf->u32Magic  = VIRTQBUF_MAGIC;
    857827    pVirtqBuf->cRefs     = 1;
    858828    pVirtqBuf->uHeadIdx  = uHeadIdx;
    859829    pVirtqBuf->uVirtq    = uVirtq;
    860 #ifndef VIRTIO_VBUF_ON_STACK
    861     *ppVirtqBuf          = pVirtqBuf;
    862 #endif /* !VIRTIO_VBUF_ON_STACK */
    863830
    864831    /*
    … …  
    958925
    959926/** API function: See Header file  */
    960 #ifdef VIRTIO_VBUF_ON_STACK
    961927int virtioCoreR3VirtqAvailBufGet(PPDMDEVINS pDevIns, PVIRTIOCORE pVirtio, uint16_t uVirtq,
    962928                                 PVIRTQBUF pVirtqBuf, bool fRemove)
    963 #else /* !VIRTIO_VBUF_ON_STACK */
    964 int virtioCoreR3VirtqAvailBufGet(PPDMDEVINS pDevIns, PVIRTIOCORE pVirtio, uint16_t uVirtq,
    965                          PPVIRTQBUF ppVirtqBuf, bool fRemove)
    966 #endif /* !VIRTIO_VBUF_ON_STACK */
    967929{
    968930    Assert(uVirtq < RT_ELEMENTS(pVirtio->aVirtqueues));
    … …  
    980942        pVirtq->uAvailIdxShadow++;
    981943
    982 #ifdef VIRTIO_VBUF_ON_STACK
    983     int rc = virtioCoreR3VirtqAvailBufGet(pDevIns, pVirtio, uVirtq, uHeadIdx, pVirtqBuf);
    984 #else /* !VIRTIO_VBUF_ON_STACK */
    985     int rc = virtioCoreR3VirtqAvailBufGet(pDevIns, pVirtio, uVirtq, uHeadIdx, ppVirtqBuf);
    986 #endif /* !VIRTIO_VBUF_ON_STACK */
    987     return rc;
     944    return virtioCoreR3VirtqAvailBufGet(pDevIns, pVirtio, uVirtq, uHeadIdx, pVirtqBuf);
    988945}
    989946

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

    r99739 r100371  
    3232# pragma once
    3333#endif
    34 
    35 /* Do not allocate VIRTQBUF from the heap when possible */
    36 #define VIRTIO_VBUF_ON_STACK 1
    3734
    3835#include <iprt/ctype.h>
    … …  
    698695uint16_t virtioCoreVirtqAvailBufCount(PPDMDEVINS pDevIns, PVIRTIOCORE pVirtio, uint16_t uVirtqNbr);
    699696
    700 #ifdef VIRTIO_VBUF_ON_STACK
    701697/**
    702698 * This function is identical to virtioCoreR3VirtqAvailBufGet(), *except* it doesn't consume
    … …  
    767763int virtioCoreR3VirtqAvailBufGet(PPDMDEVINS pDevIns, PVIRTIOCORE pVirtio, uint16_t uVirtqNbr,
    768764                                  uint16_t uHeadIdx, PVIRTQBUF pVirtqBuf);
    769 #else /* !VIRTIO_VBUF_ON_STACK */
    770 /**
    771  * This function is identical to virtioCoreR3VirtqAvailBufGet(), *except* it doesn't consume
    772  * peeked buffer from avail ring of the virtq. The function *becomes* identical to the
    773  * virtioCoreR3VirtqAvailBufGet() only if virtioCoreR3VirtqAvailRingNext() is invoked to
    774  * consume buf from the queue's avail ring, followed by invocation of virtioCoreR3VirtqUsedBufPut(),
    775  * to hand host-processed buffer back to guest, which completes guest-initiated virtq buffer circuit.
    776  *
    777  * @param   pDevIns     The device instance.
    778  * @param   pVirtio     Pointer to the shared virtio state.
    779  * @param   uVirtqNbr   Virtq number
    780  * @param   ppVirtqBuf  Address to store pointer to descriptor chain that contains the
    781  *                      pre-processed transaction information pulled from the virtq.
    782  *
    783  * @returns VBox status code:
    784  * @retval  VINF_SUCCESS         Success
    785  * @retval  VERR_INVALID_STATE   VirtIO not in ready state (asserted).
    786  * @retval  VERR_NOT_AVAILABLE   If the queue is empty.
    787  */
    788 int  virtioCoreR3VirtqAvailBufPeek(PPDMDEVINS pDevIns, PVIRTIOCORE pVirtio, uint16_t uVirtqNbr,
    789                                    PPVIRTQBUF ppVirtqBuf);
    790 
    791 /**
    792  * This function fetches the next buffer (descriptor chain) from the VirtIO "avail" ring of
    793  * indicated queue, separating the buf's s/g vectors into OUT (e.g. guest-to-host)
    794  * components and and IN (host-to-guest) components.
    795  *
    796  * Caller is responsible for GCPhys to host virtual memory conversions. If the
    797  * virtq buffer being peeked at is "consumed", virtioCoreR3VirtqAvailRingNext() must
    798  * be called, and after that virtioCoreR3VirtqUsedBufPut() must be called to
    799  * complete the buffer transfer cycle with the guest.
    800  *
    801  * @param   pDevIns     The device instance.
    802  * @param   pVirtio     Pointer to the shared virtio state.
    803  * @param   uVirtqNbr   Virtq number
    804  * @param   ppVirtqBuf  Address to store pointer to descriptor chain that contains the
    805  *                      pre-processed transaction information pulled from the virtq.
    806  *                      Returned reference must be released by calling
    807  *                      virtioCoreR3VirtqBufRelease().
    808  * @param   fRemove     flags whether to remove desc chain from queue (false = peek)
    809  *
    810  * @returns VBox status code:
    811  * @retval  VINF_SUCCESS         Success
    812  * @retval  VERR_INVALID_STATE   VirtIO not in ready state (asserted).
    813  * @retval  VERR_NOT_AVAILABLE   If the queue is empty.
    814  */
    815 int  virtioCoreR3VirtqAvailBufGet(PPDMDEVINS pDevIns, PVIRTIOCORE pVirtio, uint16_t uVirtqNbr,
    816                                   PPVIRTQBUF ppVirtqBuf, bool fRemove);
    817 
    818 /**
    819  * Fetches a specific descriptor chain using avail ring of indicated queue and converts the
    820  * descriptor chain into its OUT (to device) and IN (to guest) components.
    821  *
    822  * The caller is responsible for GCPhys to host virtual memory conversions and *must*
    823  * return the virtq buffer using virtioCoreR3VirtqUsedBufPut() to complete the roundtrip
    824  * virtq transaction.
    825  * *
    826  * @param   pDevIns     The device instance.
    827  * @param   pVirtio     Pointer to the shared virtio state.
    828  * @param   uVirtqNbr   Virtq number
    829  * @param   ppVirtqBuf  Address to store pointer to descriptor chain that contains the
    830  *                      pre-processed transaction information pulled from the virtq.
    831  *                      Returned reference must be released by calling
    832  *                      virtioCoreR3VirtqBufRelease().
    833  * @param   fRemove     flags whether to remove desc chain from queue (false = peek)
    834  *
    835  * @returns VBox status code:
    836  * @retval  VINF_SUCCESS         Success
    837  * @retval  VERR_INVALID_STATE   VirtIO not in ready state (asserted).
    838  * @retval  VERR_NOT_AVAILABLE   If the queue is empty.
    839  */
    840 int virtioCoreR3VirtqAvailBufGet(PPDMDEVINS pDevIns, PVIRTIOCORE pVirtio, uint16_t uVirtqNbr,
    841                                   uint16_t uHeadIdx, PPVIRTQBUF ppVirtqBuf);
    842 #endif /* !VIRTIO_VBUF_ON_STACK */
    843765
    844766/**
    … …  
    11851107int  virtioCoreVirtqUsedRingSync(PPDMDEVINS pDevIns, PVIRTIOCORE pVirtio, uint16_t uVirtqNbr);
    11861108
    1187 #ifdef VIRTIO_VBUF_ON_STACK
    11881109/**
    11891110 * Allocates a descriptor chain object with the reference count of one. Copying the reference
    … …  
    12001121 */
    12011122PVIRTQBUF virtioCoreR3VirtqBufAlloc(void);
    1202 #endif /* VIRTIO_VBUF_ON_STACK */
    12031123
    12041124/**
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