VirtualBox

Changeset 91905 in vbox


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

Drv*,PDMDrvHlp: Added driver helpers for all queues operations, switching to PDMQUEUEHANDLE instead of PPDMQUEUE just like already done for the devices. bugref:10074

Location:
trunk
Files:
5 edited

Legend:

Unmodified
Added
Removed

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

    r91903 r91905  
    820820    DECLR3CALLBACKMEMBER(PSUPDRVSESSION, pfnGetSupDrvSession,(PPDMDRVINS pDrvIns));
    821821
     822    /** @name Exported PDM Queue Functions
     823     * @{ */
    822824    /**
    823825     * Create a queue.
    … …  
    832834     * @param   pszName             The queue base name. The instance number will be
    833835     *                              appended automatically.
    834      * @param   ppQueue             Where to store the queue handle on success.
     836     * @param   phQueue             Where to store the queue handle on success.
    835837     * @thread  The emulation thread.
    836838     */
    837839    DECLR3CALLBACKMEMBER(int, pfnQueueCreate,(PPDMDRVINS pDrvIns, uint32_t cbItem, uint32_t cItems, uint32_t cMilliesInterval,
    838                                               PFNPDMQUEUEDRV pfnCallback, const char *pszName, PPDMQUEUE *ppQueue));
     840                                              PFNPDMQUEUEDRV pfnCallback, const char *pszName, PDMQUEUEHANDLE *phQueue));
     841
     842    DECLR3CALLBACKMEMBER(PPDMQUEUEITEMCORE, pfnQueueAlloc,(PPDMDRVINS pDrvIns, PDMQUEUEHANDLE hQueue));
     843    DECLR3CALLBACKMEMBER(void, pfnQueueInsert,(PPDMDRVINS pDrvIns, PDMQUEUEHANDLE hQueue, PPDMQUEUEITEMCORE pItem));
     844    DECLR3CALLBACKMEMBER(bool, pfnQueueFlushIfNecessary,(PPDMDRVINS pDrvIns, PDMQUEUEHANDLE hQueue));
     845    /** @} */
    839846
    840847    /**
    … …  
    14471454    DECLR3CALLBACKMEMBER(void *, pfnQueryGenericUserObject,(PPDMDRVINS pDrvIns, PCRTUUID pUuid));
    14481455
     1456    DECLR3CALLBACKMEMBER(void, pfnReserved0,(PPDMDRVINS pDrvIns));
     1457    DECLR3CALLBACKMEMBER(void, pfnReserved1,(PPDMDRVINS pDrvIns));
    14491458    DECLR3CALLBACKMEMBER(void, pfnReserved2,(PPDMDRVINS pDrvIns));
    14501459    DECLR3CALLBACKMEMBER(void, pfnReserved3,(PPDMDRVINS pDrvIns));
    … …  
    14601469} PDMDRVHLPR3;
    14611470/** Current DRVHLP version number. */
    1462 #define PDM_DRVHLPR3_VERSION                    PDM_VERSION_MAKE(0xf0fb, 10, 0)
     1471#define PDM_DRVHLPR3_VERSION                    PDM_VERSION_MAKE(0xf0fb, 11, 0)
    14631472
    14641473
    … …  
    16321641 */
    16331642DECLINLINE(int) PDMDrvHlpQueueCreate(PPDMDRVINS pDrvIns, uint32_t cbItem, uint32_t cItems, uint32_t cMilliesInterval,
    1634                                         PFNPDMQUEUEDRV pfnCallback, const char *pszName, PPDMQUEUE *ppQueue)
    1635 {
    1636     return pDrvIns->pHlpR3->pfnQueueCreate(pDrvIns, cbItem, cItems, cMilliesInterval, pfnCallback, pszName, ppQueue);
     1643                                        PFNPDMQUEUEDRV pfnCallback, const char *pszName, PDMQUEUEHANDLE *phQueue)
     1644{
     1645    return pDrvIns->pHlpR3->pfnQueueCreate(pDrvIns, cbItem, cItems, cMilliesInterval, pfnCallback, pszName, phQueue);
     1646}
     1647
     1648/**
     1649 * @copydoc PDMDRVHLPR3::pfnQueueAlloc
     1650 */
     1651DECLINLINE(PPDMQUEUEITEMCORE) PDMDrvHlpQueueAlloc(PPDMDRVINS pDrvIns, PDMQUEUEHANDLE hQueue)
     1652{
     1653    return pDrvIns->CTX_SUFF(pHlp)->pfnQueueAlloc(pDrvIns, hQueue);
     1654}
     1655
     1656/**
     1657 * @copydoc PDMDRVHLPR3::pfnQueueInsert
     1658 */
     1659DECLINLINE(void) PDMDrvHlpQueueInsert(PPDMDRVINS pDrvIns, PDMQUEUEHANDLE hQueue, PPDMQUEUEITEMCORE pItem)
     1660{
     1661    pDrvIns->CTX_SUFF(pHlp)->pfnQueueInsert(pDrvIns, hQueue, pItem);
     1662}
     1663
     1664/**
     1665 * @copydoc PDMDRVHLPR3::pfnQueueFlushIfNecessary
     1666 */
     1667DECLINLINE(bool) PDMDrvHlpQueueFlushIfNecessary(PPDMDRVINS pDrvIns, PDMQUEUEHANDLE hQueue)
     1668{
     1669    return pDrvIns->CTX_SUFF(pHlp)->pfnQueueFlushIfNecessary(pDrvIns, hQueue);
    16371670}
    16381671

  • trunk/src/VBox/Devices/Input/DrvKeyboardQueue.cpp

    r91863 r91905  
    6666    PDMIKEYBOARDPORT            IPort;
    6767    /** The queue handle. */
    68     PPDMQUEUE                   pQueue;
     68    PDMQUEUEHANDLE              hQueue;
    6969    /** State of the scancode translation. */
    7070    scan_state_t                XlatState;
    … …  
    232232    if (pDrv->XlatState == SS_IDLE)
    233233    {
    234         PDRVKBDQUEUEITEM pItem = (PDRVKBDQUEUEITEM)PDMQueueAlloc(pDrv->pQueue);
     234        PDRVKBDQUEUEITEM pItem = (PDRVKBDQUEUEITEM)PDMDrvHlpQueueAlloc(pDrv->pDrvIns, pDrv->hQueue);
    235235        if (pItem)
    236236        {
    … …  
    243243                || (idUsage == (PDMIKBDPORT_KEY_UP | HID_PG_KB_BITS | 0x91)))
    244244            {
    245                 PDRVKBDQUEUEITEM pItem2 = (PDRVKBDQUEUEITEM)PDMQueueAlloc(pDrv->pQueue);
     245                PDRVKBDQUEUEITEM pItem2 = (PDRVKBDQUEUEITEM)PDMDrvHlpQueueAlloc(pDrv->pDrvIns, pDrv->hQueue);
    246246                /*
    247247                 * NB: If there's no room in the queue, we will drop the faked
    … …  
    252252                    /* Manufacture a key down event. */
    253253                    pItem2->idUsage = idUsage & ~PDMIKBDPORT_KEY_UP;
    254                     PDMQueueInsert(pDrv->pQueue, &pItem2->Core);
     254                    PDMDrvHlpQueueInsert(pDrv->pDrvIns, pDrv->hQueue, &pItem2->Core);
    255255                }
    256256            }
    257257
    258258            pItem->idUsage = idUsage;
    259             PDMQueueInsert(pDrv->pQueue, &pItem->Core);
     259            PDMDrvHlpQueueInsert(pDrv->pDrvIns, pDrv->hQueue, &pItem->Core);
    260260
    261261            return VINF_SUCCESS;
    … …  
    265265        return VERR_PDM_NO_QUEUE_ITEMS;
    266266    }
    267     else
    268         return VINF_SUCCESS;
     267    return VINF_SUCCESS;
    269268}
    270269
    … …  
    283282        return VINF_SUCCESS;
    284283
    285     PDRVKBDQUEUEITEM pItem = (PDRVKBDQUEUEITEM)PDMQueueAlloc(pDrv->pQueue);
     284    PDRVKBDQUEUEITEM pItem = (PDRVKBDQUEUEITEM)PDMDrvHlpQueueAlloc(pDrv->pDrvIns, pDrv->hQueue);
    286285    if (pItem)
    287286    {
    288287        pItem->idUsage = idUsage;
    289         PDMQueueInsert(pDrv->pQueue, &pItem->Core);
     288        PDMDrvHlpQueueInsert(pDrv->pDrvIns, pDrv->hQueue, &pItem->Core);
    290289
    291290        return VINF_SUCCESS;
    292291    }
    293     if (!pDrv->fSuspended)
    294         AssertMsgFailed(("drvKbdQueuePutEventHid: Queue is full!!!!\n"));
     292    AssertMsg(pDrv->fSuspended, ("drvKbdQueuePutEventHid: Queue is full!!!!\n"));
    295293    return VERR_PDM_NO_QUEUE_ITEMS;
    296294}
    … …  
    311309        return VINF_SUCCESS;
    312310
    313     PDRVKBDQUEUEITEM pItem = (PDRVKBDQUEUEITEM)PDMQueueAlloc(pDrv->pQueue);
     311    PDRVKBDQUEUEITEM pItem = (PDRVKBDQUEUEITEM)PDMDrvHlpQueueAlloc(pDrv->pDrvIns, pDrv->hQueue);
    314312    if (pItem)
    315313    {
    … …  
    319317         */
    320318        pItem->idUsage = PDMIKBDPORT_RELEASE_KEYS | HID_PG_KB_BITS;
    321         PDMQueueInsert(pDrv->pQueue, &pItem->Core);
     319        PDMDrvHlpQueueInsert(pDrv->pDrvIns, pDrv->hQueue, &pItem->Core);
    322320
    323321        return VINF_SUCCESS;
    324322    }
    325     if (!pDrv->fSuspended)
    326         AssertMsgFailed(("drvKbdQueueReleaseKeys: Queue is full!!!!\n"));
     323    AssertMsg(pDrv->fSuspended, ("drvKbdQueueReleaseKeys: Queue is full!!!!\n"));
    327324    return VERR_PDM_NO_QUEUE_ITEMS;
    328325}
    … …  
    369366    PDRVKBDQUEUE pDrv = PPDMIKEYBOARDCONNECTOR_2_DRVKBDQUEUE(pInterface);
    370367
    371     AssertPtr(pDrv->pQueue);
    372     PDMQueueFlushIfNecessary(pDrv->pQueue);
     368    PDMDrvHlpQueueFlushIfNecessary(pDrv->pDrvIns, pDrv->hQueue);
    373369}
    374370
    … …  
    483479     * Init basic data members and interfaces.
    484480     */
     481    pDrv->pDrvIns                           = pDrvIns;
    485482    pDrv->fInactive                         = true;
    486483    pDrv->fSuspended                        = false;
    … …  
    501498     */
    502499    pDrv->pUpPort = PDMIBASE_QUERY_INTERFACE(pDrvIns->pUpBase, PDMIKEYBOARDPORT);
    503     if (!pDrv->pUpPort)
    504     {
    505         AssertMsgFailed(("Configuration error: No keyboard port interface above!\n"));
    506         return VERR_PDM_MISSING_INTERFACE_ABOVE;
    507     }
     500    AssertMsgReturn(pDrv->pUpPort, ("Configuration error: No keyboard port interface above!\n"), VERR_PDM_MISSING_INTERFACE_ABOVE);
    508501
    509502    /*
    … …  
    512505    PPDMIBASE pDownBase;
    513506    int rc = PDMDrvHlpAttach(pDrvIns, fFlags, &pDownBase);
    514     if (RT_FAILURE(rc))
    515     {
    516         AssertMsgFailed(("Failed to attach driver below us! rc=%Rra\n", rc));
    517         return rc;
    518     }
     507    AssertMsgRCReturn(rc, ("Failed to attach driver below us! rc=%Rra\n", rc), rc);
     508
    519509    pDrv->pDownConnector = PDMIBASE_QUERY_INTERFACE(pDownBase, PDMIKEYBOARDCONNECTOR);
    520     if (!pDrv->pDownConnector)
    521     {
    522         AssertMsgFailed(("Configuration error: No keyboard connector interface below!\n"));
    523         return VERR_PDM_MISSING_INTERFACE_BELOW;
    524     }
     510    AssertMsgReturn(pDrv->pDownConnector, ("Configuration error: No keyboard connector interface below!\n"),
     511                    VERR_PDM_MISSING_INTERFACE_BELOW);
    525512
    526513    /*
    … …  
    531518    if (rc == VERR_CFGM_VALUE_NOT_FOUND)
    532519        cMilliesInterval = 0;
    533     else if (RT_FAILURE(rc))
    534     {
    535         AssertMsgFailed(("Configuration error: 32-bit \"Interval\" -> rc=%Rrc\n", rc));
    536         return rc;
    537     }
     520    else
     521        AssertMsgRCReturn(rc, ("Configuration error: 32-bit \"Interval\" -> rc=%Rrc\n", rc), rc);
    538522
    539523    uint32_t cItems = 0;
    … …  
    541525    if (rc == VERR_CFGM_VALUE_NOT_FOUND)
    542526        cItems = 128;
    543     else if (RT_FAILURE(rc))
    544     {
    545         AssertMsgFailed(("Configuration error: 32-bit \"QueueSize\" -> rc=%Rrc\n", rc));
    546         return rc;
    547     }
     527    else
     528        AssertMsgRCReturn(rc, ("Configuration error: 32-bit \"QueueSize\" -> rc=%Rrc\n", rc), rc);
    548529
    549530    rc = PDMDrvHlpQueueCreate(pDrvIns, sizeof(DRVKBDQUEUEITEM), cItems, cMilliesInterval,
    550                               drvKbdQueueConsumer, "Keyboard", &pDrv->pQueue);
    551     if (RT_FAILURE(rc))
    552     {
    553         AssertMsgFailed(("Failed to create driver: cItems=%d cMilliesInterval=%d rc=%Rrc\n", cItems, cMilliesInterval, rc));
    554         return rc;
    555     }
     531                              drvKbdQueueConsumer, "Keyboard", &pDrv->hQueue);
     532    AssertMsgRCReturn(rc, ("Failed to create driver: cItems=%d cMilliesInterval=%d rc=%Rrc\n", cItems, cMilliesInterval, rc), rc);
    556533
    557534    return VINF_SUCCESS;

  • trunk/src/VBox/Devices/Input/DrvMouseQueue.cpp

    r91863 r91905  
    5151    PDMIMOUSEPORT               IPort;
    5252    /** The queue handle. */
    53     PPDMQUEUE                   pQueue;
     53    PDMQUEUEHANDLE              hQueue;
    5454    /** Discard input when this flag is set.
    5555     * We only accept input when the VM is running. */
    … …  
    129129        return VINF_SUCCESS;
    130130
    131     PDRVMOUSEQUEUEITEM pItem = (PDRVMOUSEQUEUEITEM)PDMQueueAlloc(pDrv->pQueue);
     131    PDRVMOUSEQUEUEITEM pItem = (PDRVMOUSEQUEUEITEM)PDMDrvHlpQueueAlloc(pDrv->pDrvIns, pDrv->hQueue);
    132132    if (pItem)
    133133    {
    … …  
    139139        pItem->u.Relative.dw       = dw;
    140140        pItem->u.Relative.fButtons = fButtons;
    141         PDMQueueInsert(pDrv->pQueue, &pItem->Core);
     141        PDMDrvHlpQueueInsert(pDrv->pDrvIns, pDrv->hQueue, &pItem->Core);
    142142        return VINF_SUCCESS;
    143143    }
    … …  
    157157        return VINF_SUCCESS;
    158158
    159     PDRVMOUSEQUEUEITEM pItem = (PDRVMOUSEQUEUEITEM)PDMQueueAlloc(pDrv->pQueue);
     159    PDRVMOUSEQUEUEITEM pItem = (PDRVMOUSEQUEUEITEM)PDMDrvHlpQueueAlloc(pDrv->pDrvIns, pDrv->hQueue);
    160160    if (pItem)
    161161    {
    … …  
    167167        pItem->u.Absolute.dw       = dw;
    168168        pItem->u.Absolute.fButtons = fButtons;
    169         PDMQueueInsert(pDrv->pQueue, &pItem->Core);
     169        PDMDrvHlpQueueInsert(pDrv->pDrvIns, pDrv->hQueue, &pItem->Core);
    170170        return VINF_SUCCESS;
    171171    }
    … …  
    213213    PDRVMOUSEQUEUE pDrv = PPDMIMOUSECONNECTOR_2_DRVMOUSEQUEUE(pInterface);
    214214
    215     AssertPtr(pDrv->pQueue);
    216     PDMQueueFlushIfNecessary(pDrv->pQueue);
     215    PDMDrvHlpQueueFlushIfNecessary(pDrv->pDrvIns, pDrv->hQueue);
    217216}
    218217
    … …  
    342341     * Init basic data members and interfaces.
    343342     */
     343    pDrv->pDrvIns                           = pDrvIns;
    344344    pDrv->fInactive                         = true;
    345345    /* IBase. */
    … …  
    357357     */
    358358    pDrv->pUpPort = PDMIBASE_QUERY_INTERFACE(pDrvIns->pUpBase, PDMIMOUSEPORT);
    359     if (!pDrv->pUpPort)
    360     {
    361         AssertMsgFailed(("Configuration error: No mouse port interface above!\n"));
    362         return VERR_PDM_MISSING_INTERFACE_ABOVE;
    363     }
     359    AssertMsgReturn(pDrv->pUpPort, ("Configuration error: No mouse port interface above!\n"), VERR_PDM_MISSING_INTERFACE_ABOVE);
    364360
    365361    /*
    … …  
    368364    PPDMIBASE pDownBase;
    369365    int rc = PDMDrvHlpAttach(pDrvIns, fFlags, &pDownBase);
    370     if (RT_FAILURE(rc))
    371     {
    372         AssertMsgFailed(("Failed to attach driver below us! rc=%Rra\n", rc));
    373         return rc;
    374     }
     366    AssertMsgRCReturn(rc, ("Failed to attach driver below us! rc=%Rra\n", rc), rc);
     367
    375368    pDrv->pDownConnector = PDMIBASE_QUERY_INTERFACE(pDownBase, PDMIMOUSECONNECTOR);
    376     if (!pDrv->pDownConnector)
    377     {
    378         AssertMsgFailed(("Configuration error: No mouse connector interface below!\n"));
    379         return VERR_PDM_MISSING_INTERFACE_BELOW;
    380     }
     369    AssertMsgReturn(pDrv->pDownConnector, ("Configuration error: No mouse connector interface below!\n"),
     370                    VERR_PDM_MISSING_INTERFACE_BELOW);
    381371
    382372    /*
    … …  
    387377    if (rc == VERR_CFGM_VALUE_NOT_FOUND)
    388378        cMilliesInterval = 0;
    389     else if (RT_FAILURE(rc))
    390     {
    391         AssertMsgFailed(("Configuration error: 32-bit \"Interval\" -> rc=%Rrc\n", rc));
    392         return rc;
    393     }
     379    else
     380        AssertMsgRCReturn(rc, ("Configuration error: 32-bit \"Interval\" -> rc=%Rrc\n", rc), rc);
    394381
    395382    uint32_t cItems = 0;
    … …  
    397384    if (rc == VERR_CFGM_VALUE_NOT_FOUND)
    398385        cItems = 128;
    399     else if (RT_FAILURE(rc))
    400     {
    401         AssertMsgFailed(("Configuration error: 32-bit \"QueueSize\" -> rc=%Rrc\n", rc));
    402         return rc;
    403     }
     386    else
     387        AssertMsgRCReturn(rc, ("Configuration error: 32-bit \"QueueSize\" -> rc=%Rrc\n", rc), rc);
    404388
    405389    rc = PDMDrvHlpQueueCreate(pDrvIns, sizeof(DRVMOUSEQUEUEITEM), cItems, cMilliesInterval,
    406                               drvMouseQueueConsumer, "Mouse", &pDrv->pQueue);
    407     if (RT_FAILURE(rc))
    408     {
    409         AssertMsgFailed(("Failed to create driver: cItems=%d cMilliesInterval=%d rc=%Rrc\n", cItems, cMilliesInterval, rc));
    410         return rc;
    411     }
     390                              drvMouseQueueConsumer, "Mouse", &pDrv->hQueue);
     391    AssertMsgRCReturn(rc, ("Failed to create driver: cItems=%d cMilliesInterval=%d rc=%Rrc\n", cItems, cMilliesInterval, rc), rc);
    412392
    413393    return VINF_SUCCESS;

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

    r91875 r91905  
    147147    size_t                  cbVScsiIoReqAlloc;
    148148    /** Queue to defer unmounting to EMT. */
    149     PPDMQUEUE               pQueue;
     149    PDMQUEUEHANDLE          hQueue;
    150150} DRVSCSI, *PDRVSCSI;
    151151
    … …  
    314314    if (RT_SUCCESS(rc))
    315315    {
    316         PDRVSCSIEJECTSTATE pEjectState = (PDRVSCSIEJECTSTATE)PDMQueueAlloc(pThis->pQueue);
     316        PDRVSCSIEJECTSTATE pEjectState = (PDRVSCSIEJECTSTATE)PDMDrvHlpQueueAlloc(pThis->pDrvIns, pThis->hQueue);
    317317        if (pEjectState)
    318318        {
    319319            pEjectState->hSemEvt = hSemEvt;
    320             PDMQueueInsert(pThis->pQueue, &pEjectState->Core);
     320            PDMDrvHlpQueueInsert(pThis->pDrvIns, pThis->hQueue, &pEjectState->Core);
    321321
    322322            /* Wait for completion. */
    … …  
    10671067 * @param   pDrvIns     The driver instance.
    10681068 * @param   pItem       The item to consume. Upon return this item will be freed.
     1069 * @thread  EMT
     1070 *
     1071 * @todo    r=bird: Seems the idea here is that we have to do this on an EMT,
     1072 *          probably because of PDMIMOUNT::pfnUnmount.  I don't quite get why
     1073 *          though, as EMT doesn't exactly serialize anything anymore (SMP)...
    10691074 */
    10701075static DECLCALLBACK(bool) drvscsiR3NotifyQueueConsumer(PPDMDRVINS pDrvIns, PPDMQUEUEITEMCORE pItem)
    … …  
    10731078    PDRVSCSI pThis = PDMINS_2_DATA(pDrvIns, PDRVSCSI);
    10741079
    1075     int rc = pThis->pDrvMount->pfnUnmount(pThis->pDrvMount, false/*=fForce*/, true/*=fEject*/);
     1080    int rc = pThis->pDrvMount->pfnUnmount(pThis->pDrvMount, false /*fForce*/, true /*fEject*/);
    10761081    Assert(RT_SUCCESS(rc) || rc == VERR_PDM_MEDIA_LOCKED || rc == VERR_PDM_MEDIA_NOT_MOUNTED);
    10771082    if (RT_SUCCESS(rc))
    … …  
    15091514
    15101515    rc = PDMDrvHlpQueueCreate(pDrvIns, sizeof(DRVSCSIEJECTSTATE), 1, 0, drvscsiR3NotifyQueueConsumer,
    1511                               "SCSI-Eject", &pThis->pQueue);
     1516                              "SCSI-Eject", &pThis->hQueue);
    15121517    if (RT_FAILURE(rc))
    15131518        return PDMDrvHlpVMSetError(pDrvIns, rc, RT_SRC_POS,

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

    r91899 r91905  
    12531253
    12541254
     1255/**
     1256 * Conversion from handle to queue pointer (temporary).
     1257 */
     1258DECLINLINE(PPDMQUEUE) pdmR3DrvHlp_QueueToPtr(PPDMDRVINS pDrvIns, PDMQUEUEHANDLE hQueue)
     1259{
     1260    PDMDRV_ASSERT_DRVINS(pDrvIns);
     1261    RT_NOREF(pDrvIns);
     1262    return (PPDMQUEUE)hQueue;
     1263}
     1264
     1265
    12551266/** @interface_method_impl{PDMDRVHLPR3,pfnQueueCreate} */
    12561267static DECLCALLBACK(int) pdmR3DrvHlp_QueueCreate(PPDMDRVINS pDrvIns, uint32_t cbItem, uint32_t cItems, uint32_t cMilliesInterval,
    1257                                                  PFNPDMQUEUEDRV pfnCallback, const char *pszName, PPDMQUEUE *ppQueue)
    1258 {
    1259     PDMDRV_ASSERT_DRVINS(pDrvIns);
    1260     LogFlow(("pdmR3DrvHlp_PDMQueueCreate: caller='%s'/%d: cbItem=%d cItems=%d cMilliesInterval=%d pfnCallback=%p pszName=%p:{%s} ppQueue=%p\n",
    1261              pDrvIns->pReg->szName, pDrvIns->iInstance, cbItem, cItems, cMilliesInterval, pfnCallback, pszName, pszName, ppQueue));
     1268                                                 PFNPDMQUEUEDRV pfnCallback, const char *pszName, PDMQUEUEHANDLE *phQueue)
     1269{
     1270    PDMDRV_ASSERT_DRVINS(pDrvIns);
     1271    LogFlow(("pdmR3DrvHlp_PDMQueueCreate: caller='%s'/%d: cbItem=%d cItems=%d cMilliesInterval=%d pfnCallback=%p pszName=%p:{%s} phQueue=%p\n",
     1272             pDrvIns->pReg->szName, pDrvIns->iInstance, cbItem, cItems, cMilliesInterval, pfnCallback, pszName, pszName, phQueue));
    12621273    PVM pVM = pDrvIns->Internal.s.pVMR3;
    12631274    VM_ASSERT_EMT(pVM);
    … …  
    12691280    }
    12701281
    1271     int rc = PDMR3QueueCreateDriver(pVM, pDrvIns, cbItem, cItems, cMilliesInterval, pfnCallback, pszName, ppQueue);
    1272 
    1273     LogFlow(("pdmR3DrvHlp_PDMQueueCreate: caller='%s'/%d: returns %Rrc *ppQueue=%p\n", pDrvIns->pReg->szName, pDrvIns->iInstance, rc, *ppQueue));
    1274     return rc;
    1275 }
     1282    PPDMQUEUE pQueue = NULL;
     1283    int rc = PDMR3QueueCreateDriver(pVM, pDrvIns, cbItem, cItems, cMilliesInterval, pfnCallback, pszName, &pQueue);
     1284    *phQueue = (PDMQUEUEHANDLE)pQueue;
     1285
     1286    LogFlow(("pdmR3DrvHlp_PDMQueueCreate: caller='%s'/%d: returns %Rrc *phQueue=%p\n", pDrvIns->pReg->szName, pDrvIns->iInstance, rc, *phQueue));
     1287    return rc;
     1288}
     1289
     1290
     1291/** @interface_method_impl{PDMDRVHLPR3,pfnQueueAlloc} */
     1292static DECLCALLBACK(PPDMQUEUEITEMCORE) pdmR3DrvHlp_QueueAlloc(PPDMDRVINS pDrvIns, PDMQUEUEHANDLE hQueue)
     1293{
     1294    return PDMQueueAlloc(pdmR3DrvHlp_QueueToPtr(pDrvIns, hQueue));
     1295}
     1296
     1297
     1298/** @interface_method_impl{PDMDRVHLPR3,pfnQueueInsert} */
     1299static DECLCALLBACK(void) pdmR3DrvHlp_QueueInsert(PPDMDRVINS pDrvIns, PDMQUEUEHANDLE hQueue, PPDMQUEUEITEMCORE pItem)
     1300{
     1301    return PDMQueueInsert(pdmR3DrvHlp_QueueToPtr(pDrvIns, hQueue), pItem);
     1302}
     1303
     1304
     1305/** @interface_method_impl{PDMDRVHLPR3,pfnQueueFlushIfNecessary} */
     1306static DECLCALLBACK(bool) pdmR3DrvHlp_QueueFlushIfNecessary(PPDMDRVINS pDrvIns, PDMQUEUEHANDLE hQueue)
     1307{
     1308    return PDMQueueFlushIfNecessary(pdmR3DrvHlp_QueueToPtr(pDrvIns, hQueue));
     1309}
     1310
    12761311
    12771312
    … …  
    20322067    pdmR3DrvHlp_GetSupDrvSession,
    20332068    pdmR3DrvHlp_QueueCreate,
     2069    pdmR3DrvHlp_QueueAlloc,
     2070    pdmR3DrvHlp_QueueInsert,
     2071    pdmR3DrvHlp_QueueFlushIfNecessary,
    20342072    pdmR3DrvHlp_TMGetVirtualFreq,
    20352073    pdmR3DrvHlp_TMGetVirtualTime,
    … …  
    22242262    NULL,
    22252263    NULL,
     2264    NULL,
     2265    NULL,
    22262266    PDM_DRVHLPR3_VERSION /* u32TheEnd */
    22272267};
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