VirtualBox

Changeset 13604 in vbox for trunk/src/VBox/Devices


Ignore:
Timestamp:
Oct 28, 2008 4:47:11 AM (16 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
38512
Message:

Synchronized slirp was inroduced

Location:
trunk/src/VBox/Devices
Files:
12 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Devices/Makefile.kmk

    r13435 r13604  
    531531ifdef VBOX_WITH_NETFLT
    532532Drivers_DEFS       = VBOX_WITH_NETFLT
     533endif
     534ifdef VBOX_WITH_SYNC_SLIRP
     535Drivers_DEFS       = VBOX_WITH_SYNC_SLIRP
    533536endif
    534537Drivers_INCS      := \

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

    r13237 r13604  
    5656#ifdef VBOX_NAT_SOURCES
    5757#include "Network/nat/nat.h"
     58#endif
     59
     60#ifdef VBOX_WITH_SYNC_SLIRP
     61#include <iprt/semaphore.h>
    5862#endif
    5963
    … …  
    8791    /** Boot file name to provide in the DHCP server response. */
    8892    char                    *pszBootFile;
     93#ifdef VBOX_WITH_SYNC_SLIRP
     94    /*polling thread*/
     95    PPDMTHREAD              pThread;
     96    /*used for wakep of poling thread*/
     97    RTSEMEVENT               semIOmutex;
     98#endif
    8999} DRVNAT, *PDRVNAT;
    90100
    … …  
    143153          pvBuf, cb, cb, pvBuf));
    144154
     155#ifndef VBOX_WITH_SYNC_SLIRP
    145156    int rc = RTCritSectEnter(&pThis->CritSect);
    146157    AssertReleaseRC(rc);
     158#endif
    147159
    148160    Assert(pThis->enmLinkState == PDMNETWORKLINKSTATE_UP);
    … …  
    154166#endif
    155167    }
     168#ifndef VBOX_WITH_SYNC_SLIRP
    156169    RTCritSectLeave(&pThis->CritSect);
     170#endif
    157171    LogFlow(("drvNATSend: end\n"));
    158172    return VINF_SUCCESS;
    … …  
    190204    LogFlow(("drvNATNotifyLinkChanged: enmLinkState=%d\n", enmLinkState));
    191205
     206#ifndef VBOX_WITH_SYNC_SLIRP
    192207    int rc = RTCritSectEnter(&pThis->CritSect);
    193208    AssertReleaseRC(rc);
     209#endif
    194210    pThis->enmLinkState = enmLinkState;
    195211
    … …  
    214230            AssertMsgFailed(("drvNATNotifyLinkChanged: unexpected link state %d\n", enmLinkState));
    215231    }
     232#ifndef VBOX_WITH_SYNC_SLIRP
    216233    RTCritSectLeave(&pThis->CritSect);
     234#endif
    217235}
    218236
    … …  
    221239 * Poller callback.
    222240 */
     241#ifndef VBOX_WITH_SYNC_SLIRP
    223242static DECLCALLBACK(void) drvNATPoller(PPDMDRVINS pDrvIns)
    224243{
    … …  
    254273    RTCritSectLeave(&pThis->CritSect);
    255274}
     275#else
     276
     277static DECLCALLBACK(int) drvNATAsyncIoThread(PPDMDRVINS pDrvIns, PPDMTHREAD pThread)
     278{
     279    PDRVNAT pThis = PDMINS_2_DATA(pDrvIns, PDRVNAT);
     280    fd_set  ReadFDs;
     281    fd_set  WriteFDs;
     282    fd_set  XcptFDs;
     283    int     cFDs = -1;
     284    int     rc;
     285
     286    LogFlow(("drvNATAsyncIoThread: pThis=%p\n", pThis));
     287
     288
     289    if (pThread->enmState == PDMTHREADSTATE_INITIALIZING)
     290        return VINF_SUCCESS;
     291    /*
     292     * Polling loop.
     293     */
     294    while (pThread->enmState == PDMTHREADSTATE_RUNNING)
     295    {
     296        FD_ZERO(&ReadFDs);
     297        FD_ZERO(&WriteFDs);
     298        FD_ZERO(&XcptFDs);
     299        cFDs = -1;
     300
     301        slirp_select_fill(pThis->pNATState, &cFDs, &ReadFDs, &WriteFDs, &XcptFDs);
     302
     303        struct timeval tv = {0, 0}; /* no wait */
     304
     305        int cReadFDs = select(cFDs + 1, &ReadFDs, &WriteFDs, &XcptFDs, &tv);
     306
     307        if (cReadFDs >= 0)
     308            slirp_select_poll(pThis->pNATState, &ReadFDs, &WriteFDs, &XcptFDs);
     309
     310#if 0
     311        if (cReadFDs == 0) {
     312            rc = RTSemEventWait(pThis->semIOmutex, RT_INDEFINITE_WAIT);
     313            AssertReleaseRC(rc);
     314        }
     315#endif
     316    }
     317
     318}
     319 /**
     320 *  Unblock the send thread so it can respond to a state change.
     321 *
     322 *  @returns VBox status code.
     323 *  @param   pDevIns     The pcnet device instance.
     324 *  @param   pThread     The send thread.
     325 */
     326static DECLCALLBACK(int) drvNATAsyncIoWakeup(PPDMDRVINS pDrvIns, PPDMTHREAD pThread)
     327{
     328#if 0
     329    PDRVNAT pThis = PDMINS_2_DATA(pDrvIns, PDRVNAT);
     330    int rc = RTSemEventSignal(pThis->semIOmutex);
     331    AssertReleaseRC(rc);
     332#endif
     333    return (VINF_SUCCESS);
     334}
     335
     336#endif
    256337
    257338#ifndef VBOX_NAT_SOURCES
    … …  
    267348    Assert(pThis);
    268349
     350#ifndef VBOX_WITH_SYNC_SLIRP
    269351    /** Happens during termination */
    270352    if (!RTCritSectIsOwner(&pThis->CritSect))
    271353        return 0;
     354#endif
    272355
    273356    int rc =  pThis->pPort->pfnWaitReceiveAvail(pThis->pPort, 0);
    … …  
    291374    Assert(pThis);
    292375
     376#ifndef VBOX_WITH_SYNC_SLIRP
    293377    /** Happens during termination */
    294378    if (!RTCritSectIsOwner(&pThis->CritSect))
    295379        return;
     380#endif
    296381
    297382    int rc = pThis->pPort->pfnReceive(pThis->pPort, pu8Buf, cb);
    … …  
    591676                                               NULL, NULL, NULL, NULL, NULL, drvNATLoadDone);
    592677                    AssertRC(rc2);
     678#ifndef VBOX_WITH_SYNC_SLIRP
    593679                    pDrvIns->pDrvHlp->pfnPDMPollerRegister(pDrvIns, drvNATPoller);
     680#else
     681                    rc = RTSemEventCreate(&pThis->semIOmutex);
     682                    AssertReleaseRC(rc);
     683                    rc = PDMDrvHlpPDMThreadCreate(pDrvIns, &pThis->pThread, pThis, drvNATAsyncIoThread, drvNATAsyncIoWakeup, 128 * _1K, RTTHREADTYPE_IO, "NAT");
     684                    AssertReleaseRC(rc);
     685#endif
    594686
    595687                    pThis->enmLinkState = PDMNETWORKLINKSTATE_UP;

  • trunk/src/VBox/Devices/Network/slirp/if.c

    r1076 r13604  
    4848        if_comp = IF_AUTOCOMP;
    4949        if_fastq.ifq_next = if_fastq.ifq_prev = &if_fastq;
     50#ifdef VBOX_WITH_SYNC_SLIRP
     51        RTSemMutexCreate(&pData->if_fastq_mutex);
     52        RTSemMutexCreate(&if_fastq.m_mutex);
     53#endif
     54
    5055        if_batchq.ifq_next = if_batchq.ifq_prev = &if_batchq;
     56#ifdef VBOX_WITH_SYNC_SLIRP
     57        RTSemMutexCreate(&pData->if_batchq_mutex);
     58        RTSemMutexCreate(&if_batchq.m_mutex);
     59#endif
    5160        /*      sl_compress_init(&comp_s); */
    5261        next_m = &if_batchq;
    … …  
    149158{
    150159        struct mbuf *ifq;
     160#ifdef VBOX_WITH_SYNC_SLIRP
     161        struct mbuf *ifqprev;
     162#endif
    151163        int on_fastq = 1;
    152164
    … …  
    154166        DEBUG_ARG("so = %lx", (long)so);
    155167        DEBUG_ARG("ifm = %lx", (long)ifm);
     168#ifdef VBOX_WITH_SYNC_SLIRP
     169    if (so != NULL)
     170        RTSemMutexRequest(so->so_mutex, RT_INDEFINITE_WAIT);
     171#endif
    156172
    157173        /*
    … …  
    160176         * XXX Shouldn't need this, gotta change dtom() etc.
    161177         */
     178#ifdef VBOX_WITH_SYNC_SLIRP
     179        RTSemMutexRequest(pData->m_usedlist_mutex, RT_INDEFINITE_WAIT);
     180        RTSemMutexRequest(ifm->m_mutex, RT_INDEFINITE_WAIT);
     181#endif
    162182        if (ifm->m_flags & M_USEDLIST) {
    163183                remque(pData, ifm);
    164184                ifm->m_flags &= ~M_USEDLIST;
    165185        }
     186#ifdef VBOX_WITH_SYNC_SLIRP
     187        RTSemMutexRelease(pData->m_usedlist_mutex);
     188#endif
    166189
    167190        /*
    … …  
    172195         * XXX add cache here?
    173196         */
     197#ifndef VBOX_WITH_SYNC_SLIRP
    174198        for (ifq = if_batchq.ifq_prev; ifq != &if_batchq; ifq = ifq->ifq_prev) {
     199#else
     200        RTSemMutexRequest(pData->if_batchq_mutex, RT_INDEFINITE_WAIT);
     201        ifq = if_batchq.ifq_prev;
     202        while(1){
     203            if (ifq == &if_batchq) {
     204                RTSemMutexRelease(pData->if_batchq_mutex);
     205                break;
     206            }
     207            ifqprev = ifq->ifq_prev;
     208            RTSemMutexRequest(ifq->m_mutex, RT_INDEFINITE_WAIT);
     209            RTSemMutexRelease(pData->if_batchq_mutex);
     210#endif
    175211                if (so == ifq->ifq_so) {
    176212                        /* A match! */
    … …  
    179215                        goto diddit;
    180216                }
     217#ifdef VBOX_WITH_SYNC_SLIRP
     218            RTSemMutexRequest(pData->if_batchq_mutex, RT_INDEFINITE_WAIT);
     219            RTSemMutexRelease(ifq->m_mutex);
     220            ifq = ifqprev;
     221#endif
    181222        }
    182223
    183224        /* No match, check which queue to put it on */
    184225        if (so && (so->so_iptos & IPTOS_LOWDELAY)) {
     226#ifdef VBOX_WITH_SYNC_SLIRP
     227                RTSemMutexRequest(pData->if_fastq_mutex, RT_INDEFINITE_WAIT);
     228#endif
    185229                ifq = if_fastq.ifq_prev;
     230#ifdef VBOX_WITH_SYNC_SLIRP
     231                RTSemMutexRequest(ifq->m_mutex, RT_INDEFINITE_WAIT);
     232                RTSemMutexRelease(pData->if_fastq_mutex);
     233#endif
    186234                on_fastq = 1;
    187235                /*
    … …  
    194242                        goto diddit;
    195243                }
    196         } else
     244        }
     245        else {
     246#ifdef VBOX_WITH_SYNC_SLIRP
     247                RTSemMutexRequest(pData->if_batchq_mutex, RT_INDEFINITE_WAIT);
     248#endif
    197249                ifq = if_batchq.ifq_prev;
     250#ifdef VBOX_WITH_SYNC_SLIRP
     251                RTSemMutexRequest(ifq->m_mutex, RT_INDEFINITE_WAIT);
     252                RTSemMutexRelease(pData->if_batchq_mutex);
     253#endif
     254        }
    198255
    199256        /* Create a new doubly linked list for this session */
    … …  
    203260
    204261diddit:
     262#ifdef VBOX_WITH_SYNC_SLIRP
     263    RTSemMutexRequest(pData->if_queued_mutex, RT_INDEFINITE_WAIT);
     264#endif
    205265        ++if_queued;
     266#ifdef VBOX_WITH_SYNC_SLIRP
     267    RTSemMutexRelease(pData->if_queued_mutex);
     268#endif
    206269
    207270        if (so) {
    … …  
    219282                                 (so->so_nqueued - so->so_queued) >= 3)) {
    220283
     284#ifdef VBOX_WITH_SYNC_SLIRP
     285                        RTSemMutexRequest(pData->if_fastq_mutex, RT_INDEFINITE_WAIT);
     286#endif
    221287                        /* Remove from current queue... */
    222288                        remque(pData, ifm->ifs_next);
     289#ifdef VBOX_WITH_SYNC_SLIRP
     290                        RTSemMutexRequest(pData->if_batchq_mutex, RT_INDEFINITE_WAIT);
     291#endif
    223292
    224293                        /* ...And insert in the new.  That'll teach ya! */
    225294                        insque(pData, ifm->ifs_next, &if_batchq);
    226                 }
    227         }
     295#ifdef VBOX_WITH_SYNC_SLIRP
     296                    RTSemMutexRelease(pData->if_fastq_mutex);
     297                    RTSemMutexRelease(pData->if_batchq_mutex);
     298#endif
     299                }
     300                RTSemMutexRelease(so->so_mutex);
     301        }
     302#ifdef VBOX_WITH_SYNC_SLIRP
     303        RTSemMutexRelease(ifq->m_mutex);
     304        RTSemMutexRelease(ifm->m_mutex);
     305#endif
    228306
    229307#ifndef FULL_BOLT
    … …  
    254332{
    255333        struct mbuf *ifm, *ifqt;
     334#ifdef VBOX_WITH_SYNC_SLIRP
     335        int on_fast = 0; /*required for correctness */
     336        struct mbuf *ifm_prev;
     337#endif
    256338
    257339        DEBUG_CALL("if_start");
    258340
    259         if (if_queued == 0)
     341#ifdef VBOX_WITH_SYNC_SLIRP
     342        RTSemMutexRequest(pData->if_queued_mutex, RT_INDEFINITE_WAIT);
     343#endif
     344        if (if_queued <= 0) {
     345#ifdef VBOX_WITH_SYNC_SLIRP
     346            RTSemMutexRelease(pData->if_queued_mutex);
     347#endif
    260348           return; /* Nothing to do */
     349        }
    261350
    262351 again:
     352#ifdef VBOX_WITH_SYNC_SLIRP
     353        RTSemMutexRelease(pData->if_queued_mutex);
     354#endif
    263355        /* check if we can really output */
    264356        if (!slirp_can_output(pData->pvUser))
    … …  
    269361         * If there's something in the fastq, select it immediately
    270362         */
     363#ifdef VBOX_WITH_SYNC_SLIRP
     364        RTSemMutexRequest(pData->if_fastq_mutex, RT_INDEFINITE_WAIT);
     365#endif
    271366        if (if_fastq.ifq_next != &if_fastq) {
    272367                ifm = if_fastq.ifq_next;
     368#ifdef VBOX_WITH_SYNC_SLIRP
     369                on_fast = 1;
     370                RTSemMutexRequest(ifm->m_mutex, RT_INDEFINITE_WAIT);
     371#endif
    273372        } else {
     373#ifdef VBOX_WITH_SYNC_SLIRP
     374                RTSemMutexRelease(pData->if_fastq_mutex);
     375                RTSemMutexRequest(pData->next_m_mutex, RT_INDEFINITE_WAIT);
     376                RTSemMutexRequest(pData->if_batchq_mutex, RT_INDEFINITE_WAIT);
     377#endif
    274378                /* Nothing on fastq, see if next_m is valid */
    275379                if (next_m != &if_batchq)
    … …  
    280384                /* Set which packet to send on next iteration */
    281385                next_m = ifm->ifq_next;
    282         }
     386#ifdef VBOX_WITH_SYNC_SLIRP
     387                RTSemMutexRelease(pData->next_m_mutex);
     388#endif
     389        }
     390#ifdef VBOX_WITH_SYNC_SLIRP
     391        RTSemMutexRequest(ifm->m_mutex, RT_INDEFINITE_WAIT);
     392        RTSemMutexRequest(pData->if_queued_mutex, RT_INDEFINITE_WAIT);
     393#endif
    283394        /* Remove it from the queue */
    284395        ifqt = ifm->ifq_prev;
     396        ifqt = ifm->ifq_prev;
    285397        remque(pData, ifm);
     398
    286399        --if_queued;
     400#ifdef VBOX_WITH_SYNC_SLIRP
     401        RTSemMutexRelease(pData->if_queued_mutex);
     402        if (on_fast == 1) {
     403            RTSemMutexRelease(pData->if_fastq_mutex);
     404        }
     405        else {
     406            RTSemMutexRelease(pData->if_batchq_mutex);
     407        }
     408#endif
    287409
    288410        /* If there are more packets for this session, re-queue them */
    … …  
    294416        /* Update so_queued */
    295417        if (ifm->ifq_so) {
     418#ifndef VBOX_WITH_SYNC_SLIRP
     419            RTSemMutexRequest(ifm->ifq_so->so_mutex, RT_INDEFINITE_WAIT);
     420#endif
    296421                if (--ifm->ifq_so->so_queued == 0)
    297422                   /* If there's no more queued, reset nqueued */
    298423                   ifm->ifq_so->so_nqueued = 0;
     424#ifndef VBOX_WITH_SYNC_SLIRP
     425            RTSemMutexRelease(ifm->ifq_so->so_mutex);
     426#endif
    299427        }
    300428
    301429        /* Encapsulate the packet for sending */
    302430        if_encap(pData, (const uint8_t *)ifm->m_data, ifm->m_len);
     431#ifdef VBOX_WITH_SYNC_SLIRP
     432        RTSemMutexRelease(ifm->m_mutex);
     433#endif
    303434
    304435        m_free(pData, ifm);
    305436
    306         if (if_queued)
     437#ifdef VBOX_WITH_SYNC_SLIRP
     438        RTSemMutexRequest(pData->if_queued_mutex, RT_INDEFINITE_WAIT);
     439        /*We release if_queued_mutex after again label and before return*/
     440#endif
     441        if (if_queued > 0)
    307442           goto again;
    308 }
     443#ifdef VBOX_WITH_SYNC_SLIRP
     444        RTSemMutexRelease(pData->if_queued_mutex);
     445#endif
     446}

  • trunk/src/VBox/Devices/Network/slirp/mbuf.c

    r1076 r13604  
    2525        m_usedlist.m_next = m_usedlist.m_prev = &m_usedlist;
    2626        mbuf_alloced = 0;
     27#ifdef VBOX_WITH_SYNC_SLIRP
     28        RTSemMutexCreate(&pData->m_usedlist_mutex);
     29        RTSemMutexCreate(&pData->m_freelist_mutex);
     30        RTSemMutexCreate(&pData->mbuf_alloced_mutex);
     31#endif
    2732        msize_init(pData);
    2833}
    … …  
    5257        register struct mbuf *m;
    5358        int flags = 0;
     59#ifdef VBOX_WITH_SYNC_SLIRP
     60        int on_free_list = 0;
     61#endif
    5462
    5563        DEBUG_CALL("m_get");
    5664
     65#ifdef VBOX_WITH_SYNC_SLIRP
     66        RTSemMutexRequest(pData->m_freelist_mutex, RT_INDEFINITE_WAIT);
     67#endif
    5768        if (m_freelist.m_next == &m_freelist) {
    5869                m = (struct mbuf *)malloc(msize);
    59                 if (m == NULL) goto end_error;
     70                if (m == NULL) {
     71#ifdef VBOX_WITH_SYNC_SLIRP
     72                    RTSemMutexRelease(pData->m_freelist_mutex);
     73#endif
     74                    goto end_error;
     75                }
     76#ifdef VBOX_WITH_SYNC_SLIRP
     77                RTSemMutexRequest(pData->mbuf_alloced_mutex, RT_INDEFINITE_WAIT);
     78#endif
    6079                mbuf_alloced++;
    6180                if (mbuf_alloced > mbuf_thresh)
    … …  
    6382                if (mbuf_alloced > mbuf_max)
    6483                        mbuf_max = mbuf_alloced;
     84#ifdef VBOX_WITH_SYNC_SLIRP
     85                RTSemMutexRelease(pData->mbuf_alloced_mutex);
     86#endif
    6587        } else {
    6688                m = m_freelist.m_next;
    6789                remque(pData, m);
    6890        }
     91#ifdef VBOX_WITH_SYNC_SLIRP
     92        RTSemMutexRequest(pData->m_usedlist_mutex, RT_INDEFINITE_WAIT);
     93#endif
    6994
    7095        /* Insert it in the used list */
    7196        insque(pData, m,&m_usedlist);
    7297        m->m_flags = (flags | M_USEDLIST);
     98#ifdef VBOX_WITH_SYNC_SLIRP
     99        RTSemMutexCreate(&m->m_mutex);
     100        RTSemMutexRequest(m->m_mutex, RT_INDEFINITE_WAIT);
     101        RTSemMutexRelease(pData->m_usedlist_mutex);
     102        RTSemMutexRelease(pData->m_freelist_mutex);
     103#endif
    73104
    74105        /* Initialise it */
    … …  
    78109        m->m_nextpkt = 0;
    79110        m->m_prevpkt = 0;
     111#ifdef VBOX_WITH_SYNC_SLIRP
     112        RTSemMutexRelease(m->m_mutex);
     113#endif
    80114end_error:
    81115        DEBUG_ARG("m = %lx", (long )m);
    … …  
    92126  if(m) {
    93127        /* Remove from m_usedlist */
    94         if (m->m_flags & M_USEDLIST)
     128#ifdef VBOX_WITH_SYNC_SLIRP
     129        RTSemMutexRequest(m->m_mutex, RT_INDEFINITE_WAIT);
     130#endif
     131        if (m->m_flags & M_USEDLIST) {
     132#ifdef VBOX_WITH_SYNC_SLIRP
     133           RTSemMutexRequest(pData->m_usedlist_mutex, RT_INDEFINITE_WAIT);
     134#endif
    95135           remque(pData, m);
     136#ifdef VBOX_WITH_SYNC_SLIRP
     137           RTSemMutexRelease(pData->m_usedlist_mutex);
     138#endif
     139        }
    96140
    97141        /* If it's M_EXT, free() it */
    … …  
    104148        if (m->m_flags & M_DOFREE) {
    105149                u32ptr_done(pData, ptr_to_u32(pData, m), m);
     150#ifdef VBOX_WITH_SYNC_SLIRP
     151                RTSemMutexRelease(m->m_mutex);
     152                RTSemMutexDestroy(m->m_mutex);
     153#endif
    106154                free(m);
     155#ifdef VBOX_WITH_SYNC_SLIRP
     156                RTSemMutexRequest(pData->mbuf_alloced_mutex, RT_INDEFINITE_WAIT);
    107157                mbuf_alloced--;
     158                RTSemMutexRelease(pData->mbuf_alloced_mutex);
     159#endif
    108160        } else if ((m->m_flags & M_FREELIST) == 0) {
     161#ifdef VBOX_WITH_SYNC_SLIRP
     162                RTSemMutexRequest(pData->m_freelist_mutex, RT_INDEFINITE_WAIT);
     163#endif
    109164                insque(pData, m,&m_freelist);
    110165                m->m_flags = M_FREELIST; /* Clobber other flags */
     166#ifdef VBOX_WITH_SYNC_SLIRP
     167                RTSemMutexRelease(pData->m_freelist_mutex);
     168                RTSemMutexRelease(m->m_mutex);
     169#endif
    111170        }
    112171  } /* if(m) */
    … …  
    124183         * If there's no room, realloc
    125184         */
     185#ifdef VBOX_WITH_SYNC_SLIRP
     186        RTSemMutexRequest(m->m_mutex, RT_INDEFINITE_WAIT);
     187        RTSemMutexRequest(n->m_mutex, RT_INDEFINITE_WAIT);
     188#endif
    126189        if (M_FREEROOM(m) < n->m_len)
    127190                m_inc(m,m->m_size+MINCSIZE);
    … …  
    130193        m->m_len += n->m_len;
    131194
     195#ifdef VBOX_WITH_SYNC_SLIRP
     196        RTSemMutexRelease(m->m_mutex);
     197        RTSemMutexRelease(n->m_mutex);
     198#endif
    132199        m_free(pData, n);
    133200}
    … …  
    143210
    144211        /* some compiles throw up on gotos.  This one we can fake. */
    145         if(m->m_size>size) return;
     212#ifdef VBOX_WITH_SYNC_SLIRP
     213        RTSemMutexRequest(m->m_mutex, RT_INDEFINITE_WAIT);
     214#endif
     215        if(m->m_size>size) {
     216#ifdef VBOX_WITH_SYNC_SLIRP
     217            RTSemMutexRelease(m->m_mutex);
     218#endif
     219            return;
     220        }
    146221
    147222        if (m->m_flags & M_EXT) {
    … …  
    167242
    168243        m->m_size = size;
    169 
     244#ifdef VBOX_WITH_SYNC_SLIRP
     245        RTSemMutexRelease(m->m_mutex);
     246#endif
    170247}
    171248
    … …  
    179256        if (m == NULL)
    180257                return;
     258#ifdef VBOX_WITH_SYNC_SLIRP
     259        RTSemMutexRequest(m->m_mutex, RT_INDEFINITE_WAIT);
     260#endif
    181261        if (len >= 0) {
    182262                /* Trim from head */
    … …  
    188268                m->m_len -= len;
    189269        }
     270#ifdef VBOX_WITH_SYNC_SLIRP
     271        RTSemMutexRelease(m->m_mutex);
     272#endif
    190273}
    191274
    … …  
    199282        int off, len;
    200283{
    201         if (len > M_FREEROOM(n))
     284#ifdef VBOX_WITH_SYNC_SLIRP
     285        RTSemMutexRequest(m->m_mutex, RT_INDEFINITE_WAIT);
     286        RTSemMutexRequest(n->m_mutex, RT_INDEFINITE_WAIT);
     287#endif
     288        if (len > M_FREEROOM(n)) {
     289#ifdef VBOX_WITH_SYNC_SLIRP
     290                RTSemMutexRelease(n->m_mutex);
     291                RTSemMutexRelease(m->m_mutex);
     292#endif
    202293                return -1;
     294        }
    203295
    204296        memcpy((n->m_data + n->m_len), (m->m_data + off), len);
    205297        n->m_len += len;
     298#ifdef VBOX_WITH_SYNC_SLIRP
     299        RTSemMutexRelease(n->m_mutex);
     300        RTSemMutexRelease(m->m_mutex);
     301#endif
    206302        return 0;
    207303}
    … …  
    222318
    223319        /* bug corrected for M_EXT buffers */
     320#ifndef VBOX_WITH_SYNC_SLIRP
    224321        for (m = m_usedlist.m_next; m != &m_usedlist; m = m->m_next) {
     322#else
     323        RTSemMutexRequest(pData->m_usedlist_mutex, RT_INDEFINITE_WAIT);
     324        m = m_usedlist.m_next;
     325        while(1) {
     326            RTSemMutexRequest(m->m_mutex, RT_INDEFINITE_WAIT);
     327            RTSemMutexRelease(pData->m_usedlist_mutex);
     328#endif
    225329          if (m->m_flags & M_EXT) {
    226             if( (char *)dat>=m->m_ext && (char *)dat<(m->m_ext + m->m_size) )
     330            if( (char *)dat>=m->m_ext && (char *)dat<(m->m_ext + m->m_size) ) {
     331#ifdef VBOX_WITH_SYNC_SLIRP
     332              RTSemMutexRelease(m->m_mutex);
     333#endif
    227334              return m;
     335            }
    228336          } else {
    229             if( (char *)dat >= m->m_dat && (char *)dat<(m->m_dat + m->m_size) )
     337            if( (char *)dat >= m->m_dat && (char *)dat<(m->m_dat + m->m_size) ) {
     338#ifdef VBOX_WITH_SYNC_SLIRP
     339              RTSemMutexRelease(m->m_mutex);
     340#endif
    230341              return m;
     342            }
    231343          }
     344#ifdef VBOX_WITH_SYNC_SLIRP
     345          RTSemMutexRelease(m->m_mutex);
     346          RTSemMutexRequest(pData->m_usedlist_mutex, RT_INDEFINITE_WAIT);
     347          m = m->m_next;
     348#endif
    232349        }
    233350

  • trunk/src/VBox/Devices/Network/slirp/mbuf.h

    r1076 r13604  
    3737#ifndef _MBUF_H_
    3838#define _MBUF_H_
     39#ifdef VBOX_WITH_SYNC_SLIRP
     40#include <iprt/semaphore.h>
     41#endif
    3942
    4043#define m_freem m_free
    … …  
    7376        caddr_t mh_data;                /* Location of data */
    7477        int     mh_len;                 /* Amount of data in this mbuf */
     78#ifdef VBOX_WITH_SYNC_SLIRP
     79        RTSEMMUTEX mh_mutex;
     80#endif
    7581};
    7682
    … …  
    108114#define m_ext           M_dat.m_ext_
    109115#define m_so            m_hdr.mh_so
     116#ifdef VBOX_WITH_SYNC_SLIRP
     117#define m_mutex         m_hdr.mh_mutex
     118#endif
    110119
    111120#define ifq_prev m_prev

  • trunk/src/VBox/Devices/Network/slirp/slirp.c

    r9150 r13604  
    66#include <VBox/err.h>
    77#include <iprt/assert.h>
     8#ifdef VBOX_WITH_SYNC_SLIRP
     9#include <iprt/semaphore.h>
     10#endif
    811
    912static const uint8_t special_ethaddr[6] = {
    … …  
    200203{
    201204    int fNATfailed = 0;
     205#ifdef VBOX_WITH_SYNC_SLIRP
     206    int rc = 0;
     207#endif
    202208    PNATState pData = malloc(sizeof(NATState));
    203209    *ppData = pData;
    … …  
    222228        WSAStartup(MAKEWORD(2,0), &Data);
    223229    }
     230#endif
     231
     232#ifdef VBOX_WITH_SYNC_SLIRP
     233    rc = RTSemMutexCreate(&pData->tcb_mutex);
     234    AssertReleaseRC(rc);
     235    rc = RTSemMutexCreate(&pData->udb_mutex);
     236    AssertReleaseRC(rc);
     237    rc = RTSemMutexCreate(&pData->if_queued_mutex);
     238    AssertReleaseRC(rc);
     239    rc = RTSemMutexCreate(&pData->next_m_mutex);
     240    AssertReleaseRC(rc);
    224241#endif
    225242
    … …  
    358375                 * in the fragment queue, or there are TCP connections active
    359376                 */
     377#ifndef VBOX_WITH_SYNC_SLIRP
    360378                do_slowtimo = ((tcb.so_next != &tcb) ||
    361379                               ((struct ipasfrag *)&ipq != u32_to_ptr(pData, ipq.next, struct ipasfrag *)));
    … …  
    363381                for (so = tcb.so_next; so != &tcb; so = so_next) {
    364382                        so_next = so->so_next;
     383#else
     384                RTSemMutexRequest(pData->tcb_mutex, RT_INDEFINITE_WAIT);
     385                so = tcb.so_next;
     386                do_slowtimo = ((so != &tcb) ||
     387                               ((struct ipasfrag *)&ipq != u32_to_ptr(pData, ipq.next, struct ipasfrag *)));
     388                while (1) {
     389                    if (so == &tcb) {
     390                        RTSemMutexRelease(pData->tcb_mutex);
     391                        break;
     392                    }
     393                    so_next = so->so_next;
     394                    RTSemMutexRequest(so->so_mutex, RT_INDEFINITE_WAIT);
     395                    RTSemMutexRelease(pData->tcb_mutex);
     396#endif
    365397
    366398                        /*
    … …  
    375407                         */
    376408                        if (so->so_state & SS_NOFDREF || so->s == -1)
    377                            continue;
     409#ifndef VBOX_WITH_SYNC_SLIRP
     410                                continue;
     411#else
     412                                goto before_loop_ends;
     413#endif
    378414
    379415                        /*
    … …  
    383419                                FD_SET(so->s, readfds);
    384420                                UPD_NFDS(so->s);
     421#ifndef VBOX_WITH_SYNC_SLIRP
    385422                                continue;
     423#else
     424                                goto before_loop_ends;
     425#endif
    386426                        }
    387427
    … …  
    392432                                FD_SET(so->s, writefds);
    393433                                UPD_NFDS(so->s);
     434#ifndef VBOX_WITH_SYNC_SLIRP
    394435                                continue;
     436#else
     437                                goto before_loop_ends;
     438#endif
    395439                        }
    396440
    … …  
    413457                                UPD_NFDS(so->s);
    414458                        }
     459#ifdef VBOX_WITH_SYNC_SLIRP
     460                before_loop_ends:
     461                        /*Release of global tcb mutex happens in the head of loop*/
     462                        RTSemMutexRequest(pData->tcb_mutex, RT_INDEFINITE_WAIT);
     463                        RTSemMutexRelease(so->so_mutex);
     464                        so = so_next;
     465#endif
    415466                }
    416467
    … …  
    418469                 * UDP sockets
    419470                 */
     471#ifndef VBOX_WITH_SYNC_SLIRP
    420472                for (so = udb.so_next; so != &udb; so = so_next) {
    421473                        so_next = so->so_next;
     474#else
     475                RTSemMutexRequest(pData->udb_mutex, RT_INDEFINITE_WAIT);
     476                so = udb.so_next;
     477                while(1) {
     478                    if (so == &udb) {
     479                        RTSemMutexRelease(pData->udb_mutex);
     480                        break;
     481                    }
     482                so_next = so->so_next;
     483                RTSemMutexRequest(so->so_mutex, RT_INDEFINITE_WAIT);
     484                RTSemMutexRelease(pData->udb_mutex);
     485#endif
    422486
    423487                        /*
    … …  
    427491                                if (so->so_expire <= curtime) {
    428492                                        udp_detach(pData, so);
     493#ifndef VBOX_WITH_SYNC_SLIRP
    429494                                        continue;
     495#else
     496                                        goto before_udp_loop_end;
     497#endif
    430498                                } else
    431499                                        do_slowtimo = 1; /* Let socket expire */
    … …  
    446514                                UPD_NFDS(so->s);
    447515                        }
     516#ifdef VBOX_WITH_SYNC_SLIRP
     517                        before_udp_loop_end:
     518                        RTSemMutexRequest(pData->udb_mutex, RT_INDEFINITE_WAIT);
     519                        RTSemMutexRelease(so->so_mutex);
     520                        so = so_next;
     521#endif
    448522                }
    449523        }
    … …  
    515589                 * Check TCP sockets
    516590                 */
     591#ifndef VBOX_WITH_SYNC_SLIRP
    517592                for (so = tcb.so_next; so != &tcb; so = so_next) {
    518593                        so_next = so->so_next;
     594#else
     595                RTSemMutexRequest(pData->tcb_mutex, RT_INDEFINITE_WAIT);
     596                so = tcb.so_next;
     597                while (1) {
     598                    if (so == &tcb) {
     599                        RTSemMutexRelease(pData->tcb_mutex);
     600                        break;
     601                    }
     602                so_next = so->so_next;
     603                RTSemMutexRequest(so->so_mutex, RT_INDEFINITE_WAIT);
     604                RTSemMutexRelease(pData->tcb_mutex);
     605#endif
    519606
    520607                        /*
    … …  
    523610                         */
    524611                        if (so->so_state & SS_NOFDREF || so->s == -1)
    525                            continue;
     612#ifndef VBOX_WITH_SYNC_SLIRP
     613                                continue;
     614#else
     615                                goto before_loop_ends;
     616#endif
    526617
    527618                        /*
    … …  
    541632                                if (so->so_state & SS_FACCEPTCONN) {
    542633                                        tcp_connect(pData, so);
    543                                         continue;
     634#ifndef VBOX_WITH_SYNC_SLIRP
     635                                        continue;
     636#else
     637                                        goto before_loop_ends;
     638#endif
    544639                                } /* else */
    545640                                ret = soread(pData, so);
    … …  
    573668                              if (errno == EAGAIN || errno == EWOULDBLOCK ||
    574669                                  errno == EINPROGRESS || errno == ENOTCONN)
    575                                 continue;
     670#ifndef VBOX_WITH_SYNC_SLIRP
     671                                        continue;
     672#else
     673                                        goto before_loop_ends;
     674#endif
    576675
    577676                              /* else failed */
    … …  
    608707                            if (errno == EAGAIN || errno == EWOULDBLOCK ||
    609708                                errno == EINPROGRESS || errno == ENOTCONN)
    610                               continue; /* Still connecting, continue */
     709#ifndef VBOX_WITH_SYNC_SLIRP
     710                                        continue;/* Still connecting, continue */
     711#else
     712                                        goto before_loop_ends;
     713#endif
    611714
    612715                            /* else failed */
    … …  
    620723                              if (errno == EAGAIN || errno == EWOULDBLOCK ||
    621724                                  errno == EINPROGRESS || errno == ENOTCONN)
    622                                 continue;
     725#ifndef VBOX_WITH_SYNC_SLIRP
     726                                        continue;
     727#else
     728                                        goto before_loop_ends;
     729#endif
    623730                              /* else failed */
    624731                              so->so_state = SS_NOFDREF;
    … …  
    629736                          tcp_input((struct mbuf *)NULL, sizeof(struct ip),so);
    630737                        } /* SS_ISFCONNECTING */
     738#endif
     739#ifdef VBOX_WITH_SYNC_SLIRP
     740                    before_loop_ends:
     741                    RTSemMutexRequest(pData->tcb_mutex, RT_INDEFINITE_WAIT);
     742                    RTSemMutexRelease(so->so_mutex);
     743                    so = so_next;
    631744#endif
    632745                }
    … …  
    637750                 * Incoming UDP data isn't buffered either.
    638751                 */
     752#ifndef VBOX_WITH_SYNC_SLIRP
    639753                for (so = udb.so_next; so != &udb; so = so_next) {
    640754                        so_next = so->so_next;
     755#else
     756                RTSemMutexRequest(pData->udb_mutex, RT_INDEFINITE_WAIT);
     757                so = udb.so_next;
     758                while(1) {
     759                    if (so == &udb) {
     760                        RTSemMutexRelease(pData->udb_mutex);
     761                        break;
     762                    }
     763                    so_next = so->so_next;
     764                    RTSemMutexRequest(so->so_mutex, RT_INDEFINITE_WAIT);
     765                    RTSemMutexRelease(pData->udb_mutex);
     766#endif
    641767
    642768                        if (so->s != -1 && FD_ISSET(so->s, readfds)) {
    643769                            sorecvfrom(pData, so);
    644770                        }
     771#ifdef VBOX_WITH_SYNC_SLIRP
     772                    RTSemMutexRequest(pData->udb_mutex, RT_INDEFINITE_WAIT);
     773                    RTSemMutexRelease(so->so_mutex);
     774                    so = so_next;
     775#endif
    645776                }
    646777        }
    … …  
    649780         * See if we can start outputting
    650781         */
     782#ifndef VBOX_WITH_SYNC_SLIRP
    651783        if (if_queued && link_up)
    652784           if_start(pData);
     785#else
     786#if 0
     787        if (link_up) {
     788            RTSemMutexRequest(pData->if_queued_mutex, RT_INDEFINITE_WAIT);
     789            if (if_queued > 0){
     790                RTSemMutexRelease(pData->if_queued_mutex);
     791                if_start(pData);
     792            }
     793            else {
     794                RTSemMutexRelease(pData->if_queued_mutex);
     795            }
     796        }
     797#endif
     798#endif
    653799}
    654800

  • trunk/src/VBox/Devices/Network/slirp/slirp_state.h

    r8155 r13604  
    2121#ifndef _slirp_state_h_
    2222#define _slirp_state_h_
     23#ifndef VBOX_WITH_SYNC_SLIRP
     24#include <iprt/semaphore.h>
     25#endif
    2326
    2427/** Number of DHCP clients supported by NAT. */
    … …  
    6164    int if_maxlinkhdr;
    6265    int if_queued;
     66#ifdef VBOX_WITH_SYNC_SLIRP
     67    RTSEMMUTEX  if_queued_mutex;
     68#endif
    6369    int if_thresh;
    6470    struct mbuf if_fastq;
     71#ifdef VBOX_WITH_SYNC_SLIRP
     72    RTSEMMUTEX  if_fastq_mutex;
     73#endif
    6574    struct mbuf if_batchq;
     75#ifdef VBOX_WITH_SYNC_SLIRP
     76    RTSEMMUTEX  if_batchq_mutex;
     77#endif
    6678    struct mbuf *next_m;
     79#ifdef VBOX_WITH_SYNC_SLIRP
     80    RTSEMMUTEX  next_m_mutex;
     81#endif
    6782    /* Stuff from icmp.c */
    6883    struct icmpstat_t icmpstat;
    … …  
    7388    /* Stuff from mbuf.c */
    7489    int mbuf_alloced, mbuf_max;
     90#ifdef VBOX_WITH_SYNC_SLIRP
     91    RTSEMMUTEX  mbuf_alloced_mutex;
     92#endif
    7593    int msize;
    7694    struct mbuf m_freelist, m_usedlist;
     95#ifdef VBOX_WITH_SYNC_SLIRP
     96    RTSEMMUTEX  m_freelist_mutex;
     97    RTSEMMUTEX  m_usedlist_mutex;
     98#endif
    7799    /* Stuff from slirp.c */
    78100    void *pvUser;
    … …  
    98120    struct socket *tcp_last_so;
    99121    tcp_seq tcp_iss;
     122    RTSEMMUTEX tcb_mutex;
    100123#if ARCH_BITS == 64
    101124    /* Stuff from tcp_subr.c */
    … …  
    116139    struct socket udb;
    117140    struct socket *udp_last_so;
     141    RTSEMMUTEX udb_mutex;
    118142} NATState;
    119143

  • trunk/src/VBox/Devices/Network/slirp/socket.c

    r8009 r13604  
    1212#ifdef __sun__
    1313#include <sys/filio.h>
     14#endif
     15
     16#ifdef VBOX_WITH_SYNC_SLIRP
     17#include <iprt/semaphore.h>
    1418#endif
    1519
    … …  
    6064    so->so_state = SS_NOFDREF;
    6165    so->s = -1;
     66#ifdef VBOX_WITH_SYNC_SLIRP
     67    RTSemMutexCreate(&so->so_mutex);
     68#endif
    6269  }
    6370  return(so);
    … …  
    7077sofree(PNATState pData, struct socket *so)
    7178{
     79#ifndef VBOX_WITH_SYNC_SLIRP
    7280  if (so->so_emu==EMU_RSH && so->extra) {
    7381        sofree(pData, so->extra);
    … …  
    8391  if(so->so_next && so->so_prev)
    8492    remque(pData, so);  /* crashes if so is not in a queue */
     93#else
     94    /*Take global mutexes of udb and tcb, because we dont know which is mutex */
     95    /*XXX: don't forget to set correct so_type in corresponded attach operation */
     96    RTSemMutexRequest(so->so_mutex, RT_INDEFINITE_WAIT);
     97    if (so->so_emu==EMU_RSH && so->extra) {
     98          sofree(pData, so->extra);
     99          so->extra=NULL;
     100    }
     101
     102    if (so->so_type == IPPROTO_UDP) {
     103        RTSemMutexRequest(pData->udb_mutex, RT_INDEFINITE_WAIT);
     104    }
     105    else if (so->so_type == IPPROTO_TCP) {
     106        RTSemMutexRequest(pData->tcb_mutex, RT_INDEFINITE_WAIT);
     107    }
     108    else {
     109        Assert(!"unknown type");
     110    }
     111
     112    if (so == tcp_last_so)
     113      tcp_last_so = &tcb;
     114    else if (so == udp_last_so)
     115      udp_last_so = &udb;
     116
     117    if(so->so_next && so->so_prev)
     118      remque(pData, so);  /* crashes if so is not in a queue */
     119
     120    if (so->so_type == IPPROTO_UDP) {
     121        RTSemMutexRelease(pData->udb_mutex);
     122    }
     123    else if (so->so_type == IPPROTO_TCP) {
     124        RTSemMutexRelease(pData->tcb_mutex);
     125    }
     126    else {
     127        Assert(!"unknown type");
     128    }
     129    /* socket's mutex could be released because socket none accessible via queue anymore*/
     130    RTSemMutexRelease(so->so_mutex);
     131
     132    m_free(pData, so->so_m);
     133
     134
     135    RTSemMutexDestroy(so->so_mutex);
     136#endif
    85137
    86138  free(so);
     139  so = NULL;
    87140}
    88141
    … …  
    101154        int mss = so->so_tcpcb->t_maxseg;
    102155
     156#ifdef VBOX_WITH_SYNC_SLIRP
     157        RTSemMutexRequest(so->so_mutex, RT_INDEFINITE_WAIT);
     158#endif
    103159        DEBUG_CALL("soread");
    104160        DEBUG_ARG("so = %lx", (long )so);
    … …  
    159215#endif
    160216        if (nn <= 0) {
    161                 if (nn < 0 && (errno == EINTR || errno == EAGAIN))
     217                if (nn < 0 && (errno == EINTR || errno == EAGAIN)) {
     218#ifdef VBOX_WITH_SYNC_SLIRP
     219                        RTSemMutexRelease(so->so_mutex);
     220#endif
    162221                        return 0;
     222                }
    163223                else {
    164224                        DEBUG_MISC((dfd, " --- soread() disconnected, nn = %d, errno = %d-%s\n", nn, errno,strerror(errno)));
    165225                        sofcantrcvmore(so);
    166226                        tcp_sockclosed(pData, sototcpcb(so));
     227#ifdef VBOX_WITH_SYNC_SLIRP
     228                        RTSemMutexRelease(so->so_mutex);
     229#endif
    167230                        return -1;
    168231                }
    … …  
    194257        if (sb->sb_wptr >= (sb->sb_data + sb->sb_datalen))
    195258                sb->sb_wptr -= sb->sb_datalen;
     259#ifdef VBOX_WITH_SYNC_SLIRP
     260        RTSemMutexRelease(so->so_mutex);
     261#endif
    196262        return nn;
    197263}
    … …  
    207273sorecvoob(PNATState pData, struct socket *so)
    208274{
     275#ifdef VBOX_WITH_SYNC_SLIRP
     276        RTSemMutexRequest(so->so_mutex, RT_INDEFINITE_WAIT);
     277#endif
    209278        struct tcpcb *tp = sototcpcb(so);
    210279
    … …  
    225294        tcp_output(pData, tp);
    226295        tp->t_force = 0;
     296#ifdef VBOX_WITH_SYNC_SLIRP
     297        RTSemMutexRelease(so->so_mutex);
     298#endif
    227299}
    228300
    … …  
    239311
    240312        int n, len;
     313#ifdef VBOX_WITH_SYNC_SLIRP
     314        RTSemMutexRequest(so->so_mutex, RT_INDEFINITE_WAIT);
     315#endif
    241316
    242317        DEBUG_CALL("sosendoob");
    … …  
    283358                sb->sb_rptr -= sb->sb_datalen;
    284359
     360#ifdef VBOX_WITH_SYNC_SLIRP
     361        RTSemMutexRelease(so->so_mutex);
     362#endif
    285363        return n;
    286364}
    … …  
    297375        int len = sb->sb_cc;
    298376        struct iovec iov[2];
     377#ifdef VBOX_WITH_SYNC_SLIRP
     378        RTSemMutexRequest(so->so_mutex, RT_INDEFINITE_WAIT);
     379#endif
    299380
    300381        DEBUG_CALL("sowrite");
    … …  
    344425#endif
    345426        /* This should never happen, but people tell me it does *shrug* */
    346         if (nn < 0 && (errno == EAGAIN || errno == EINTR))
     427        if (nn < 0 && (errno == EAGAIN || errno == EINTR)) {
     428#ifdef VBOX_WITH_SYNC_SLIRP
     429                RTSemMutexRelease(so->so_mutex);
     430#endif
    347431                return 0;
     432        }
    348433
    349434        if (nn <= 0) {
    … …  
    352437                sofcantsendmore(so);
    353438                tcp_sockclosed(pData, sototcpcb(so));
     439#ifdef VBOX_WITH_SYNC_SLIRP
     440                RTSemMutexRelease(so->so_mutex);
     441#endif
    354442                return -1;
    355443        }
    … …  
    378466                sofcantsendmore(so);
    379467
     468#ifdef VBOX_WITH_SYNC_SLIRP
     469        RTSemMutexRelease(so->so_mutex);
     470#endif
    380471        return nn;
    381472}
    … …  
    392483        DEBUG_CALL("sorecvfrom");
    393484        DEBUG_ARG("so = %lx", (long)so);
     485
     486#ifdef VBOX_WITH_SYNC_SLIRP
     487        RTSemMutexRequest(so->so_mutex, RT_INDEFINITE_WAIT);
     488#endif
    394489
    395490        if (so->so_type == IPPROTO_ICMP) {   /* This is a "ping" reply */
    … …  
    478573          } /* rx error */
    479574        } /* if ping packet */
     575#ifdef VBOX_WITH_SYNC_SLIRP
     576        RTSemMutexRelease(so->so_mutex);
     577#endif
    480578}
    481579
    … …  
    490588#if 0
    491589        struct sockaddr_in host_addr;
     590#endif
     591#ifdef VBOX_WITH_SYNC_SLIRP
     592        RTSemMutexRequest(so->so_mutex, RT_INDEFINITE_WAIT);
    492593#endif
    493594
    … …  
    542643        ret = sendto(so->s, m->m_data, m->m_len, 0,
    543644                     (struct sockaddr *)&addr, sizeof (struct sockaddr));
    544         if (ret < 0)
     645        if (ret < 0) {
     646#ifdef VBOX_WITH_SYNC_SLIRP
     647                RTSemMutexRelease(so->so_mutex);
     648#endif
    545649                return -1;
     650        }
    546651
    547652        /*
    … …  
    552657                so->so_expire = curtime + SO_EXPIRE;
    553658        so->so_state = SS_ISFCONNECTED; /* So that it gets select()ed */
     659#ifdef VBOX_WITH_SYNC_SLIRP
     660                RTSemMutexRelease(so->so_mutex);
     661#endif
    554662        return 0;
    555663}
    … …  
    582690                return NULL;
    583691        }
     692#ifndef VBOX_WITH_SYNC_SLIRP
    584693        insque(pData, so,&tcb);
     694#else
     695        RTSemMutexRequest(so->so_mutex, RT_INDEFINITE_WAIT);
     696        /*after adding to global queue probably we should keep lock*/
     697        RTSemMutexRequest(pData->tcb_mutex, RT_INDEFINITE_WAIT);
     698        insque(pData, so,&tcb);
     699        RTSemMutexRelease(pData->tcb_mutex);
     700#endif
    585701
    586702        /*
    … …  
    627743
    628744        so->s = s;
     745#ifdef VBOX_WITH_SYNC_SLIRP
     746        RTSemMutexRelease(so->so_mutex);
     747#endif
    629748        return so;
    630749}
    … …  
    665784        register struct socket *so;
    666785{
     786#ifdef VBOX_WITH_SYNC_SLIRP
     787    RTSemMutexRequest(so->so_mutex, RT_INDEFINITE_WAIT);
     788#endif
    667789        so->so_state &= ~(SS_NOFDREF|SS_ISFCONNECTED|SS_FCANTRCVMORE|
    668790                          SS_FCANTSENDMORE|SS_FWDRAIN);
    669791        so->so_state |= SS_ISFCONNECTING; /* Clobber other states */
     792#ifdef VBOX_WITH_SYNC_SLIRP
     793    RTSemMutexRelease(so->so_mutex);
     794#endif
    670795}
    671796
    … …  
    674799        register struct socket *so;
    675800{
     801#ifdef VBOX_WITH_SYNC_SLIRP
     802    RTSemMutexRequest(so->so_mutex, RT_INDEFINITE_WAIT);
     803#endif
    676804        so->so_state &= ~(SS_ISFCONNECTING|SS_FWDRAIN|SS_NOFDREF);
    677805        so->so_state |= SS_ISFCONNECTED; /* Clobber other states */
     806#ifdef VBOX_WITH_SYNC_SLIRP
     807    RTSemMutexRelease(so->so_mutex);
     808#endif
    678809}
    679810
    … …  
    682813        struct  socket *so;
    683814{
     815#ifdef VBOX_WITH_SYNC_SLIRP
     816    RTSemMutexRequest(so->so_mutex, RT_INDEFINITE_WAIT);
     817#endif
    684818        if ((so->so_state & SS_NOFDREF) == 0) {
    685819                shutdown(so->s,0);
    … …  
    690824        else
    691825           so->so_state |= SS_FCANTRCVMORE;
     826#ifdef VBOX_WITH_SYNC_SLIRP
     827    RTSemMutexRelease(so->so_mutex);
     828#endif
    692829}
    693830
    … …  
    696833        struct socket *so;
    697834{
     835#ifdef VBOX_WITH_SYNC_SLIRP
     836    RTSemMutexRequest(so->so_mutex, RT_INDEFINITE_WAIT);
     837#endif
    698838        if ((so->so_state & SS_NOFDREF) == 0) {
    699839            shutdown(so->s,1);           /* send FIN to fhost */
    … …  
    704844        else
    705845           so->so_state |= SS_FCANTSENDMORE;
     846#ifdef VBOX_WITH_SYNC_SLIRP
     847    RTSemMutexRelease(so->so_mutex);
     848#endif
    706849}
    707850
    … …  
    726869        struct socket *so;
    727870{
     871#ifdef VBOX_WITH_SYNC_SLIRP
     872    RTSemMutexRequest(so->so_mutex, RT_INDEFINITE_WAIT);
     873#endif
    728874        if (so->so_rcv.sb_cc)
    729875                so->so_state |= SS_FWDRAIN;
    730876        else
    731877                sofcantsendmore(so);
    732 }
    733 
     878#ifdef VBOX_WITH_SYNC_SLIRP
     879    RTSemMutexRelease(so->so_mutex);
     880#endif
     881}
     882

  • trunk/src/VBox/Devices/Network/slirp/socket.h

    r1076 r13604  
    1010#ifndef _SLIRP_SOCKET_H_
    1111#define _SLIRP_SOCKET_H_
     12#ifndef VBOX_WITH_SYNC_SLIRP
     13#include <iprt/semaphore.h>
     14#endif
    1215
    1316#define SO_EXPIRE 240000
    … …  
    5255  struct sbuf so_snd;           /* Send buffer */
    5356  void * extra;                 /* Extra pointer */
     57  RTSEMMUTEX so_mutex;          /*per socket mutex*/
    5458};
    5559

  • trunk/src/VBox/Devices/Network/slirp/tcp_subr.c

    r8009 r13604  
    262262        DEBUG_CALL("tcp_close");
    263263        DEBUG_ARG("tp = %lx", (long )tp);
     264#ifdef VBOX_WITH_SYNC_SLIRP
     265        /*sofree destrys so_mutex*/
     266        RTSemMutexRequest(so->so_mutex, RT_INDEFINITE_WAIT);
     267#endif
    264268
    265269        /* free the reassembly queue, if any */
    … …  
    528532        if ((so->so_tcpcb = tcp_newtcpcb(pData, so)) == NULL)
    529533           return -1;
    530 
     534        so->so_type = IPPROTO_TCP;
     535
     536        RTSemMutexRequest(pData->tcb_mutex, RT_INDEFINITE_WAIT);
    531537        insque(pData, so, &tcb);
     538        RTSemMutexRelease(pData->tcb_mutex);
    532539
    533540        return 0;

  • trunk/src/VBox/Devices/Network/slirp/tcp_timer.c

    r1076 r13604  
    4646        register struct socket *so;
    4747        register struct tcpcb *tp;
     48#ifdef VBOX_WITH_SYNC_SLIRP
     49        struct socket *so_next;
     50#endif
    4851
    4952        DEBUG_CALL("tcp_fasttimo");
    5053
     54#ifndef VBOX_WITH_SYNC_SLIRP
    5155        so = tcb.so_next;
    5256        if (so)
    5357        for (; so != &tcb; so = so->so_next)
     58#else
     59        RTSemMutexRequest(pData->tcb_mutex, RT_INDEFINITE_WAIT);
     60        so = tcb.so_next;
     61        while(1) {
     62            if ( so == &tcb) {
     63                RTSemMutexRelease(pData->tcb_mutex);
     64                break;
     65            }
     66            so_next = so->so_next;
     67            RTSemMutexRequest(so->so_mutex, RT_INDEFINITE_WAIT);
     68            RTSemMutexRelease(pData->tcb_mutex);
     69#endif
    5470                if ((tp = (struct tcpcb *)so->so_tcpcb) &&
    5571                    (tp->t_flags & TF_DELACK)) {
    … …  
    5975                        (void) tcp_output(pData, tp);
    6076                }
     77#ifdef VBOX_WITH_SYNC_SLIRP
     78                RTSemMutexRequest(pData->tcb_mutex, RT_INDEFINITE_WAIT);
     79                RTSemMutexRelease(so->so_mutex);
     80                so = so_next;
     81        }
     82#endif
     83
    6184}
    6285
    … …  
    78101         * Search through tcb's and update active timers.
    79102         */
     103#ifndef VBOX_WITH_SYNC_SLIRP
    80104        ip = tcb.so_next;
    81105        if (ip == 0)
    82106           return;
    83107        for (; ip != &tcb; ip = ipnxt) {
     108#else
     109        RTSemMutexRequest(pData->tcb_mutex, RT_INDEFINITE_WAIT);
     110        ip = tcb.so_next;
     111        if (ip == NULL) {
     112            RTSemMutexRelease(pData->tcb_mutex);
     113            return;
     114        }
     115        while (1) {
     116                if (ip == &tcb) {
     117                    RTSemMutexRelease(pData->tcb_mutex);
     118                    break;
     119                }
     120                ipnxt = ip->so_next;
     121                RTSemMutexRequest(ip->so_mutex, RT_INDEFINITE_WAIT);
     122                RTSemMutexRelease(pData->tcb_mutex);
     123#endif
    84124                ipnxt = ip->so_next;
    85125                tp = sototcpcb(ip);
    86126                if (tp == 0)
     127#ifndef VBOX_WITH_SYNC_SLIRP
    87128                        continue;
     129#else
     130                        goto before_loop_ends;
     131#endif
    88132                for (i = 0; i < TCPT_NTIMERS; i++) {
    89133                        if (tp->t_timer[i] && --tp->t_timer[i] == 0) {
    … …  
    98142tpgone:
    99143                ;
     144#ifdef VBOX_WITH_SYNC_SLIRP
     145before_loop_ends:
     146                RTSemMutexRequest(pData->tcb_mutex, RT_INDEFINITE_WAIT);
     147                RTSemMutexRelease(ip->so_mutex);
     148                ip=ipnxt;
     149#endif
    100150        }
    101151        tcp_iss += TCP_ISSINCR/PR_SLOWHZ;               /* increment iss */

  • trunk/src/VBox/Devices/Network/slirp/udp.c

    r8009 r13604  
    351351    }
    352352  }
     353#ifdef VBOX_WITH_SYNC_SLIRP
     354  so->so_type = IPPROTO_UDP;
     355#endif
    353356  return(so->s);
    354357}
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