VirtualBox

Changeset 13704 in vbox


Ignore:
Timestamp:
Oct 31, 2008 6:48:25 AM (16 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
38670
Message:

TCP sync was intoducedTCP sync was intoduced

Location:
trunk/src/VBox/Devices/Network/slirp
Files:
7 edited

Legend:

Unmodified
Added
Removed

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

    r13670 r13704  
    201201                        ip = ip_reass(pData, (struct ipasfrag *)ip, fp);
    202202                        if (ip == 0)
     203#ifndef VBOX_WITH_SYNC_SLIRP
    203204                                return;
     205#else
     206                        {
     207                            rc = RTSemMutexRelease(m->m_mutex);
     208                            AssertReleaseRC(rc);
     209                            return;
     210                        }
     211#endif
    204212                        ipstat.ips_reassembled++;
     213#ifndef VBOX_WITH_SYNC_SLIRP
    205214                        m = dtom(pData, ip);
     215#else
     216                        rc = RTSemMutexRelease(m->m_mutex);
     217                        AssertReleaseRC(rc);
     218                        m = dtom(pData, ip);
     219                        rc = RTSemMutexRequest(m->m_mutex, RT_INDEFINITE_WAIT);
     220                        AssertReleaseRC(rc);
     221#endif
    206222                } else
    207223                        if (fp)

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

    r13670 r13704  
    233233    rc = RTSemMutexCreate(&pData->tcb_mutex);
    234234    AssertReleaseRC(rc);
     235    rc = RTSemMutexCreate(&pData->tcp_last_so_mutex);
     236    AssertReleaseRC(rc);
    235237    rc = RTSemMutexCreate(&pData->udb_mutex);
    236238    AssertReleaseRC(rc);
    … …  
    786788           if_start(pData);
    787789#else
    788 #if 1
     790#if 0
    789791        if (link_up) {
    790792            RTSemMutexRequest(pData->if_queued_mutex, RT_INDEFINITE_WAIT);

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

    r13670 r13704  
    149149#ifdef VBOX_WITH_SYNC_SLIRP
    150150    /*
     151     * tcp_last_so_mutex used for control access to tcp_last_so pointer
     152     */
     153    RTSEMMUTEX tcp_last_so_mutex;
     154    /*
    151155     * tcb_mutex used for control access to tcb queue of sockets
    152      * servising TCP connections and tcp_last_so field
     156     * servising TCP connections
    153157     */
    154158    RTSEMMUTEX tcb_mutex;

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

    r13670 r13704  
    104104    }
    105105    else if (so->so_type == IPPROTO_TCP) {
    106         RTSemMutexRequest(pData->tcb_mutex, RT_INDEFINITE_WAIT);
     106        RTSemMutexRequest(pData->tcp_last_so_mutex, RT_INDEFINITE_WAIT);
    107107    }
    108108    else {
    … …  
    122122    }
    123123    else if (so->so_type == IPPROTO_TCP) {
    124         RTSemMutexRelease(pData->tcb_mutex);
     124        RTSemMutexRelease(pData->tcp_last_so_mutex);
    125125    }
    126126    else {

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

    r8009 r13704  
    246246        DEBUG_ARGS((dfd," m = %8lx  iphlen = %2d  inso = %lx\n",
    247247                    (long )m, iphlen, (long )inso ));
     248#ifdef VBOX_WITH_SYNC_SLIRP
     249#if 0
     250#define return                                      \
     251do {                                                \
     252    fprintf(stderr, "%s:%d\n", __FILE__, __LINE__); \
     253    return;                                         \
     254}while(0)
     255#endif
     256
     257        int rc;
     258        if (inso != NULL) {
     259            rc = RTSemMutexRequest(inso->so_mutex, RT_INDEFINITE_WAIT);
     260            AssertReleaseRC(rc);
     261        }
     262#endif
    248263
    249264        /*
    … …  
    256271                tp = sototcpcb(so);
    257272                m = so->so_m;
     273#ifdef VBOX_WITH_SYNC_SLIRP
     274                rc = RTSemMutexRequest(m->m_mutex, RT_INDEFINITE_WAIT);
     275                AssertReleaseRC(rc);
     276#endif
    258277                so->so_m = 0;
    259278                ti = so->so_ti;
    … …  
    263282                goto cont_conn;
    264283        }
     284#ifdef VBOX_WITH_SYNC_SLIRP
     285        rc = RTSemMutexRequest(m->m_mutex, RT_INDEFINITE_WAIT);
     286        AssertReleaseRC(rc);
     287#endif
    265288
    266289
    … …  
    356379         */
    357380findso:
     381#ifdef VBOX_WITH_SYNC_SLIRP
     382        rc = RTSemMutexRequest(pData->tcp_last_so_mutex, RT_INDEFINITE_WAIT);
     383        AssertReleaseRC(rc);
     384#endif
    358385        so = tcp_last_so;
     386#ifdef VBOX_WITH_SYNC_SLIRP
     387        /* this checking for making sure that we're not trying to hold mutex on head list*/
     388        if (tcp_last_so != &tcb) {
     389            rc = RTSemMutexRequest(so->so_mutex, RT_INDEFINITE_WAIT);
     390            AssertReleaseRC(rc);
     391        }
     392        rc = RTSemMutexRelease(pData->tcp_last_so_mutex);
     393        AssertReleaseRC(rc);
     394#endif
    359395        if (so->so_fport != ti->ti_dport ||
    360396            so->so_lport != ti->ti_sport ||
    361397            so->so_laddr.s_addr != ti->ti_src.s_addr ||
    362398            so->so_faddr.s_addr != ti->ti_dst.s_addr) {
     399#ifndef VBOX_WITH_SYNC_SLIRP
    363400                so = solookup(&tcb, ti->ti_src, ti->ti_sport,
    364401                               ti->ti_dst, ti->ti_dport);
    365402                if (so)
    366403                        tcp_last_so = so;
     404#else
     405                /*To make sure that we don't try to release mutex on head of the socket queue*/
     406                if (so != &tcb) {
     407                    rc = RTSemMutexRelease(so->so_mutex);
     408                    AssertReleaseRC(rc);
     409                }
     410                so = solookup(&tcb, ti->ti_src, ti->ti_sport,
     411                               ti->ti_dst, ti->ti_dport);
     412                if (so) {
     413                        rc = RTSemMutexRequest(so->so_mutex, RT_INDEFINITE_WAIT);
     414                        AssertReleaseRC(rc);
     415                        rc = RTSemMutexRequest(pData->tcp_last_so_mutex, RT_INDEFINITE_WAIT);
     416                        AssertReleaseRC(rc);
     417                        tcp_last_so = so;
     418                        rc = RTSemMutexRelease(pData->tcp_last_so_mutex);
     419                        AssertReleaseRC(rc);
     420                }
     421#endif
    367422                ++tcpstat.tcps_socachemiss;
    368423        }
    … …  
    387442          if ((so = socreate()) == NULL)
    388443            goto dropwithreset;
     444#ifdef VBOX_WITH_SYNC_SLIRP
     445          rc = RTSemMutexRequest(so->so_mutex, RT_INDEFINITE_WAIT);
     446          AssertReleaseRC(rc);
     447#endif
    389448          if (tcp_attach(pData, so) < 0) {
     449#ifdef VBOX_WITH_SYNC_SLIRP
     450            rc = RTSemMutexRelease(so->so_mutex);
     451            AssertReleaseRC(rc);
     452            rc = RTSemMutexDestroy(so->so_mutex);
     453            AssertReleaseRC(rc);
     454#endif
    390455            free(so); /* Not sofree (if it failed, it's not insqued) */
     456#ifdef VBOX_WITH_SYNC_SLIRP
     457            so = NULL;
     458#endif
    391459            goto dropwithreset;
    392460          }
    … …  
    506574                                tp->snd_una = ti->ti_ack;
    507575                                m_freem(pData, m);
     576#ifdef VBOX_WITH_SYNC_SLIRP
     577                                if (m != NULL) {
     578                                    rc = RTSemMutexRelease(m->m_mutex);
     579                                    AssertReleaseRC(rc);
     580                                }
     581#endif
    508582
    509583                                /*
    … …  
    535609                                if (so->so_snd.sb_cc)
    536610                                        (void) tcp_output(pData, tp);
    537 
     611#ifdef VBOX_WITH_SYNC_SLIRP
     612                                rc = RTSemMutexRelease(so->so_mutex);
     613                                AssertReleaseRC(rc);
     614#endif
    538615                                return;
    539616                        }
    … …  
    575652                        tp->t_flags |= TF_ACKNOW;
    576653                        tcp_output(pData, tp);
     654#ifdef VBOX_WITH_SYNC_SLIRP
     655                                rc = RTSemMutexRelease(so->so_mutex);
     656                                AssertReleaseRC(rc);
     657                                if (m != NULL) {
     658                                    rc = RTSemMutexRelease(m->m_mutex);
     659                                    AssertReleaseRC(rc);
     660                                }
     661#endif
    577662                        return;
    578663                }
    … …  
    675760            tp = tcp_close(pData, tp);
    676761            m_free(pData, m);
     762#ifdef VBOX_WITH_SYNC_SLIRP
     763            if (m != NULL) {
     764                rc = RTSemMutexRelease(m->m_mutex);
     765                AssertReleaseRC(rc);
     766            }
     767#endif
    677768          } else {
    678769            /*
    … …  
    687778            tp->t_state = TCPS_SYN_RECEIVED;
    688779          }
     780#ifdef VBOX_WITH_SYNC_SLIRP
     781          rc = RTSemMutexRelease(so->so_mutex);
     782          AssertReleaseRC(rc);
     783          if (m != NULL) {
     784            rc = RTSemMutexRelease(m->m_mutex);
     785            AssertReleaseRC(rc);
     786          }
     787#endif
    689788          return;
    690789
    … …  
    14441543                (void) tcp_output(pData, tp);
    14451544        }
     1545#ifdef VBOX_WITH_SYNC_SLIRP
     1546          rc = RTSemMutexRelease(so->so_mutex);
     1547          AssertReleaseRC(rc);
     1548
     1549          if (m != NULL) {
     1550            rc = RTSemMutexRelease(m->m_mutex);
     1551            AssertReleaseRC(rc);
     1552          }
     1553#endif
    14461554        return;
    14471555
    … …  
    14561564        tp->t_flags |= TF_ACKNOW;
    14571565        (void) tcp_output(pData, tp);
     1566#ifdef VBOX_WITH_SYNC_SLIRP
     1567          rc = RTSemMutexRelease(so->so_mutex);
     1568          AssertReleaseRC(rc);
     1569          if (m != NULL) {
     1570            rc = RTSemMutexRelease(m->m_mutex);
     1571            AssertReleaseRC(rc);
     1572          }
     1573#endif
    14581574        return;
    14591575
    … …  
    14681584        }
    14691585
     1586#ifdef VBOX_WITH_SYNC_SLIRP
     1587          rc = RTSemMutexRelease(so->so_mutex);
     1588          AssertReleaseRC(rc);
     1589          if (m != NULL) {
     1590            rc = RTSemMutexRelease(m->m_mutex);
     1591            AssertReleaseRC(rc);
     1592          }
     1593#endif
    14701594        return;
    14711595
    … …  
    14751599         */
    14761600        m_free(pData, m);
     1601#ifdef VBOX_WITH_SYNC_SLIRP
     1602          rc = RTSemMutexRelease(so->so_mutex);
     1603          AssertReleaseRC(rc);
     1604          if (m != NULL) {
     1605            rc = RTSemMutexRelease(m->m_mutex);
     1606            AssertReleaseRC(rc);
     1607          }
     1608#endif
    14771609
    14781610        return;
     1611#ifdef VBOX_WITH_SYNC_SLIRP
     1612#undef return
     1613#endif
    14791614}
    14801615

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

    r13670 r13704  
    277277/*      free(tp, M_PCB);  */
    278278#ifdef VBOX_WITH_SYNC_SLIRP
    279         RTSemMutexRequest(pData->tcb_mutex, RT_INDEFINITE_WAIT);
     279        RTSemMutexRequest(pData->tcp_last_so_mutex, RT_INDEFINITE_WAIT);
    280280        /*sofree destrys so_mutex*/
    281281        RTSemMutexRequest(so->so_mutex, RT_INDEFINITE_WAIT);
    … …  
    294294        tcpstat.tcps_closed++;
    295295#ifdef VBOX_WITH_SYNC_SLIRP
    296         RTSemMutexRelease(pData->tcb_mutex);
     296        RTSemMutexRelease(pData->tcp_last_so_mutex);
    297297#endif
    298298        return ((struct tcpcb *)0);
    … …  
    456456        DEBUG_CALL("tcp_connect");
    457457        DEBUG_ARG("inso = %lx", (long)inso);
     458#ifdef VBOX_WITH_SYNC_SLIRP
     459        int rc;
     460        rc = RTSemMutexRequest(pData->tcb_mutex, RT_INDEFINITE_WAIT);
     461        AssertReleaseRC(rc);
     462        rc = RTSemMutexRequest(inso->so_mutex, RT_INDEFINITE_WAIT);
     463        AssertReleaseRC(rc);
     464#endif
    458465
    459466        /*
    … …  
    468475                        /* If it failed, get rid of the pending connection */
    469476                        closesocket(accept(inso->s,(struct sockaddr *)&addr,&addrlen));
     477#ifdef VBOX_WITH_SYNC_SLIRP
     478                        rc = RTSemMutexRelease(inso->so_mutex);
     479                        AssertReleaseRC(rc);
     480                        rc = RTSemMutexRelease(pData->tcb_mutex);
     481                        AssertReleaseRC(rc);
     482#endif
    470483                        return;
    471484                }
     485#ifdef VBOX_WITH_SYNC_SLIRP
     486                rc = RTSemMutexRequest(so->so_mutex, RT_INDEFINITE_WAIT);
     487                AssertReleaseRC(rc);
     488#endif
    472489                if (tcp_attach(pData, so) < 0) {
     490#ifndef VBOX_WITH_SYNC_SLIRP
    473491                        free(so); /* NOT sofree */
     492#else
     493                        rc = RTSemMutexRelease(inso->so_mutex);
     494                        AssertReleaseRC(rc);
     495                        rc = RTSemMutexRelease(so->so_mutex);
     496                        AssertReleaseRC(rc);
     497                        RTSemMutexDestroy(so->so_mutex);
     498                        rc = RTSemMutexRelease(pData->tcb_mutex);
     499                        AssertReleaseRC(rc);
     500                        free(so);
     501                        so = NULL;
     502#endif
    474503                        return;
    475504                }
     505#ifdef VBOX_WITH_SYNC_SLIRP
     506                rc = RTSemMutexRelease(pData->tcb_mutex);
     507                AssertReleaseRC(rc);
     508#endif
    476509                so->so_laddr = inso->so_laddr;
    477510                so->so_lport = inso->so_lport;
    … …  
    482515        if ((s = accept(inso->s,(struct sockaddr *)&addr,&addrlen)) < 0) {
    483516                tcp_close(pData, sototcpcb(so)); /* This will sofree() as well */
     517#ifdef VBOX_WITH_SYNC_SLIRP
     518                if (so != inso) {
     519                    rc = RTSemMutexRelease(inso->so_mutex);
     520                    AssertReleaseRC(rc);
     521                }
     522                rc = RTSemMutexRelease(so->so_mutex);
     523                AssertReleaseRC(rc);
     524#endif
    484525                return;
    485526        }
    … …  
    504545                                           /* if it's not FACCEPTONCE, it's already NOFDREF */
    505546        }
     547#ifdef VBOX_WITH_SYNC_SLIRP
     548        if (so != inso) {
     549            rc = RTSemMutexRelease(inso->so_mutex);
     550            AssertReleaseRC(rc);
     551        }
     552#endif
    506553        so->s = s;
    507554
    … …  
    526573        tcp_sendseqinit(tp);
    527574        tcp_output(pData, tp);
     575#ifdef VBOX_WITH_SYNC_SLIRP
     576        rc = RTSemMutexRelease(so->so_mutex);
     577        AssertReleaseRC(rc);
     578#endif
    528579}
    529580
    … …  
    537588           return -1;
    538589#ifdef VBOX_WITH_SYNC_SLIRP
     590        int rc = RTSemMutexRequest(so->so_mutex, RT_INDEFINITE_WAIT);
     591        AssertReleaseRC(rc);
    539592        so->so_type = IPPROTO_TCP;
    540593
    541         RTSemMutexRequest(pData->tcb_mutex, RT_INDEFINITE_WAIT);
     594        rc = RTSemMutexRequest(pData->tcb_mutex, RT_INDEFINITE_WAIT);
     595        AssertReleaseRC(rc);
    542596        insque(pData, so, &tcb);
    543         RTSemMutexRelease(pData->tcb_mutex);
     597        rc = RTSemMutexRelease(pData->tcb_mutex);
     598        AssertReleaseRC(rc);
     599
     600        rc = RTSemMutexRelease(so->so_mutex);
     601        AssertReleaseRC(rc);
    544602#else
    545603        insque(pData, so, &tcb);

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

    r13670 r13704  
    498498
    499499        sofree(pData, so);
     500#ifdef VBOX_WITH_SYNC_SLIRP
     501        if (so != NULL) {
     502            rc = RTSemMutexRelease(so->so_mutex);
     503            AssertReleaseRC(rc);
     504        }
     505#endif
    500506}
    501507
    … …  
    824830        if (bind(so->s,(struct sockaddr *)&addr, addrlen) < 0) {
    825831                udp_detach(pData, so);
     832#ifdef VBOX_WITH_SYNC_SLIRP
     833                rc = RTSemMutexRelease(so->so_mutex);
     834                AssertReleaseRC(rc);
     835#endif
    826836                return NULL;
    827837        }
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