Changeset 28488 in vbox

Timestamp:

Apr 19, 2010 6:01:22 PM (15 years ago)

Author:

vboxsync

Message:

SrvIntNetR0.cpp: Started replacing the non-recrusive fast mutexes with regular mutexes.

File:

• trunk/src/VBox/Devices/Network/SrvIntNetR0.cpp (modified) (38 diffs)

trunk/src/VBox/Devices/Network/SrvIntNetR0.cpp

@@ -227 +227 @@
     /** Pointer to ring-3 mapping of the default exchange buffer. */
     R3PTRTYPE(PINTNETBUF)   pIntBufDefaultR3;
-    /** Event semaphore which a receiver thread will sleep on while waiting for data to arrive. */
+    /** Event semaphore which a receiver thread will sleep on while waiting
+     * for data to arrive. */
     RTSEMEVENT volatile     Event;
     /** Number of threads sleeping on the Event semaphore. */
@@ -348 +349 @@
     /** List of interfaces connected to the network.
      * This is protected by the INTNET::FastMutex. */
-    PINTNETIF               pIFs;
+    PINTNETIF               pIfs;
     /** Pointer to the trunk interface.
      * Can be NULL if there is no trunk connection. */
@@ -399 +400 @@
 typedef struct INTNET
 {
-    /** Mutex protecting the network creation, opening and destruction.
-     * (This means all operations affecting the pNetworks list.) */
-    RTSEMFASTMUTEX          FastMutex;
+    /** Mutex protecting the creation, opening and destruction of both networks and
+     * interfaces.  (This means all operations affecting the pNetworks list.) */
+    RTSEMMUTEX              hMtxCreateOpenDestroy;
     /** List of networks. Protected by INTNET::Spinlock. */
     PINTNETNETWORK volatile pNetworks;
@@ -1068 +1069 @@
                                                 uint8_t const cbAddr, const char *pszMsg)
 {
-    for (PINTNETIF pIf = pNetwork->pIFs; pIf; pIf = pIf->pNext)
+    for (PINTNETIF pIf = pNetwork->pIfs; pIf; pIf = pIf->pNext)
     {
         int i = intnetR0IfAddrCacheLookup(&pIf->aAddrCache[enmType], pAddr, cbAddr);
@@ -1092 +1093 @@
                                                        INTNETADDRTYPE const enmType, uint8_t const cbAddr, const char *pszMsg)
 {
-    for (PINTNETIF pIf = pNetwork->pIFs; pIf; pIf = pIf->pNext)
+    for (PINTNETIF pIf = pNetwork->pIfs; pIf; pIf = pIf->pNext)
         if (pIf != pIfSender)
         {
@@ -1114 +1115 @@
 DECLINLINE(PINTNETIF) intnetR0NetworkAddrCacheLookupIf(PINTNETNETWORK pNetwork, PCRTNETADDRU pAddr, INTNETADDRTYPE const enmType, uint8_t const cbAddr)
 {
-    for (PINTNETIF pIf = pNetwork->pIFs; pIf; pIf = pIf->pNext)
+    for (PINTNETIF pIf = pNetwork->pIfs; pIf; pIf = pIf->pNext)
     {
         int i = intnetR0IfAddrCacheLookup(&pIf->aAddrCache[enmType], pAddr, cbAddr);
@@ -1325 +1326 @@
         case RTNET_DHCP_MT_ACK:
             if (intnetR0IPv4AddrIsGood(pDhcp->bp_yiaddr))
-                for (PINTNETIF pCur = pNetwork->pIFs; pCur; pCur = pCur->pNext)
+                for (PINTNETIF pCur = pNetwork->pIfs; pCur; pCur = pCur->pNext)
                     if (    pCur->fMacSet
                         &&  !memcmp(&pCur->Mac, &pDhcp->bp_chaddr, sizeof(RTMAC)))
@@ -1343 +1344 @@
         case RTNET_DHCP_MT_RELEASE:
         {
-            for (PINTNETIF pCur = pNetwork->pIFs; pCur; pCur = pCur->pNext)
+            for (PINTNETIF pCur = pNetwork->pIfs; pCur; pCur = pCur->pNext)
                 if (    pCur->fMacSet
                     &&  !memcmp(&pCur->Mac, &pDhcp->bp_chaddr, sizeof(RTMAC)))
@@ -2270 +2271 @@
      * Write the packet to all the interfaces and signal them.
      */
-    for (PINTNETIF pIf = pNetwork->pIFs; pIf; pIf = pIf->pNext)
+    for (PINTNETIF pIf = pNetwork->pIfs; pIf; pIf = pIf->pNext)
         if (pIf != pIfSender)
             intnetR0IfSend(pIf, pIfSender, pSG, NULL);
@@ -2403 +2404 @@
             if (!(pNetwork->fFlags & (INTNET_OPEN_FLAGS_IGNORE_PROMISC | INTNET_OPEN_FLAGS_QUIETLY_IGNORE_PROMISC)))
             {
-                for (PINTNETIF pIf = pNetwork->pIFs; pIf; pIf = pIf->pNext)
+                for (PINTNETIF pIf = pNetwork->pIfs; pIf; pIf = pIf->pNext)
                     if (pIf->fPromiscuous)
                     {
@@ -2418 +2419 @@
      */
     bool fExactIntNetRecipient = false;
-    for (PINTNETIF pIf = pNetwork->pIFs; pIf; pIf = pIf->pNext)
+    for (PINTNETIF pIf = pNetwork->pIfs; pIf; pIf = pIf->pNext)
     {
         bool fIt = intnetR0IfAddrCacheLookup(&pIf->aAddrCache[enmAddrType], &Addr, cbAddr) >= 0;
@@ -2464 +2465 @@
      */
     bool fExactIntNetRecipient = false;
-    for (PINTNETIF pIf = pNetwork->pIFs; pIf; pIf = pIf->pNext)
+    for (PINTNETIF pIf = pNetwork->pIfs; pIf; pIf = pIf->pNext)
     {
         bool fIt = false;
@@ -3312 +3313 @@
 static DECLCALLBACK(void) intnetR0IfDestruct(void *pvObj, void *pvUser1, void *pvUser2)
 {
-    PINTNETIF pIf = (PINTNETIF)pvUser1;
+    PINTNETIF pIf     = (PINTNETIF)pvUser1;
     PINTNET   pIntNet = (PINTNET)pvUser2;
     Log(("intnetR0IfDestruct: pvObj=%p pIf=%p pIntNet=%p hIf=%RX32\n", pvObj, pIf, pIntNet, pIf->hIf));
 
-    RTSemFastMutexRequest(pIntNet->FastMutex);
-
-    /*
-     * Mark the interface as being destroyed so the waiter
-     * can behave appropriately (theoretical case).
-     */
+    /*
+     * We grab the INTNET create/open/destroy semaphore to make sure nobody is
+     * adding or removing interface while we're in here.  For paranoid reasons
+     * we also mark the interface as destroyed here so any waiting threads can
+     * take the appropriate actions (theoretical case).
+     */
+    RTSemMutexRequest(pIntNet->hMtxCreateOpenDestroy, RT_INDEFINITE_WAIT);
     ASMAtomicWriteBool(&pIf->fDestroying, true);
 
@@ -3344 +3346 @@
         intnetR0IfSetActive(pIf, false);
 
-        if (pNetwork->pIFs == pIf)
-            pNetwork->pIFs = pIf->pNext;
+        /* unlink */
+        if (pNetwork->pIfs == pIf)
+            pNetwork->pIfs = pIf->pNext;
         else
         {
-            PINTNETIF pPrev = pNetwork->pIFs;
+            PINTNETIF pPrev = pNetwork->pIfs;
             while (pPrev)
             {
@@ -3362 +3365 @@
         pIf->pNext = NULL;
 
-        /*
-         * Release our reference to the network.
-         */
-        RTSemFastMutexRelease(pIntNet->FastMutex);
-
+        /* Release our reference to the network. */
         SUPR0ObjRelease(pNetwork->pvObj, pIf->pSession);
         pIf->pNetwork = NULL;
     }
-    else
-        RTSemFastMutexRelease(pIntNet->FastMutex);
+
+    RTSemMutexRelease(pIntNet->hMtxCreateOpenDestroy);
 
     /*
@@ -3435 +3434 @@
  * Creates a new network interface.
  *
- * The call must have opened the network for the new interface
- * and is responsible for closing it on failure. On success
- * it must leave the network opened so the interface destructor
- * can close it.
+ * The call must have opened the network for the new interface and is
+ * responsible for closing it on failure.  On success it must leave the network
+ * opened so the interface destructor can close it.
  *
  * @returns VBox status code.
@@ -3447 +3445 @@
  * @param   phIf        Where to store the interface handle.
  */
-static int intnetR0NetworkCreateIf(PINTNETNETWORK pNetwork, PSUPDRVSESSION pSession, unsigned cbSend, unsigned cbRecv, bool *pfCloseNetwork, PINTNETIFHANDLE phIf)
+static int intnetR0NetworkCreateIf(PINTNETNETWORK pNetwork, PSUPDRVSESSION pSession, unsigned cbSend, unsigned cbRecv,
+                                   PINTNETIFHANDLE phIf)
 {
     LogFlow(("intnetR0NetworkCreateIf: pNetwork=%p pSession=%p cbSend=%u cbRecv=%u phIf=%p\n",
@@ -3457 +3456 @@
     AssertPtr(pNetwork);
     AssertPtr(phIf);
-    AssertPtr(pfCloseNetwork);
-    *pfCloseNetwork = false;
 
     /*
@@ -3514 +3511 @@
             ASMMemZero32(pIf->pIntBufDefault, cbBuf); /** @todo I thought I specified these buggers as clearing the memory... */
 
-            pIf->pIntBuf = pIf->pIntBufDefault;
+            pIf->pIntBuf   = pIf->pIntBufDefault;
             pIf->pIntBufR3 = pIf->pIntBufDefaultR3;
             INTNETBufInit(pIf->pIntBuf, cbBuf, cbRecv, cbSend);
@@ -3524 +3521 @@
             if (RT_SUCCESS(rc))
             {
-                pIf->pNext = pNetwork->pIFs;
-                pNetwork->pIFs = pIf;
+                pIf->pNext = pNetwork->pIfs;
+                pNetwork->pIfs = pIf;
                 RTSemFastMutexRelease(pNetwork->FastMutex2);
 
                 /*
-                 * Register the interface with the session.
+                 * Register the interface with the session, adding another
+                 * reference to the network to ease the cleanup duties of the caller.
                  */
-                pIf->pvObj = SUPR0ObjRegister(pSession, SUPDRVOBJTYPE_INTERNAL_NETWORK_INTERFACE, intnetR0IfDestruct, pIf, pNetwork->pIntNet);
-                if (pIf->pvObj)
+                rc = SUPR0ObjAddRef(pNetwork->pvObj, pSession);
+                if (RT_SUCCESS(rc))
                 {
-                    rc = RTHandleTableAllocWithCtx(pNetwork->pIntNet->hHtIfs, pIf, pSession, (uint32_t *)&pIf->hIf);
-                    if (RT_SUCCESS(rc))
+                    pIf->pvObj = SUPR0ObjRegister(pSession, SUPDRVOBJTYPE_INTERNAL_NETWORK_INTERFACE, intnetR0IfDestruct, pIf, pNetwork->pIntNet);
+                    if (pIf->pvObj)
                     {
-                        *phIf = pIf->hIf;
-                        Log(("intnetR0NetworkCreateIf: returns VINF_SUCCESS *phIf=%RX32 cbSend=%u cbRecv=%u cbBuf=%u\n",
-                             *phIf, pIf->pIntBufDefault->cbSend, pIf->pIntBufDefault->cbRecv, pIf->pIntBufDefault->cbBuf));
-                        return VINF_SUCCESS;
+                        rc = RTHandleTableAllocWithCtx(pNetwork->pIntNet->hHtIfs, pIf, pSession, (uint32_t *)&pIf->hIf);
+                        if (RT_SUCCESS(rc))
+                        {
+                            *phIf = pIf->hIf;
+                            Log(("intnetR0NetworkCreateIf: returns VINF_SUCCESS *phIf=%RX32 cbSend=%u cbRecv=%u cbBuf=%u\n",
+                                 *phIf, pIf->pIntBufDefault->cbSend, pIf->pIntBufDefault->cbRecv, pIf->pIntBufDefault->cbBuf));
+                            return VINF_SUCCESS;
+                        }
+
+                        SUPR0ObjRelease(pIf->pvObj, pSession);
+                        LogFlow(("intnetR0NetworkCreateIf: returns %Rrc\n", rc));
+                        return rc;
                     }
 
-                    SUPR0ObjRelease(pIf->pvObj, pSession);
-                    LogFlow(("intnetR0NetworkCreateIf: returns %Rrc\n", rc));
-                    return rc;
+                    SUPR0ObjRelease(pNetwork->pvObj, pSession);
                 }
 
@@ -3562 +3566 @@
     RTMemFree(pIf);
     LogFlow(("intnetR0NetworkCreateIf: returns %Rrc\n", rc));
-    *pfCloseNetwork = true;
     return rc;
 }
@@ -3840 +3843 @@
      * Free up the resources.
      */
-    RTSEMFASTMUTEX FastMutex = pThis->FastMutex;
-    pThis->FastMutex = NIL_RTSEMFASTMUTEX;
+    RTSEMFASTMUTEX hFastMutex = pThis->FastMutex;
+    pThis->FastMutex = NIL_RTSEMMUTEX;
     pThis->pNetwork = NULL;
-    RTSemFastMutexRelease(FastMutex);
-    RTSemFastMutexDestroy(FastMutex);
+    RTSemFastMutexRelease(hFastMutex);
+    RTSemFastMutexDestroy(hFastMutex);
     RTMemFree(pThis);
 }
@@ -3953 +3956 @@
 
 /**
- * Close a network which was opened/created using intnetR0OpenNetwork()/intnetR0CreateNetwork().
- *
- * @param   pNetwork    The network to close.
- * @param   pSession    The session handle.
- */
-static int intnetR0NetworkClose(PINTNETNETWORK pNetwork, PSUPDRVSESSION pSession)
-{
-    LogFlow(("intnetR0NetworkClose: pNetwork=%p pSession=%p\n", pNetwork, pSession));
-    AssertPtrReturn(pSession, VERR_INVALID_PARAMETER);
-    AssertPtrReturn(pNetwork, VERR_INVALID_PARAMETER);
-
-    int rc = SUPR0ObjRelease(pNetwork->pvObj, pSession);
-    LogFlow(("intnetR0NetworkClose: return %Rrc\n", rc));
-    return rc;
-}
-
-
-/**
  * Object destructor callback.
  * This is called for reference counted objectes when the count reaches 0.
@@ -3986 +3971 @@
 
     /* take the create/destroy sem. */
-    RTSemFastMutexRequest(pIntNet->FastMutex);
+    RTSemMutexRequest(pIntNet->hMtxCreateOpenDestroy, RT_INDEFINITE_WAIT);
 
     /*
@@ -4014 +3999 @@
 
     /*
-     * Because of the undefined order of the per session object dereferencing when closing a session,
-     * we have to handle the case where the network is destroyed before the interfaces. We'll
-     * deal with this by simply orphaning the interfaces.
+     * Because of the undefined order of the per session object dereferencing
+     * when closing a session, we have to handle the case where the network is
+     * destroyed before the interfaces.
+     * We deal with this simply by orphaning the interfaces.
      */
     RTSemFastMutexRequest(pNetwork->FastMutex2);
 
-    PINTNETIF pCur = pNetwork->pIFs;
+    PINTNETIF pCur = pNetwork->pIfs;
     while (pCur)
     {
@@ -4050 +4036 @@
 
     /* release the create/destroy sem. (can be done before trunk destruction.) */
-    RTSemFastMutexRelease(pIntNet->FastMutex);
+    RTSemMutexRelease(pIntNet->hMtxCreateOpenDestroy);
 }
 
@@ -4056 +4042 @@
 /**
  * Opens an existing network.
+ *
+ * The call must own the INTNET::hMtxCreateOpenDestroy.
  *
  * @returns VBox status code.
@@ -4137 +4125 @@
             return rc;
         }
+
         pCur = pCur->pNext;
     }
@@ -4148 +4137 @@
  * Creates a new network.
  *
- * The call must own the INTNET::FastMutex and has already attempted
+ * The call must own the INTNET::hMtxCreateOpenDestroy and has already attempted
  * opening the network and found it to be non-existing.
  *
@@ -4159 +4148 @@
  * @param   pszTrunk        The trunk name. Its meaning is specfic to the type.
  * @param   fFlags          Flags, see INTNET_OPEN_FLAGS_*.
- * @param   ppNetwork       Where to store the network. In the case of failure whatever is returned
- *                          here should be dereferenced outside the INTNET::FastMutex.
+ * @param   ppNetwork       Where to store the network. In the case of failure
+ *                          whatever is returned here should be dereferenced
+ *                          outside the INTNET::hMtxCreateOpenDestroy.
  */
 static int intnetR0CreateNetwork(PINTNET pIntNet, PSUPDRVSESSION pSession, const char *pszNetwork, INTNETTRUNKTYPE enmTrunkType,
@@ -4190 +4180 @@
     if (RT_SUCCESS(rc))
     {
-        //pNew->pIFs = NULL;
-        pNew->pIntNet = pIntNet;
-        //pNew->cActiveIFs = 0;
-        pNew->fFlags = fFlags;
-        size_t cchName = strlen(pszNetwork);
-        pNew->cchName = (uint8_t)cchName;
+        //pNew->pIfs        = NULL;
+        pNew->pIntNet       = pIntNet;
+        //pNew->cActiveIFs  = 0;
+        pNew->fFlags        = fFlags;
+        size_t cchName      = strlen(pszNetwork);
+        pNew->cchName       = (uint8_t)cchName;
         Assert(cchName && cchName < sizeof(pNew->szName));  /* caller's responsibility. */
         memcpy(pNew->szName, pszNetwork, cchName);          /* '\0' by alloc. */
-        pNew->enmTrunkType = enmTrunkType;
+        pNew->enmTrunkType  = enmTrunkType;
         Assert(strlen(pszTrunk) < sizeof(pNew->szTrunk));   /* caller's responsibility. */
         strcpy(pNew->szTrunk, pszTrunk);
         if (fFlags & INTNET_OPEN_FLAGS_SHARED_MAC_ON_WIRE)
-            pNew->pbTmp = RT_ALIGN_PT(pNew + 1, 64, uint8_t *);
+            pNew->pbTmp     = RT_ALIGN_PT(pNew + 1, 64, uint8_t *);
         //else
-        //    pNew->pbTmp = NULL;
+        //    pNew->pbTmp   = NULL;
 
         /*
@@ -4216 +4206 @@
 
             /*
-             * Check if the current session is actually allowed to create and open
-             * the network. It is possible to implement network name based policies
-             * and these must be checked now. SUPR0ObjRegister does no such checks.
+             * Check if the current session is actually allowed to create and
+             * open the network.  It is possible to implement network name
+             * based policies and these must be checked now.  SUPR0ObjRegister
+             * does no such checks.
              */
             rc = SUPR0ObjVerifyAccess(pNew->pvObj, pSession, pNew->szName);
@@ -4235 +4226 @@
             }
 
-            /*
-             * We unlink it here so it cannot be opened when the caller leaves
-             * INTNET::FastMutex before dereferencing it.
-             */
-            Assert(pIntNet->pNetworks == pNew);
-            pIntNet->pNetworks = pNew->pNext;
-            pNew->pNext = NULL;
-
-            *ppNetwork = pNew;
+            SUPR0ObjRelease(pNew->pvObj, pSession);
             LogFlow(("intnetR0CreateNetwork: returns %Rrc\n", rc));
             return rc;
@@ -4324 +4307 @@
 
     /*
-     * Acquire the mutex to serialize open/create.
-     */
-    int rc = RTSemFastMutexRequest(pIntNet->FastMutex);
+     * Acquire the mutex to serialize open/create/close.
+     */
+    int rc = RTSemMutexRequest(pIntNet->hMtxCreateOpenDestroy, RT_INDEFINITE_WAIT);
     if (RT_FAILURE(rc))
         return rc;
@@ -4333 +4316 @@
      * Try open / create the network and create an interface on it for the
      * caller to use.
-     *
-     * Note! Because of the destructors grabbing INTNET::FastMutex and us being
-     * required to own this semaphore for the entire network opening / creation
-     * and interface creation sequence, intnetR0CreateNetwork will have to
-     * defer the network cleanup to us on failure.
      */
     PINTNETNETWORK pNetwork = NULL;
     rc = intnetR0OpenNetwork(pIntNet, pSession, pszNetwork, enmTrunkType, pszTrunk, fFlags, &pNetwork);
-    if (RT_SUCCESS(rc) || rc == VERR_NOT_FOUND)
-    {
-        bool fCloseNetwork = true;
-        bool fNewNet = rc == VERR_NOT_FOUND;
-        if (fNewNet)
-            rc = intnetR0CreateNetwork(pIntNet, pSession, pszNetwork, enmTrunkType, pszTrunk, fFlags, &pNetwork);
+    if (RT_SUCCESS(rc))
+    {
+        rc = intnetR0NetworkCreateIf(pNetwork, pSession, cbSend, cbRecv, phIf);
         if (RT_SUCCESS(rc))
-            rc = intnetR0NetworkCreateIf(pNetwork, pSession, cbSend, cbRecv, &fCloseNetwork, phIf);
-
-        RTSemFastMutexRelease(pIntNet->FastMutex);
-
-        if (RT_FAILURE(rc))
+            rc = VINF_ALREADY_INITIALIZED;
+        SUPR0ObjRelease(pNetwork->pvObj, pSession);
+    }
+    else if (rc == VERR_NOT_FOUND)
+    {
+        rc = intnetR0CreateNetwork(pIntNet, pSession, pszNetwork, enmTrunkType, pszTrunk, fFlags, &pNetwork);
+        if (RT_SUCCESS(rc))
         {
-            if(pNetwork && fCloseNetwork)
-                intnetR0NetworkClose(pNetwork, pSession);
+            rc = intnetR0NetworkCreateIf(pNetwork, pSession, cbSend, cbRecv, phIf);
+            SUPR0ObjRelease(pNetwork->pvObj, pSession);
         }
-        else if(!fNewNet)
-            rc = VINF_ALREADY_INITIALIZED;
-    }
-    else
-        RTSemFastMutexRelease(pIntNet->FastMutex);
-
+    }
+
+    RTSemMutexRelease(pIntNet->hMtxCreateOpenDestroy);
     LogFlow(("INTNETR0Open: return %Rrc *phIf=%RX32\n", rc, *phIf));
     return rc;
@@ -4405 +4379 @@
      */
     Assert(pIntNet->pNetworks == NULL);
-    if (pIntNet->FastMutex != NIL_RTSEMFASTMUTEX)
-    {
-        RTSemFastMutexDestroy(pIntNet->FastMutex);
-        pIntNet->FastMutex = NIL_RTSEMFASTMUTEX;
+    if (pIntNet->hMtxCreateOpenDestroy != NIL_RTSEMMUTEX)
+    {
+        RTSemMutexDestroy(pIntNet->hMtxCreateOpenDestroy);
+        pIntNet->hMtxCreateOpenDestroy = NIL_RTSEMMUTEX;
     }
     if (pIntNet->hHtIfs != NIL_RTHANDLETABLE)
@@ -4436 +4410 @@
         //pIntNet->pNetworks = NULL;
 
-        rc = RTSemFastMutexCreate(&pIntNet->FastMutex);
+        rc = RTSemMutexCreate(&pIntNet->hMtxCreateOpenDestroy);
         if (RT_SUCCESS(rc))
         {
@@ -4448 +4422 @@
             }
 
-            RTSemFastMutexDestroy(pIntNet->FastMutex);
+            RTSemMutexDestroy(pIntNet->hMtxCreateOpenDestroy);
         }
         RTMemFree(pIntNet);