VirtualBox

Ignore:
Timestamp:
Sep 23, 2008 7:42:25 AM (16 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
36953
Message:

Solaris/vboxnetflt: fixed a race between xmit and recv.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/VBox/HostDrivers/VBoxNetFlt/solaris/VBoxNetFlt-solaris.c

    r12656 r12661  
    681681    }
    682682    else
    683     {   
     683    {
    684684        /*
    685685         * Allocate & initialize per-stream data. Hook it into the (read and write) queue's module specific data.
     
    689689        {
    690690            LogRel((DEVICE_NAME ":VBoxNetFltSolarisModOpen failed to allocate stream data.\n"));
    691    
     691
    692692            RTSpinlockRelease(pThis->hSpinlock, &Tmp);
    693693            return ENOMEM;
     
    757757                LogRel((DEVICE_NAME ":vboxNetFltSolarisSetRawMode failed rc=%Vrc.\n", rc));
    758758        }
    759         else       
     759        else
    760760            LogRel((DEVICE_NAME ":vboxNetFltSolarisBindReq failed rc=%Vrc.\n", rc));
    761761
     
    906906                        && pPromiscStream->fRawMode)
    907907                    {
     908                        RTSpinlockAcquire(pThis->hSpinlock, &Tmp);
    908909                        vboxNetFltSolarisRecv(pThis, pStream, pQueue, pMsg);
     910                        RTSpinlockRelease(pThis->hSpinlock, &Tmp);
    909911                        fSendUpstream = false;
    910912                    }
     
    921923                    switch (Prim)
    922924                    {
    923 #if 0
    924                         case DL_UNITDATA_IND:
    925                         {
    926                             /*
    927                              * I do not think control would come here... We convert all outgoing fast mode requests
    928                              * to raw mode; so I don't think we should really receive any fast mode replies.
    929                              */
    930                             LogFlow((DEVICE_NAME ":VBoxNetFltSolarisModReadPut: DL_UNITDATA_IND\n"));
    931 
    932                             if (fActive)
    933                             {
    934                                 vboxNetFltSolarisRecv(pThis, pStream, pQueue, pMsg);
    935                                 fSendUpstream = false;
    936                             }
    937                             break;
    938                         }
    939 #endif
    940 
    941925                        case DL_BIND_ACK:
    942926                        {
     
    24052389        return VERR_NET_MSG_SIZE;
    24062390
    2407     RTSPINLOCKTMP Tmp = RTSPINLOCKTMP_INITIALIZER;
    2408     RTSpinlockAcquire(pThis->hSpinlock, &Tmp);
    2409 
    24102391    PCRTNETETHERHDR pEthHdr = (PCRTNETETHERHDR)pMsg->b_rptr;
    24112392    PVBOXNETFLTPACKETID pCur = NULL;
     
    24412422                pCur = pPromiscStream->pTail;
    24422423                vboxNetFltSolarisInitPacketId(pCur, pMsg);
     2424                pPromiscStream->cLoopback++;
    24432425
    24442426                LogFlow((DEVICE_NAME ":vboxNetFltSolarisQueueLoopback re-used tail checksum=%u cLoopback=%d.\n",
     
    24862468    }
    24872469
    2488     RTSpinlockRelease(pThis->hSpinlock, &Tmp);
    24892470    return rc;
    24902471}
     
    25622543            pPromiscStream->pTail = pCur;
    25632544            pCur->pNext = NULL;
    2564             pPromiscStream->cLoopback--;
    2565         }
     2545        }
     2546        pPromiscStream->cLoopback--;
    25662547
    25672548        LogFlow((DEVICE_NAME ":vboxNetFltSolarisIsOurMBlk found packet %p cLoopback=%d\n", pMsg, pPromiscStream->cLoopback));
     
    25902571    Assert(pStream->Type == kPromiscStream);
    25912572
     2573    vboxnetflt_promisc_stream_t *pPromiscStream = ASMAtomicUoReadPtr((void * volatile *)&pThis->u.s.pvPromiscStream);
     2574    if (RT_UNLIKELY(!pPromiscStream))
     2575    {
     2576        freemsg(pMsg);
     2577        LogRel((DEVICE_NAME ":Promiscuous stream missing!! Failing to receive packet.\n"));
     2578        return VERR_INVALID_POINTER;
     2579    }
     2580
    25922581    /*
    25932582     * Don't loopback packets we transmit to the wire.
    25942583     */
    2595     vboxnetflt_promisc_stream_t *pPromiscStream = ASMAtomicUoReadPtr((void * volatile *)&pThis->u.s.pvPromiscStream);
    25962584    if (vboxNetFltSolarisIsOurMBlk(pThis, pPromiscStream, pMsg))
    25972585    {
     
    29752963     */
    29762964    int rc = VINF_SUCCESS;
     2965    RTSPINLOCKTMP Tmp = RTSPINLOCKTMP_INITIALIZER;
    29772966    if (fDst & INTNETTRUNKDIR_WIRE)
    29782967    {
    2979         vboxnetflt_promisc_stream_t *pPromiscStream = ASMAtomicUoReadPtr((void * volatile *)&pThis->u.s.pvPromiscStream);
    2980         if (RT_LIKELY(pPromiscStream))
    2981         {
     2968        mblk_t *pMsg = vboxNetFltSolarisMBlkFromSG(pThis, pSG, fDst);
     2969        if (RT_LIKELY(pMsg))
     2970        {
     2971            LogFlow((DEVICE_NAME ":vboxNetFltPortOsXmit INTNETTRUNKDIR_WIRE\n"));
     2972
     2973            RTSpinlockAcquire(pThis->hSpinlock, &Tmp);
     2974
     2975            vboxnetflt_promisc_stream_t *pPromiscStream = ASMAtomicUoReadPtr((void * volatile *)&pThis->u.s.pvPromiscStream);
    29822976            queue_t *pPromiscWriteQueue = WR(pPromiscStream->Stream.pReadQueue);
    2983             Assert(pPromiscWriteQueue);
    2984 
    2985             mblk_t *pMsg = vboxNetFltSolarisMBlkFromSG(pThis, pSG, fDst);
    2986             if (RT_LIKELY(pMsg))
    2987             {
    2988                 LogFlow((DEVICE_NAME ":vboxNetFltPortOsXmit INTNETTRUNKDIR_WIRE\n"));
    2989 
    2990                 rc = vboxNetFltSolarisQueueLoopback(pThis, pPromiscStream, pMsg);
    2991                 putnext(pPromiscWriteQueue, pMsg);
    2992             }
    2993             else
    2994                 rc = VERR_NO_MEMORY;
     2977
     2978            rc = vboxNetFltSolarisQueueLoopback(pThis, pPromiscStream, pMsg);
     2979
     2980            RTSpinlockRelease(pThis->hSpinlock, &Tmp);
     2981
     2982            putnext(pPromiscWriteQueue, pMsg);
    29952983        }
    29962984        else
    2997             rc = VERR_INVALID_POINTER;
     2985            rc = VERR_NO_MEMORY;
    29982986    }
    29992987
     
    30263014                     * Send message up ARP stream.
    30273015                     */
     3016                    RTSpinlockAcquire(pThis->hSpinlock, &Tmp);
     3017
    30283018                    vboxnetflt_stream_t *pArpStream = ASMAtomicUoReadPtr((void * volatile *)&pThis->u.s.pvArpStream);
    3029                     queue_t *pArpReadQueue = pArpStream->pReadQueue;
    3030                     Assert(pArpReadQueue);
    3031 
    3032                     putnext(pArpReadQueue, pMsg);
     3019                    if (RT_LIKELY(pArpStream))
     3020                    {
     3021                        queue_t *pArpReadQueue = pArpStream->pReadQueue;
     3022                        Assert(pArpReadQueue);
     3023
     3024                        RTSpinlockRelease(pThis->hSpinlock, &Tmp);
     3025
     3026                        putnext(pArpReadQueue, pMsg);
     3027                    }
     3028                    else
     3029                    {
     3030                        RTSpinlockRelease(pThis->hSpinlock, &Tmp);
     3031                        rc = VERR_INVALID_POINTER;
     3032                    }
    30333033                }
    30343034                else
     
    30393039                     * Send messages up IP stream.
    30403040                     */
     3041                    RTSpinlockAcquire(pThis->hSpinlock, &Tmp);
     3042
    30413043                    vboxnetflt_stream_t *pIpStream = ASMAtomicUoReadPtr((void * volatile *)&pThis->u.s.pvIpStream);
    3042                     queue_t *pIpReadQueue = pIpStream->pReadQueue;
    3043                     Assert(pIpReadQueue);
    3044 
    3045                     putnext(pIpReadQueue, pMsg);
     3044                    if (RT_LIKELY(pIpStream))
     3045                    {
     3046                        queue_t *pIpReadQueue = pIpStream->pReadQueue;
     3047                        Assert(pIpReadQueue);
     3048   
     3049                        RTSpinlockRelease(pThis->hSpinlock, &Tmp);
     3050                        putnext(pIpReadQueue, pMsg);
     3051                    }
     3052                    else
     3053                    {
     3054                        RTSpinlockRelease(pThis->hSpinlock, &Tmp);
     3055                        rc = VERR_INVALID_POINTER;                   
     3056                    }
    30463057                }
    30473058            }
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