VirtualBox

Changeset 22441 in vbox


Ignore:
Timestamp:
Aug 25, 2009 3:38:53 PM (15 years ago)
Author:
vboxsync
Message:

netflt/win: wait for pending ops to complete before switching netflt mode on/off

Location:
trunk/src/VBox/HostDrivers/VBoxNetFlt
Files:
6 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/HostDrivers/VBoxNetFlt/VBoxNetFltInternal.h

    r20374 r22441  
    195195            /** Filter driver device context. */
    196196            ADAPT IfAdaptor;
     197            /** since the driver is able to work in different modes (NetFlt or PassThru)
     198             * we need to wait for the old-mode operations to complete before switching to the new mode
     199             * The most trickiest here is NetFlt->PassThru switch as we can not block in PtSent/Receive
     200             * because they typically run at DPC level
     201             * we also not allowed to re-order packets, so on NetFlt-PassThru switch (kVBoxNetDevMode_NetFltDeinitializing mode)
     202             * we put them to the pending queue to process them in order on final mode activation stage */
     203            volatile VBOXNETDEVMODE_TYPE enmModeMP;
     204            volatile VBOXNETDEVMODE_TYPE enmModePT;
     205            volatile uint32_t cModeNetFltRefs;
     206            volatile uint32_t cModePassThruRefs;
     207
    197208            /** Packet worker thread info */
    198209            PACKET_QUEUE_WORKER PacketQueueWorker;

  • trunk/src/VBox/HostDrivers/VBoxNetFlt/win/VBoxNetFlt-win.c

    r21904 r22441  
    157157            DBGPRINT(("device not idle"));
    158158            Assert(0);
    159             break;
     159//            break;
    160160        }
    161161#endif
    … …  
    34903490#endif
    34913491    PADAPT pAdapt = PVBOXNETFLTINS_2_PADAPT(pThis);
     3492
     3493    /* we first wait for all pending ops to complete
     3494     * this might include all packets queued for processing */
     3495    for(;;)
     3496    {
     3497        if(fActive)
     3498        {
     3499                if(!pThis->u.s.cModePassThruRefs)
     3500                {
     3501                        break;
     3502                }
     3503        }
     3504        else
     3505        {
     3506                if(!pThis->u.s.cModeNetFltRefs)
     3507                {
     3508                        break;
     3509                }
     3510        }
     3511                vboxNetFltWinSleep(2);
     3512    }
     3513
    34923514    if(!vboxNetFltWinReferenceAdapt(pAdapt))
    3493         return;
    3494 
    3495 #ifndef VBOXNETADP
    3496 # ifndef VBOX_NETFLT_ONDEMAND_BIND
    3497     if(fActive)
    3498     {
    3499         /*
    3500          * flush any pass-thru receive-queued packets
    3501          */
    3502         vboxNetFltWinPtFlushReceiveQueue(pAdapt, false /*fReturn*/);
    3503     }
    3504 # endif
    3505 
     3515        return;
     3516#ifndef VBOXNETADP
     3517
     3518    /* the packets put to ReceiveQueue Array are currently not holding the references,
     3519     * simply need to flush them */
     3520    vboxNetFltWinPtFlushReceiveQueue(pAdapt, false /*fReturn*/);
    35063521
    35073522    if(fActive)
    … …  
    36713686{
    36723687    PADAPT pAdapt = PVBOXNETFLTINS_2_PADAPT(pThis);
     3688    pThis->u.s.cModeNetFltRefs = 0;
     3689    pThis->u.s.cModePassThruRefs = 0;
    36733690    vboxNetFltWinSetAdaptState(pAdapt, kVBoxAdaptState_Disconnected);
    36743691    vboxNetFltWinSetOpState(&pAdapt->MPState, kVBoxNetDevOpState_Deinitialized);

  • trunk/src/VBox/HostDrivers/VBoxNetFlt/win/VBoxNetFlt-win.h

    r21343 r22441  
    305305DECLHIDDEN(void) vboxNetFltWinWaitDereference(PADAPT_DEVICE pState);
    306306
     307DECLINLINE(void) vboxNetFltWinReferenceModeNetFlt(PVBOXNETFLTINS pIns)
     308{
     309        ASMAtomicIncU32((volatile uint32_t *)&pIns->u.s.cModeNetFltRefs);
     310}
     311
     312DECLINLINE(void) vboxNetFltWinReferenceModePassThru(PVBOXNETFLTINS pIns)
     313{
     314        ASMAtomicIncU32((volatile uint32_t *)&pIns->u.s.cModePassThruRefs);
     315}
     316
     317DECLINLINE(void) vboxNetFltWinIncReferenceModeNetFlt(PVBOXNETFLTINS pIns, uint32_t v)
     318{
     319        ASMAtomicAddU32((volatile uint32_t *)&pIns->u.s.cModeNetFltRefs, v);
     320}
     321
     322DECLINLINE(void) vboxNetFltWinIncReferenceModePassThru(PVBOXNETFLTINS pIns, uint32_t v)
     323{
     324        ASMAtomicAddU32((volatile uint32_t *)&pIns->u.s.cModePassThruRefs, v);
     325}
     326
     327DECLINLINE(void) vboxNetFltWinDereferenceModeNetFlt(PVBOXNETFLTINS pIns)
     328{
     329        ASMAtomicDecU32((volatile uint32_t *)&pIns->u.s.cModeNetFltRefs);
     330}
     331
     332DECLINLINE(void) vboxNetFltWinDereferenceModePassThru(PVBOXNETFLTINS pIns)
     333{
     334        ASMAtomicDecU32((volatile uint32_t *)&pIns->u.s.cModePassThruRefs);
     335}
     336
     337DECLINLINE(void) vboxNetFltWinDecReferenceModeNetFlt(PVBOXNETFLTINS pIns, uint32_t v)
     338{
     339        Assert(v);
     340        ASMAtomicAddU32((volatile uint32_t *)&pIns->u.s.cModeNetFltRefs, (uint32_t)(-((int32_t)v)));
     341}
     342
     343DECLINLINE(void) vboxNetFltWinDecReferenceModePassThru(PVBOXNETFLTINS pIns, uint32_t v)
     344{
     345        Assert(v);
     346        ASMAtomicAddU32((volatile uint32_t *)&pIns->u.s.cModePassThruRefs, (uint32_t)(-((int32_t)v)));
     347}
     348
    307349DECLINLINE(void) vboxNetFltWinSetPowerState(PADAPT_DEVICE pState, NDIS_DEVICE_POWER_STATE State)
    308350{
    … …  
    374416DECLINLINE(void) vboxNetFltWinDecReferenceDevice(PADAPT pAdapt, PADAPT_DEVICE pState, uint32_t v)
    375417{
     418        Assert(v);
    376419    ASMAtomicAddU32((uint32_t volatile *)&pState->cReferences, (uint32_t)(-((int32_t)v)));
    377420}
    … …  
    387430DECLINLINE(bool) vboxNetFltWinDoIncReferenceDevice(PADAPT pAdapt, PADAPT_DEVICE pState, uint32_t v)
    388431{
     432        Assert(v);
    389433    if (vboxNetFltWinGetPowerState(pState) == NdisDeviceStateD0 && vboxNetFltWinGetOpState(pState) == kVBoxNetDevOpState_Initialized)
    390434    {
    … …  
    439483}
    440484#else
    441 DECLINLINE(bool) vboxNetFltWinReferenceAdaptNetFltFromAdapt(PADAPT pAdapt, PVBOXNETFLTINS *ppNetFlt)
     485DECLINLINE(bool) vboxNetFltWinReferenceAdaptNetFlt(PVBOXNETFLTINS pNetFlt, PADAPT pAdapt, bool * pbNetFltActive)
    442486{
    443487    RTSPINLOCKTMP Tmp = RTSPINLOCKTMP_INITIALIZER;
    444     PVBOXNETFLTINS pNetFlt = PADAPT_2_PVBOXNETFLTINS(pAdapt);
    445488
    446489    RTSpinlockAcquire((pNetFlt)->hSpinlock, &Tmp);
    … …  
    452495    {
    453496        RTSpinlockRelease((pNetFlt)->hSpinlock, &Tmp);
    454         *ppNetFlt = NULL;
     497        *pbNetFltActive = false;
    455498        return false;
    456499    }
    … …  
    458501    if(!ASMAtomicUoReadBool(&(pNetFlt)->fActive))
    459502    {
     503        vboxNetFltWinReferenceModePassThru(pNetFlt);
    460504        RTSpinlockRelease((pNetFlt)->hSpinlock, &Tmp);
    461         *ppNetFlt = NULL;
     505        *pbNetFltActive = false;
    462506        return true;
    463507    }
    464508
    465509    vboxNetFltRetain((pNetFlt), true /* fBusy */);
    466 
     510        vboxNetFltWinReferenceModeNetFlt(pNetFlt);
    467511    RTSpinlockRelease((pNetFlt)->hSpinlock, &Tmp);
    468512
    469     *ppNetFlt = pNetFlt;
     513    *pbNetFltActive = true;
    470514    return true;
    471515}
    … …  
    513557}
    514558#else
    515 DECLINLINE(bool) vboxNetFltWinIncReferenceAdaptNetFltFromAdapt(PADAPT pAdapt, PVBOXNETFLTINS *ppNetFlt, uint32_t v)
     559DECLINLINE(bool) vboxNetFltWinIncReferenceAdaptNetFlt(PVBOXNETFLTINS pNetFlt, PADAPT pAdapt, uint32_t v, bool *pbNetFltActive)
    516560{
    517561    RTSPINLOCKTMP Tmp = RTSPINLOCKTMP_INITIALIZER;
    518562    uint32_t i;
    519     PVBOXNETFLTINS pNetFlt = PADAPT_2_PVBOXNETFLTINS(pAdapt);
    520563
    521564    Assert(v);
    522565    if(!v)
    523566    {
    524         *ppNetFlt = NULL;
     567        *pbNetFltActive = false;
    525568        return false;
    526569    }
    … …  
    534577    {
    535578        RTSpinlockRelease(pNetFlt->hSpinlock, &Tmp);
    536         *ppNetFlt = NULL;
     579        *pbNetFltActive = false;
    537580        return false;
    538581    }
    … …  
    540583    if(!ASMAtomicUoReadBool(&(pNetFlt)->fActive))
    541584    {
     585        vboxNetFltWinIncReferenceModePassThru(pNetFlt, v);
     586
    542587        RTSpinlockRelease((pNetFlt)->hSpinlock, &Tmp);
    543         *ppNetFlt = NULL;
     588        *pbNetFltActive = false;
    544589        return true;
    545590    }
    546591
    547592    vboxNetFltRetain(pNetFlt, true /* fBusy */);
     593
     594        vboxNetFltWinIncReferenceModeNetFlt(pNetFlt, v);
     595
    548596    RTSpinlockRelease(pNetFlt->hSpinlock, &Tmp);
    549597
    … …  
    554602    }
    555603
    556     *ppNetFlt = pNetFlt;
     604    *pbNetFltActive = true;
    557605
    558606    return true;
    … …  
    568616        vboxNetFltRelease(pNetFlt, true);
    569617    }
     618
     619        vboxNetFltWinDecReferenceModeNetFlt(pNetFlt, n);
    570620}
    571621
    … …  
    573623{
    574624    vboxNetFltRelease(pNetFlt, true);
     625
     626        vboxNetFltWinDereferenceModeNetFlt(pNetFlt);
    575627}
    576628

  • trunk/src/VBox/HostDrivers/VBoxNetFlt/win/VBoxNetFltCommon-win.h

    r21343 r22441  
    298298} ADAPT_DEVICE, *PADAPT_DEVICE;
    299299
     300
     301typedef enum VBOXNETDEVMODE_TYPE
     302{
     303    kVBoxNetDevMode_InvalidValue = 0,
     304    kVBoxNetDevMode_NetFltInitializing,
     305    kVBoxNetDevMode_NetFltInitialized,
     306    kVBoxNetDevMode_NetFltDeinitializing,
     307    kVBoxNetDevMode_NetFltWaitDeinitialized,
     308    kVBoxNetDevMode_NetFltDeinitialized,
     309
     310} VBOXNETDEVMODE_TYPE;
     311
     312/* packet filter processing mode constants */
     313#define VBOXNETFLT_PFP_NETFLT   1
     314#define VBOXNETFLT_PFP_PASSTHRU 2
     315
    300316/** represents filter driver device context*/
    301317typedef struct _ADAPT
    … …  
    351367    /** @todo join all boolean states to one field treated as flags bitmap */
    352368    /** true iff we are processing Set packet filter OID */
    353     bool                        bProcessingPacketFilter;
     369    uint8_t                        fProcessingPacketFilter;
    354370    /** true iff the upper protocol filter cache was initialized */
    355371    bool                        bUpperProtSetFilterInitialized;

  • trunk/src/VBox/HostDrivers/VBoxNetFlt/win/VBoxNetFltMp-win.c

    r21343 r22441  
    815815    NDIS_STATUS         fStatus;
    816816    UINT                i;
    817     PVBOXNETFLTINS pNetFltIf;
     817    PVBOXNETFLTINS pNetFlt = PADAPT_2_PVBOXNETFLTINS(pAdapt);
     818    bool bNetFltActive;
    818819
    819820    Assert(cNumberOfPackets);
    820821
    821     if(vboxNetFltWinIncReferenceAdaptNetFltFromAdapt(pAdapt, &pNetFltIf, cNumberOfPackets))
     822    if(vboxNetFltWinIncReferenceAdaptNetFlt(pNetFlt, pAdapt, cNumberOfPackets, &bNetFltActive))
    822823    {
    823824        uint32_t cAdaptRefs = cNumberOfPackets;
    824         uint32_t cNetFltRefs = pNetFltIf ? cNumberOfPackets : 0;
     825        uint32_t cNetFltRefs;
     826        uint32_t cPassThruRefs;
     827        if(bNetFltActive)
     828        {
     829                cNetFltRefs = cNumberOfPackets;
     830                cPassThruRefs = 0;
     831        }
     832        else
     833        {
     834                cPassThruRefs = cNumberOfPackets;
     835                cNetFltRefs = 0;
     836        }
    825837
    826838        for (i = 0; i < cNumberOfPackets; i++)
    … …  
    853865            {
    854866                if(!cNetFltRefs
    855                     || (fStatus = vboxNetFltWinQuEnqueuePacket(pNetFltIf, pPacket, PACKET_SRC_HOST)) != NDIS_STATUS_SUCCESS)
     867                    || (fStatus = vboxNetFltWinQuEnqueuePacket(pNetFlt, pPacket, PACKET_SRC_HOST)) != NDIS_STATUS_SUCCESS)
    856868                {
    857869#ifndef VBOXNETADP
    … …  
    889901
    890902        if(cNetFltRefs)
    891             vboxNetFltWinDecReferenceNetFlt(pNetFltIf, cNetFltRefs);
     903        {
     904            vboxNetFltWinDecReferenceNetFlt(pNetFlt, cNetFltRefs);
     905        }
     906        else if(cPassThruRefs)
     907        {
     908            vboxNetFltWinDecReferenceModePassThru(pNetFlt, cPassThruRefs);
     909        }
    892910        if(cAdaptRefs)
     911        {
    893912            vboxNetFltWinDecReferenceAdapt(pAdapt, cAdaptRefs);
     913        }
    894914    }
    895915    else
    … …  
    10511071        if(Oid == OID_GEN_CURRENT_PACKET_FILTER && VBOXNETFLT_PROMISCUOUS_SUPPORTED(pAdapt))
    10521072        {
    1053             PVBOXNETFLTINS pNetFltIf;
    1054             const bool fAdaptActive = vboxNetFltWinReferenceAdaptNetFltFromAdapt(pAdapt, &pNetFltIf);
     1073            bool fNetFltActive;
     1074            const bool fAdaptActive = vboxNetFltWinReferenceAdaptNetFlt(pNetFlt, pAdapt, &fNetFltActive);
    10551075
    10561076            Assert(InformationBuffer);
    1057             Assert(!pAdapt->bProcessingPacketFilter);
    1058 
    1059             if(pNetFltIf)
     1077            Assert(!pAdapt->fProcessingPacketFilter);
     1078
     1079            if(fNetFltActive)
    10601080            {
    10611081                /* netflt is active, simply return the cached value */
    … …  
    10631083
    10641084                Status = NDIS_STATUS_SUCCESS;
    1065                 vboxNetFltWinDereferenceNetFlt(pNetFltIf);
     1085                vboxNetFltWinDereferenceNetFlt(pNetFlt);
    10661086                vboxNetFltWinDereferenceAdapt(pAdapt);
    10671087
    … …  
    10731093            else if(fAdaptActive)
    10741094            {
    1075                 vboxNetFltWinDereferenceAdapt(pAdapt);
     1095                pAdapt->fProcessingPacketFilter = VBOXNETFLT_PFP_PASSTHRU;
     1096                /* we're cleaning it in RequestComplete */
    10761097            }
    10771098        }
    … …  
    13971418        {
    13981419            /* need to disable cleaning promiscuous here ?? */
    1399             PVBOXNETFLTINS pNetFltIf;
    1400             const bool fAdaptActive = vboxNetFltWinReferenceAdaptNetFltFromAdapt(pAdapt, &pNetFltIf);
     1420                bool fNetFltActive;
     1421            const bool fAdaptActive = vboxNetFltWinReferenceAdaptNetFlt(pNetFlt, pAdapt, &fNetFltActive);
    14011422
    14021423            Assert(InformationBuffer);
    1403             Assert(!pAdapt->bProcessingPacketFilter);
    1404 
    1405             if(pNetFltIf)
     1424            Assert(!pAdapt->fProcessingPacketFilter);
     1425
     1426            if(fNetFltActive)
    14061427            {
    14071428                Assert(fAdaptActive);
    … …  
    14191440                    pAdapt->Request.DATA.SET_INFORMATION.InformationBuffer = &pAdapt->fSetFilterBuffer;
    14201441                    pAdapt->Request.DATA.SET_INFORMATION.InformationBufferLength = sizeof(pAdapt->fSetFilterBuffer);
    1421                     pAdapt->bProcessingPacketFilter = true;
     1442                    pAdapt->fProcessingPacketFilter = VBOXNETFLT_PFP_NETFLT;
    14221443                    /* we'll do dereferencing in request complete */
    14231444                }
    … …  
    14251446                {
    14261447                    Status = NDIS_STATUS_SUCCESS;
    1427                     vboxNetFltWinDereferenceNetFlt(pNetFltIf);
     1448                    vboxNetFltWinDereferenceNetFlt(pNetFlt);
    14281449                    vboxNetFltWinDereferenceAdapt(pAdapt);
    14291450
    … …  
    14361457            else if(fAdaptActive)
    14371458            {
    1438                 vboxNetFltWinDereferenceAdapt(pAdapt);
     1459                pAdapt->fProcessingPacketFilter = VBOXNETFLT_PFP_PASSTHRU;
     1460                /* dereference on completion */
    14391461            }
    14401462        }
    … …  
    17921814#ifdef VBOXNETADP_REPORT_DISCONNECTED
    17931815            {
    1794                 PVBOXNETFLTINS pNetFltIf = NULL;
    1795                 bool bActive = vboxNetFltWinReferenceAdaptNetFltFromAdapt(pAdapt, &pNetFltIf);
    1796                 if(bActive && pNetFltIf)
     1816                PVBOXNETFLTINS pNetFlt = PADAPT_2_PVBOXNETFLTINS(pAdapt);
     1817                bool bNetFltActive;
     1818                bool bActive = vboxNetFltWinReferenceAdaptNetFltFromAdapt(pNetFlt, pAdapt, bNetFltActive);
     1819                if(bActive && bNetFltActive)
    17971820                {
    17981821                    ulInfo = NdisMediaStateConnected;
    … …  
    18071830                    vboxNetFltWinDereferenceAdapt(pAdapt);
    18081831                }
    1809                 if(pNetFltIf)
     1832                if(bNetFltActive)
    18101833                {
    1811                     vboxNetFltWinDereferenceNetFlt(pNetFltIf);
     1834                    vboxNetFltWinDereferenceNetFlt(pNetFlt);
     1835                }
     1836                else
     1837                {
     1838                    vboxNetFltWinDereferenceModePassThru(pNetFlt);
    18121839                }
    18131840            }

  • trunk/src/VBox/HostDrivers/VBoxNetFlt/win/VBoxNetFltPt-win.c

    r22389 r22441  
    559559        if(Oid == OID_GEN_CURRENT_PACKET_FILTER && VBOXNETFLT_PROMISCUOUS_SUPPORTED(pAdapt))
    560560        {
     561                /* we're here _ONLY_ in the passthru mode */
     562                Assert(pAdapt->fProcessingPacketFilter == VBOXNETFLT_PFP_PASSTHRU);
     563                if(pAdapt->fProcessingPacketFilter == VBOXNETFLT_PFP_PASSTHRU)
     564                {
     565                                PVBOXNETFLTINS pNetFltIf = PADAPT_2_PVBOXNETFLTINS(pAdapt);
     566                                Assert(!pNetFltIf->fActive);
     567                                vboxNetFltWinDereferenceModePassThru(pNetFltIf);
     568                                vboxNetFltWinDereferenceAdapt(pAdapt);
     569                }
     570
    561571            if(Status == NDIS_STATUS_SUCCESS)
    562572            {
    … …  
    582592              PVBOXNETFLTINS pNetFltIf = PADAPT_2_PVBOXNETFLTINS(pAdapt);
    583593              Assert(Status == NDIS_STATUS_SUCCESS);
    584               if(pAdapt->bProcessingPacketFilter)
     594              if(pAdapt->fProcessingPacketFilter == VBOXNETFLT_PFP_NETFLT)
    585595              {
     596                  Assert(pNetFltIf->fActive);
    586597                  if(Status == NDIS_STATUS_SUCCESS)
    587598                  {
    … …  
    591602                  vboxNetFltWinDereferenceNetFlt(pNetFltIf);
    592603                  vboxNetFltWinDereferenceAdapt(pAdapt);
    593                   pAdapt->bProcessingPacketFilter = false;
     604                  pAdapt->fProcessingPacketFilter = 0;
    594605              }
    595               else
     606              else if(pAdapt->fProcessingPacketFilter == VBOXNETFLT_PFP_PASSTHRU)
    596607              {
     608                  Assert(!pNetFltIf->fActive);
     609
    597610                  if(Status == NDIS_STATUS_SUCCESS)
    598611                  {
    … …  
    601614                      pAdapt->bUpperProtSetFilterInitialized = true;
    602615                  }
     616                  vboxNetFltWinDereferenceModePassThru(pNetFltIf);
     617                  vboxNetFltWinDereferenceAdapt(pAdapt);
     618                  pAdapt->fProcessingPacketFilter = 0;
    603619              }
    604620          }
    … …  
    14881504    PADAPT            pAdapt = (PADAPT)ProtocolBindingContext;
    14891505    NDIS_STATUS       Status = NDIS_STATUS_SUCCESS;
    1490     PVBOXNETFLTINS pNetFltIf;
     1506    PVBOXNETFLTINS pNetFlt = PADAPT_2_PVBOXNETFLTINS(pAdapt);
    14911507#ifdef VBOX_NETFLT_ONDEMAND_BIND
    14921508#if 0
    … …  
    15711587#else /* if NOT defined VBOX_NETFLT_ONDEMAND_BIND */
    15721588    PNDIS_PACKET      pPacket = NULL;
    1573     bool fAdaptActive = vboxNetFltWinReferenceAdaptNetFltFromAdapt(pAdapt, &pNetFltIf);
     1589    bool bNetFltActive;
     1590    bool fAdaptActive = vboxNetFltWinReferenceAdaptNetFlt(pNetFlt, pAdapt, &bNetFltActive);
     1591    const bool bPassThruActive = !bNetFltActive;
    15741592    if(fAdaptActive)
    15751593    {
    … …  
    16051623                    }
    16061624
    1607                     if(pNetFltIf)
     1625                    if(bNetFltActive)
    16081626                    {
    1609                         Status = vboxNetFltWinQuEnqueuePacket(pNetFltIf, pPacket, PACKET_COPY);
     1627                        Status = vboxNetFltWinQuEnqueuePacket(pNetFlt, pPacket, PACKET_COPY);
    16101628                        if(Status == NDIS_STATUS_SUCCESS)
    16111629                        {
    16121630                            //NdisReturnPackets(&pPacket, 1);
    16131631                            fAdaptActive = false;
    1614                             pNetFltIf = NULL;
     1632                            bNetFltActive = false;
    16151633                            break;
    16161634                        }
    … …  
    16301648            }
    16311649#endif /* todo: remove */
    1632             if(pNetFltIf)
     1650            if(bNetFltActive)
    16331651            {
    16341652                Status = vboxNetFltWinPtReceiveActive(pAdapt, MacReceiveContext, pHeaderBuffer, cbHeaderBuffer,
    … …  
    16391657                    {
    16401658                        fAdaptActive = false;
    1641                         pNetFltIf = NULL;
     1659                        bNetFltActive = false;
    16421660                    }
    16431661                    else
    … …  
    16831701        } while(0);
    16841702
    1685         if(pNetFltIf)
    1686             vboxNetFltWinDereferenceNetFlt(pNetFltIf);
     1703        if(bNetFltActive)
     1704        {
     1705            vboxNetFltWinDereferenceNetFlt(pNetFlt);
     1706        }
     1707        else if(bPassThruActive)
     1708        {
     1709            vboxNetFltWinDereferenceModePassThru(pNetFlt);
     1710        }
    16871711        if(fAdaptActive)
     1712        {
    16881713            vboxNetFltWinDereferenceAdapt(pAdapt);
     1714        }
    16891715    }
    16901716    else
    … …  
    17101736#ifndef VBOX_NETFLT_ONDEMAND_BIND
    17111737    PADAPT        pAdapt =(PADAPT)ProtocolBindingContext;
     1738    PVBOXNETFLTINS pNetFlt = PADAPT_2_PVBOXNETFLTINS(pAdapt);
    17121739    ULONG         NumberOfPackets = 0;
     1740    /* since the receive array queued packets do not hold the reference we need to
     1741     * reference  the PassThru/NetFlt mode here to avoid packet reordering caused by
     1742     * concurrently running vboxNetFltWinPtReceiveComplete and vboxNetFltPortOsSetActive
     1743     * on netflt activation/deactivation */
     1744    bool bNetFltActive;
     1745    bool fAdaptActive = vboxNetFltWinReferenceAdaptNetFlt(pNetFlt, pAdapt, &bNetFltActive);
    17131746
    17141747    vboxNetFltWinPtFlushReceiveQueue(pAdapt, false);
    … …  
    17311764
    17321765    pAdapt->bIndicateRcvComplete = FALSE;
     1766
     1767    if(fAdaptActive)
     1768    {
     1769        if(bNetFltActive)
     1770        {
     1771            vboxNetFltWinDereferenceNetFlt(pNetFlt);
     1772        }
     1773        else
     1774        {
     1775            vboxNetFltWinDereferenceModePassThru(pNetFlt);
     1776        }
     1777        vboxNetFltWinDereferenceAdapt(pAdapt);
     1778    }
    17331779#endif
    17341780}
    … …  
    17531799    PADAPT              pAdapt =(PADAPT)ProtocolBindingContext;
    17541800    INT         cRefCount = 0;
    1755     PVBOXNETFLTINS pNetFltIf;
     1801    PVBOXNETFLTINS pNetFlt = PADAPT_2_PVBOXNETFLTINS(pAdapt);
    17561802#ifdef VBOX_NETFLT_ONDEMAND_BIND
    17571803    PNDIS_BUFFER pBuffer;
    … …  
    18421888    return 0;
    18431889#else
    1844     bool fAdaptActive = vboxNetFltWinReferenceAdaptNetFltFromAdapt(pAdapt, &pNetFltIf);
     1890    bool bNetFltActive;
     1891    bool fAdaptActive = vboxNetFltWinReferenceAdaptNetFlt(pNetFlt, pAdapt, &bNetFltActive);
     1892    const bool bPassThruActive = !bNetFltActive;
    18451893    if(fAdaptActive)
    18461894    {
    … …  
    18691917            }
    18701918
    1871             if(pNetFltIf)
     1919            if(bNetFltActive)
    18721920            {
    18731921                bool bResources = NDIS_GET_PACKET_STATUS(pPacket) == NDIS_STATUS_RESOURCES;
    … …  
    18791927                Assert(!bResources);
    18801928
    1881                 fStatus = vboxNetFltWinQuEnqueuePacket(pNetFltIf, pPacket, bResources ? PACKET_COPY : 0);
     1929                fStatus = vboxNetFltWinQuEnqueuePacket(pNetFlt, pPacket, bResources ? PACKET_COPY : 0);
    18821930                if(fStatus == NDIS_STATUS_SUCCESS)
    18831931                {
    1884                     pNetFltIf = NULL;
     1932                    bNetFltActive = false;
    18851933                    fAdaptActive = false;
    18861934                    if(bResources)
    … …  
    19101958        } while(FALSE);
    19111959
    1912         if(pNetFltIf)
    1913             vboxNetFltWinDereferenceNetFlt(pNetFltIf);
     1960        if(bNetFltActive)
     1961        {
     1962            vboxNetFltWinDereferenceNetFlt(pNetFlt);
     1963        }
     1964        else if(bPassThruActive)
     1965        {
     1966            vboxNetFltWinDereferenceModePassThru(pNetFlt);
     1967        }
    19141968        if(fAdaptActive)
     1969        {
    19151970            vboxNetFltWinDereferenceAdapt(pAdapt);
     1971        }
    19161972    }
    19171973    else
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