VirtualBox

Changeset 81703 in vbox for trunk/src/VBox/Devices/Network


Ignore:
Timestamp:
Nov 6, 2019 11:51:57 AM (5 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
134465
Message:

DevVirtioNet.cpp,Virtio.cpp: Some cleanups prepping for refactoring to new PDM device style. bugref:9218

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r81696 r81703  
    396396}
    397397
    398 static DECLCALLBACK(uint32_t) vnetIoCb_GetHostFeatures(void *pvState)
    399 {
    400     RT_NOREF_PV(pvState);
     398/**
     399 * @interface_method_impl{VPCIIOCALLBACKS,pfnGetHostFeatures}
     400 */
     401static DECLCALLBACK(uint32_t) vnetIoCb_GetHostFeatures(PVPCISTATE pVPciState)
     402{
     403    RT_NOREF_PV(pVPciState);
    401404
    402405    /* We support:
    … …  
    429432}
    430433
    431 static DECLCALLBACK(uint32_t) vnetIoCb_GetHostMinimalFeatures(void *pvState)
    432 {
    433     RT_NOREF_PV(pvState);
     434/**
     435 * @interface_method_impl{VPCIIOCALLBACKS,pfnGetHostMinimalFeatures}
     436 */
     437static DECLCALLBACK(uint32_t) vnetIoCb_GetHostMinimalFeatures(PVPCISTATE pVPciState)
     438{
     439    RT_NOREF_PV(pVPciState);
    434440    return VNET_F_MAC;
    435441}
    436442
    437 static DECLCALLBACK(void) vnetIoCb_SetHostFeatures(void *pvState, uint32_t fFeatures)
    438 {
     443/**
     444 * @interface_method_impl{VPCIIOCALLBACKS,pfnSetHostFeatures}
     445 */
     446static DECLCALLBACK(void) vnetIoCb_SetHostFeatures(PVPCISTATE pVPciState, uint32_t fFeatures)
     447{
     448    PVNETSTATE pThis = RT_FROM_MEMBER(pVPciState, VNETSTATE, VPCI);
    439449    /** @todo Nothing to do here yet */
    440     PVNETSTATE pThis = (PVNETSTATE)pvState;
    441450    LogFlow(("%s vnetIoCb_SetHostFeatures: uFeatures=%x\n", INSTANCE(pThis), fFeatures));
    442451    vnetPrintFeatures(pThis, fFeatures, "The guest negotiated the following features");
    443452}
    444453
    445 static DECLCALLBACK(int) vnetIoCb_GetConfig(void *pvState, uint32_t offCfg, uint32_t cb, void *data)
    446 {
    447     PVNETSTATE pThis = (PVNETSTATE)pvState;
     454/**
     455 * @interface_method_impl{VPCIIOCALLBACKS,pfnGetConfig}
     456 */
     457static DECLCALLBACK(int) vnetIoCb_GetConfig(PVPCISTATE pVPciState, uint32_t offCfg, uint32_t cb, void *data)
     458{
     459    PVNETSTATE pThis = RT_FROM_MEMBER(pVPciState, VNETSTATE, VPCI);
    448460    if (offCfg + cb > sizeof(struct VNetPCIConfig))
    449461    {
    … …  
    455467}
    456468
    457 static DECLCALLBACK(int) vnetIoCb_SetConfig(void *pvState, uint32_t offCfg, uint32_t cb, void *data)
    458 {
    459     PVNETSTATE pThis = (PVNETSTATE)pvState;
     469/**
     470 * @interface_method_impl{VPCIIOCALLBACKS,pfnSetConfig}
     471 */
     472static DECLCALLBACK(int) vnetIoCb_SetConfig(PVPCISTATE pVPciState, uint32_t offCfg, uint32_t cb, void *data)
     473{
     474    PVNETSTATE pThis = RT_FROM_MEMBER(pVPciState, VNETSTATE, VPCI);
    460475    if (offCfg + cb > sizeof(struct VNetPCIConfig))
    461476    {
    462477        Log(("%s vnetIoCb_SetConfig: Write beyond the config structure is attempted (offCfg=%#x cb=%x).\n", INSTANCE(pThis), offCfg, cb));
    463478        if (offCfg < sizeof(struct VNetPCIConfig))
    464             memcpy((uint8_t *)&pThis->config + offCfg, data,
    465                    sizeof(struct VNetPCIConfig) - offCfg);
     479            memcpy((uint8_t *)&pThis->config + offCfg, data, sizeof(struct VNetPCIConfig) - offCfg);
    466480        return VINF_SUCCESS;
    467481    }
    … …  
    471485
    472486/**
     487 * @interface_method_impl{VPCIIOCALLBACKS,pfnReset}
     488 *
    473489 * Hardware reset. Revert all registers to initial values.
    474  *
    475  * @param   pThis      The device state structure.
    476  */
    477 static DECLCALLBACK(int) vnetIoCb_Reset(void *pvState)
    478 {
    479     PVNETSTATE pThis = (PVNETSTATE)pvState;
     490 */
     491static DECLCALLBACK(int) vnetIoCb_Reset(PVPCISTATE pVPciState)
     492{
     493    PVNETSTATE pThis = RT_FROM_MEMBER(pVPciState, VNETSTATE, VPCI);
    480494    Log(("%s Reset triggered\n", INSTANCE(pThis)));
    481495
    … …  
    610624
    611625/**
     626 * @interface_method_impl{VPCIIOCALLBACKS,pfnReady}
     627 *
    612628 * This function is called when the driver becomes ready.
    613  *
    614  * @param   pThis      The device state structure.
    615  */
    616 static DECLCALLBACK(void) vnetIoCb_Ready(void *pvState)
    617 {
    618     PVNETSTATE pThis = (PVNETSTATE)pvState;
     629 */
     630static DECLCALLBACK(void) vnetIoCb_Ready(PVPCISTATE pVPciState)
     631{
     632    PVNETSTATE pThis = RT_FROM_MEMBER(pVPciState, VNETSTATE, VPCI);
    619633    Log(("%s Driver became ready, waking up RX thread...\n", INSTANCE(pThis)));
    620634/**
    … …  
    655669PDMBOTHCBDECL(int) vnetIOPortIn(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT port, uint32_t *pu32, unsigned cb)
    656670{
    657     return vpciIOPortIn(pDevIns, pvUser, port, pu32, cb, &g_IOCallbacks);
     671    PVNETSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PVNETSTATE);
     672    RT_NOREF(pvUser);
     673    return vpciIOPortIn(pDevIns, &pThis->VPCI, port, pu32, cb, &g_IOCallbacks);
    658674}
    659675
    … …  
    664680PDMBOTHCBDECL(int) vnetIOPortOut(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT port, uint32_t u32, unsigned cb)
    665681{
    666     return vpciIOPortOut(pDevIns, pvUser, port, u32, cb, &g_IOCallbacks);
     682    PVNETSTATE pThis = PDMDEVINS_2_DATA(pDevIns, PVNETSTATE);
     683    RT_NOREF(pvUser);
     684    return vpciIOPortOut(pDevIns, &pThis->VPCI, port, u32, cb, &g_IOCallbacks);
    667685}
    668686
    … …  
    11181136}
    11191137
    1120 static DECLCALLBACK(void) vnetR3QueueReceive(void *pvState, PVQUEUE pQueue)
    1121 {
    1122     RT_NOREF(pQueue);
    1123     PVNETSTATE pThis = (PVNETSTATE)pvState;
     1138static DECLCALLBACK(void) vnetR3QueueReceive(PPDMDEVINS pDevIns, PVPCISTATE pVPciState, PVQUEUE pQueue)
     1139{
     1140    PVNETSTATE pThis = RT_FROM_MEMBER(pVPciState, VNETSTATE, VPCI);
     1141    RT_NOREF(pThis, pQueue);
    11241142    Log(("%s Receive buffers has been added, waking up receive thread.\n", INSTANCE(pThis)));
    1125     vnetR3WakeupReceive(pThis->VPCI.CTX_SUFF(pDevIns));
     1143    vnetR3WakeupReceive(pDevIns);
    11261144}
    11271145
    … …  
    14291447# ifdef VNET_TX_DELAY
    14301448
    1431 static DECLCALLBACK(void) vnetR3QueueTransmit(void *pvState, PVQUEUE pQueue)
    1432 {
    1433     PVNETSTATE pThis = (PVNETSTATE)pvState;
     1449static DECLCALLBACK(void) vnetR3QueueTransmit(PPDMDEVINS pDevIns, PVPCISTATE pVPciState, PVQUEUE pQueue)
     1450{
     1451    PVNETSTATE pThis = RT_FROM_MEMBER(pVPciState, VNETSTATE, VPCI);
     1452    RT_NOREF(pDevIns);
    14341453
    14351454    if (TMTimerIsActive(pThis->CTX_SUFF(pTxTimer)))
    … …  
    15131532    while (pThread->enmState == PDMTHREADSTATE_RUNNING)
    15141533    {
    1515         rc = SUPSemEventWaitNoResume(pThis->pSupDrvSession, pThis->hTxEvent, RT_INDEFINITE_WAIT);
     1534        rc = PDMDevHlpSUPSemEventWaitNoResume(pDevIns, pThis->hTxEvent, RT_INDEFINITE_WAIT);
    15161535        if (RT_UNLIKELY(pThread->enmState != PDMTHREADSTATE_RUNNING))
    15171536            break;
    … …  
    15381557 * @param   pThread     The send thread.
    15391558 */
    1540 static DECLCALLBACK(int) vnetTxThreadWakeUp(PPDMDEVINS pDevIns, PPDMTHREAD pThread)
    1541 {
    1542     RT_NOREF(pDevIns);
     1559static DECLCALLBACK(int) vnetR3TxThreadWakeUp(PPDMDEVINS pDevIns, PPDMTHREAD pThread)
     1560{
    15431561    PVNETSTATE pThis = (PVNETSTATE)pThread->pvUser;
    1544     return SUPSemEventSignal(pThis->pSupDrvSession, pThis->hTxEvent);
     1562    return PDMDevHlpSUPSemEventSignal(pDevIns, pThis->hTxEvent);
    15451563}
    15461564
    15471565static int vnetR3CreateTxThreadAndEvent(PPDMDEVINS pDevIns, PVNETSTATE pThis)
    15481566{
    1549     int rc = SUPSemEventCreate(pThis->pSupDrvSession, &pThis->hTxEvent);
     1567    int rc = PDMDevHlpSUPSemEventCreate(pDevIns, &pThis->hTxEvent);
    15501568    if (RT_FAILURE(rc))
    1551         return PDMDevHlpVMSetError(pDevIns, rc, RT_SRC_POS,
    1552                                    N_("VNET: Failed to create SUP event semaphore"));
     1569        return PDMDevHlpVMSetError(pDevIns, rc, RT_SRC_POS, N_("VNET: Failed to create SUP event semaphore"));
     1570
    15531571    rc = PDMDevHlpThreadCreate(pDevIns, &pThis->pTxThread, pThis, vnetR3TxThread,
    1554                                vnetTxThreadWakeUp, 0, RTTHREADTYPE_IO, INSTANCE(pThis));
     1572                               vnetR3TxThreadWakeUp, 0, RTTHREADTYPE_IO, INSTANCE(pThis));
    15551573    if (RT_FAILURE(rc))
    1556         return PDMDevHlpVMSetError(pDevIns, rc, RT_SRC_POS,
    1557                                    N_("VNET: Failed to create worker thread %s"), INSTANCE(pThis));
     1574        return PDMDevHlpVMSetError(pDevIns, rc, RT_SRC_POS, N_("VNET: Failed to create worker thread %s"), INSTANCE(pThis));
    15581575    return VINF_SUCCESS;
    15591576}
    15601577
    1561 static void vnetR3DestroyTxThreadAndEvent(PVNETSTATE pThis)
     1578static void vnetR3DestroyTxThreadAndEvent(PPDMDEVINS pDevIns, PVNETSTATE pThis)
    15621579{
    15631580    if (pThis->pTxThread)
    … …  
    15721589    if (pThis->hTxEvent != NIL_SUPSEMEVENT)
    15731590    {
    1574         SUPSemEventClose(pThis->pSupDrvSession, pThis->hTxEvent);
     1591        PDMDevHlpSUPSemEventClose(pDevIns, pThis->hTxEvent);
    15751592        pThis->hTxEvent = NIL_SUPSEMEVENT;
    15761593    }
    15771594}
    15781595
    1579 static DECLCALLBACK(void) vnetR3QueueTransmit(void *pvState, PVQUEUE pQueue)
    1580 {
    1581     PVNETSTATE pThis = (PVNETSTATE)pvState;
     1596static DECLCALLBACK(void) vnetR3QueueTransmit(PPDMDEVINS pDevIns, PVPCISTATE pVPciState, PVQUEUE pQueue)
     1597{
     1598    PVNETSTATE pThis = RT_FROM_MEMBER(pVPciState, VNETSTATE, VPCI);
    15821599
    15831600    Log(("vnetR3QueueTransmit: disable kicking and wake up TX thread\n"));
    15841601    vringSetNotification(&pThis->VPCI, &pQueue->VRing, false);
    1585     SUPSemEventSignal(pThis->pSupDrvSession, pThis->hTxEvent);
     1602    PDMDevHlpSUPSemEventSignal(pDevIns, pThis->hTxEvent);
    15861603}
    15871604
    … …  
    17351752
    17361753
    1737 static DECLCALLBACK(void) vnetR3QueueControl(void *pvState, PVQUEUE pQueue)
    1738 {
    1739     PVNETSTATE pThis = (PVNETSTATE)pvState;
    1740     uint8_t u8Ack;
     1754static DECLCALLBACK(void) vnetR3QueueControl(PPDMDEVINS pDevIns, PVPCISTATE pVPciState, PVQUEUE pQueue)
     1755{
     1756    PVNETSTATE pThis = RT_FROM_MEMBER(pVPciState, VNETSTATE, VPCI);
    17411757    VQUEUEELEM elem;
    17421758    while (vqueueGet(&pThis->VPCI, pQueue, &elem))
    … …  
    17561772        }
    17571773
     1774        uint8_t    bAck;
    17581775        VNETCTLHDR CtlHdr;
    1759         PDMDevHlpPhysRead(pThis->VPCI.CTX_SUFF(pDevIns),
    1760                           elem.aSegsOut[0].addr,
    1761                           &CtlHdr, sizeof(CtlHdr));
     1776        PDMDevHlpPhysRead(pDevIns, elem.aSegsOut[0].addr, &CtlHdr, sizeof(CtlHdr));
    17621777        switch (CtlHdr.u8Class)
    17631778        {
    17641779            case VNET_CTRL_CLS_RX_MODE:
    1765                 u8Ack = vnetR3ControlRx(pThis, &CtlHdr, &elem);
     1780                bAck = vnetR3ControlRx(pThis, &CtlHdr, &elem);
    17661781                break;
    17671782            case VNET_CTRL_CLS_MAC:
    1768                 u8Ack = vnetR3ControlMac(pThis, &CtlHdr, &elem);
     1783                bAck = vnetR3ControlMac(pThis, &CtlHdr, &elem);
    17691784                break;
    17701785            case VNET_CTRL_CLS_VLAN:
    1771                 u8Ack = vnetR3ControlVlan(pThis, &CtlHdr, &elem);
     1786                bAck = vnetR3ControlVlan(pThis, &CtlHdr, &elem);
    17721787                break;
    17731788            default:
    1774                 u8Ack = VNET_ERROR;
    1775         }
    1776         Log(("%s Processed control message %u, ack=%u.\n", INSTANCE(pThis), CtlHdr.u8Class, u8Ack));
    1777         PDMDevHlpPCIPhysWrite(pThis->VPCI.CTX_SUFF(pDevIns),
    1778                               elem.aSegsIn[elem.nIn - 1].addr,
    1779                               &u8Ack, sizeof(u8Ack));
    1780 
    1781         vqueuePut(&pThis->VPCI, pQueue, &elem, sizeof(u8Ack));
     1789                bAck = VNET_ERROR;
     1790        }
     1791        Log(("%s Processed control message %u, ack=%u.\n", INSTANCE(pThis), CtlHdr.u8Class, bAck));
     1792        PDMDevHlpPCIPhysWrite(pDevIns, elem.aSegsIn[elem.nIn - 1].addr, &bAck, sizeof(bAck));
     1793
     1794        vqueuePut(&pThis->VPCI, pQueue, &elem, sizeof(bAck));
    17821795        vqueueSync(&pThis->VPCI, pQueue);
    17831796    }
    … …  
    20072020    }
    20082021
    2009     vnetR3DestroyTxThreadAndEvent(pThis);
     2022    vnetR3DestroyTxThreadAndEvent(pDevIns, pThis);
     2023
    20102024    /*
    2011      * Zero some important members.
     2025     * Zero important members.
    20122026     */
    20132027    pThis->pDrvBase = NULL;
    … …  
    21242138
    21252139#ifdef VNET_TX_DELAY
    2126     LogRel(("TxTimer stats (avg/min/max): %7d usec %7d usec %7d usec\n",
    2127             pThis->u32AvgDiff, pThis->u32MinDiff, pThis->u32MaxDiff));
    2128 #endif /* VNET_TX_DELAY */
     2140    LogRel(("TxTimer stats (avg/min/max): %7d usec %7d usec %7d usec\n", pThis->u32AvgDiff, pThis->u32MinDiff, pThis->u32MaxDiff));
     2141#endif
     2142
    21292143    Log(("%s Destroying instance\n", INSTANCE(pThis)));
    21302144    if (pThis->hEventMoreRxDescAvail != NIL_RTSEMEVENT)
    … …  
    21562170     */
    21572171    pThis->hEventMoreRxDescAvail = NIL_RTSEMEVENT;
     2172#ifndef VNET_TX_DELAY
     2173    pThis->hTxEvent              = NIL_SUPSEMEVENT;
     2174    pThis->pTxThread             = NULL;
     2175#endif
    21582176
    21592177    /* Do our own locking. */
    … …  
    21902208    Assert(pThis->cMsLinkUpDelay <= 300000); /* less than 5 minutes */
    21912209    if (pThis->cMsLinkUpDelay > 5000 || pThis->cMsLinkUpDelay < 100)
    2192         LogRel(("%s WARNING! Link up delay is set to %u seconds!\n",
    2193                 INSTANCE(pThis), pThis->cMsLinkUpDelay / 1000));
    2194     Log(("%s Link up delay is set to %u seconds\n",
    2195          INSTANCE(pThis), pThis->cMsLinkUpDelay / 1000));
    2196 
    2197     vnetPrintFeatures(pThis, vnetIoCb_GetHostFeatures(pThis), "Device supports the following features");
     2210        LogRel(("%s WARNING! Link up delay is set to %u seconds!\n", INSTANCE(pThis), pThis->cMsLinkUpDelay / 1000));
     2211    Log(("%s Link up delay is set to %u seconds\n", INSTANCE(pThis), pThis->cMsLinkUpDelay / 1000));
     2212
     2213    vnetPrintFeatures(pThis, vnetIoCb_GetHostFeatures(&pThis->VPCI), "Device supports the following features");
    21982214
    21992215    /* Initialize PCI config space */
    … …  
    22442260    AssertRCReturn(rc, rc);
    22452261
    2246 #ifndef VNET_TX_DELAY
    2247     pThis->pSupDrvSession = PDMDevHlpGetSupDrvSession(pDevIns);
    2248     pThis->hTxEvent       = NIL_SUPSEMEVENT;
    2249     pThis->pTxThread      = NULL;
    2250 #else /* VNET_TX_DELAY */
     2262#ifdef VNET_TX_DELAY
    22512263    /* Create Transmit Delay Timer */
    22522264    rc = PDMDevHlpTMTimerCreate(pDevIns, TMCLOCK_VIRTUAL, vnetR3TxTimer, pThis, TMTIMER_FLAGS_NO_CRIT_SECT,
    … …  
    22862298    AssertRCReturn(rc, rc);
    22872299
    2288     rc = vnetIoCb_Reset(pThis);
     2300    rc = vnetIoCb_Reset(&pThis->VPCI);
    22892301    AssertRCReturn(rc, rc);
    22902302
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