VirtualBox

Ignore:
Timestamp:
Nov 1, 2008 9:00:32 AM (16 years ago)
Author:
vboxsync
Message:

Enother yet portion of macrofied if/ifndef orgy will finish soon

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r13704 r13727  
    203203{
    204204    int fNATfailed = 0;
    205 #ifdef VBOX_WITH_SYNC_SLIRP
    206     int rc = 0;
    207 #endif
    208205    PNATState pData = malloc(sizeof(NATState));
    209206    *ppData = pData;
    … …  
    230227#endif
    231228
    232 #ifdef VBOX_WITH_SYNC_SLIRP
    233     rc = RTSemMutexCreate(&pData->tcb_mutex);
    234     AssertReleaseRC(rc);
    235     rc = RTSemMutexCreate(&pData->tcp_last_so_mutex);
    236     AssertReleaseRC(rc);
    237     rc = RTSemMutexCreate(&pData->udb_mutex);
    238     AssertReleaseRC(rc);
    239     rc = RTSemMutexCreate(&pData->udp_last_so_mutex);
    240     AssertReleaseRC(rc);
    241     rc = RTSemMutexCreate(&pData->if_queued_mutex);
    242     AssertReleaseRC(rc);
    243     rc = RTSemMutexCreate(&pData->next_m_mutex);
    244     AssertReleaseRC(rc);
    245 #endif
     229    VBOX_SLIRP_LOCK_CREATE(&pData->tcb_mutex);
     230    VBOX_SLIRP_LOCK_CREATE(&pData->tcp_last_so_mutex);
     231    VBOX_SLIRP_LOCK_CREATE(&pData->udb_mutex);
     232    VBOX_SLIRP_LOCK_CREATE(&pData->udp_last_so_mutex);
     233    VBOX_SLIRP_LOCK_CREATE(&pData->if_queued_mutex);
     234    VBOX_SLIRP_LOCK_CREATE(&pData->next_m_mutex);
    246235
    247236    Assert(sizeof(struct ip) == 20);
    … …  
    379368                 * in the fragment queue, or there are TCP connections active
    380369                 */
    381 #ifndef VBOX_WITH_SYNC_SLIRP
     370                VBOX_SLIRP_LOCK(pData->tcb_mutex);
    382371                do_slowtimo = ((tcb.so_next != &tcb) ||
    383372                               ((struct ipasfrag *)&ipq != u32_to_ptr(pData, ipq.next, struct ipasfrag *)));
    384373
     374                so = tcb.so_next;
     375#ifndef VBOX_WITH_SYNC_SLIRP
    385376                for (so = tcb.so_next; so != &tcb; so = so_next) {
    386                         so_next = so->so_next;
    387377#else
    388                 RTSemMutexRequest(pData->tcb_mutex, RT_INDEFINITE_WAIT);
    389                 so = tcb.so_next;
    390                 do_slowtimo = ((so != &tcb) ||
    391                                ((struct ipasfrag *)&ipq != u32_to_ptr(pData, ipq.next, struct ipasfrag *)));
    392378                while (1) {
    393379                    if (so == &tcb) {
    394                         RTSemMutexRelease(pData->tcb_mutex);
     380                        VBOX_SLIRP_UNLOCK(pData->tcb_mutex);
    395381                        break;
    396382                    }
     383#endif
    397384                    so_next = so->so_next;
    398                     RTSemMutexRequest(so->so_mutex, RT_INDEFINITE_WAIT);
    399                     RTSemMutexRelease(pData->tcb_mutex);
    400 #endif
     385                    VBOX_SLIRP_LOCK(so->so_mutex);
     386                    VBOX_SLIRP_UNLOCK(pData->tcb_mutex);
    401387
    402388                        /*
    … …  
    411397                         */
    412398                        if (so->so_state & SS_NOFDREF || so->s == -1)
    413 #ifndef VBOX_WITH_SYNC_SLIRP
    414                                 continue;
    415 #else
    416399                                goto before_loop_ends;
    417 #endif
    418400
    419401                        /*
    … …  
    423405                                FD_SET(so->s, readfds);
    424406                                UPD_NFDS(so->s);
    425 #ifndef VBOX_WITH_SYNC_SLIRP
    426                                 continue;
    427 #else
    428407                                goto before_loop_ends;
    429 #endif
    430408                        }
    431409
    … …  
    436414                                FD_SET(so->s, writefds);
    437415                                UPD_NFDS(so->s);
    438 #ifndef VBOX_WITH_SYNC_SLIRP
    439                                 continue;
    440 #else
    441416                                goto before_loop_ends;
    442 #endif
    443417                        }
    444418
    … …  
    461435                                UPD_NFDS(so->s);
    462436                        }
    463 #ifdef VBOX_WITH_SYNC_SLIRP
    464437                before_loop_ends:
    465438                        /*Release of global tcb mutex happens in the head of loop*/
    466                         RTSemMutexRelease(so->so_mutex);
    467                         RTSemMutexRequest(pData->tcb_mutex, RT_INDEFINITE_WAIT);
     439                        VBOX_SLIRP_UNLOCK(so->so_mutex);
     440                        VBOX_SLIRP_LOCK(pData->tcb_mutex);
     441#ifdef VBOX_WITH_SYNC_SLIRP
    468442                        so = so_next;
    469443#endif
    … …  
    473447                 * UDP sockets
    474448                 */
     449                VBOX_SLIRP_LOCK(pData->udb_mutex);
     450                so = udb.so_next;
    475451#ifndef VBOX_WITH_SYNC_SLIRP
    476452                for (so = udb.so_next; so != &udb; so = so_next) {
    477                         so_next = so->so_next;
    478453#else
    479                 RTSemMutexRequest(pData->udb_mutex, RT_INDEFINITE_WAIT);
    480                 so = udb.so_next;
    481454                while(1) {
    482455                    if (so == &udb) {
    483                         RTSemMutexRelease(pData->udb_mutex);
     456                        VBOX_SLIRP_UNLOCK(pData->udb_mutex);
    484457                        break;
    485458                    }
    486                 so_next = so->so_next;
    487                 RTSemMutexRequest(so->so_mutex, RT_INDEFINITE_WAIT);
    488                 RTSemMutexRelease(pData->udb_mutex);
    489 #endif
     459#endif
     460                    so_next = so->so_next;
     461                    VBOX_SLIRP_LOCK(so->so_mutex);
     462                    VBOX_SLIRP_UNLOCK(pData->udb_mutex);
    490463
    491464                        /*
    … …  
    495468                                if (so->so_expire <= curtime) {
    496469                                        udp_detach(pData, so);
    497 #ifndef VBOX_WITH_SYNC_SLIRP
    498                                         continue;
    499 #else
    500470                                        goto before_udp_loop_end;
    501 #endif
    502471                                } else
    503472                                        do_slowtimo = 1; /* Let socket expire */
    … …  
    518487                                UPD_NFDS(so->s);
    519488                        }
     489                        before_udp_loop_end:
     490                        VBOX_SLIRP_UNLOCK(so->so_mutex);
     491                        VBOX_SLIRP_LOCK(pData->udb_mutex);
    520492#ifdef VBOX_WITH_SYNC_SLIRP
    521                         before_udp_loop_end:
    522                         RTSemMutexRelease(so->so_mutex);
    523                         RTSemMutexRequest(pData->udb_mutex, RT_INDEFINITE_WAIT);
    524493                        so = so_next;
    525494#endif
    … …  
    593562                 * Check TCP sockets
    594563                 */
     564                VBOX_SLIRP_LOCK(pData->tcb_mutex);
     565                so = tcb.so_next;
    595566#ifndef VBOX_WITH_SYNC_SLIRP
    596567                for (so = tcb.so_next; so != &tcb; so = so_next) {
    597                         so_next = so->so_next;
    598568#else
    599                 RTSemMutexRequest(pData->tcb_mutex, RT_INDEFINITE_WAIT);
    600                 so = tcb.so_next;
    601569                while (1) {
    602570                    if (so == &tcb) {
    603                         RTSemMutexRelease(pData->tcb_mutex);
     571                        VBOX_SLIRP_UNLOCK(pData->tcb_mutex);
    604572                        break;
    605573                    }
    606                 so_next = so->so_next;
    607                 RTSemMutexRequest(so->so_mutex, RT_INDEFINITE_WAIT);
    608                 RTSemMutexRelease(pData->tcb_mutex);
    609 #endif
     574#endif
     575                    so_next = so->so_next;
     576                    VBOX_SLIRP_LOCK(so->so_mutex);
     577                    VBOX_SLIRP_UNLOCK(pData->tcb_mutex);
    610578
    611579                        /*
    … …  
    614582                         */
    615583                        if (so->so_state & SS_NOFDREF || so->s == -1)
    616 #ifndef VBOX_WITH_SYNC_SLIRP
    617                                 continue;
    618 #else
    619584                                goto before_loop_ends;
    620 #endif
    621585
    622586                        /*
    … …  
    636600                                if (so->so_state & SS_FACCEPTCONN) {
    637601                                        tcp_connect(pData, so);
    638 #ifndef VBOX_WITH_SYNC_SLIRP
    639                                         continue;
    640 #else
    641602                                        goto before_loop_ends;
    642 #endif
    643603                                } /* else */
    644604                                ret = soread(pData, so);
    … …  
    672632                              if (errno == EAGAIN || errno == EWOULDBLOCK ||
    673633                                  errno == EINPROGRESS || errno == ENOTCONN)
    674 #ifndef VBOX_WITH_SYNC_SLIRP
    675                                         continue;
    676 #else
    677634                                        goto before_loop_ends;
    678 #endif
    679635
    680636                              /* else failed */
    … …  
    711667                            if (errno == EAGAIN || errno == EWOULDBLOCK ||
    712668                                errno == EINPROGRESS || errno == ENOTCONN)
    713 #ifndef VBOX_WITH_SYNC_SLIRP
    714                                         continue;/* Still connecting, continue */
    715 #else
    716                                         goto before_loop_ends;
    717 #endif
     669                                        goto before_loop_ends;/* Still connecting, continue */
    718670
    719671                            /* else failed */
    … …  
    727679                              if (errno == EAGAIN || errno == EWOULDBLOCK ||
    728680                                  errno == EINPROGRESS || errno == ENOTCONN)
    729 #ifndef VBOX_WITH_SYNC_SLIRP
    730                                         continue;
    731 #else
    732681                                        goto before_loop_ends;
    733 #endif
    734682                              /* else failed */
    735683                              so->so_state = SS_NOFDREF;
    … …  
    741689                        } /* SS_ISFCONNECTING */
    742690#endif
     691                    before_loop_ends:
     692                    VBOX_SLIRP_UNLOCK(so->so_mutex);
     693                    VBOX_SLIRP_LOCK(pData->tcb_mutex);
    743694#ifdef VBOX_WITH_SYNC_SLIRP
    744                     before_loop_ends:
    745                     RTSemMutexRelease(so->so_mutex);
    746                     RTSemMutexRequest(pData->tcb_mutex, RT_INDEFINITE_WAIT);
    747695                    so = so_next;
    748696#endif
    … …  
    754702                 * Incoming UDP data isn't buffered either.
    755703                 */
     704                VBOX_SLIRP_LOCK(pData->udb_mutex);
     705                so = udb.so_next;
    756706#ifndef VBOX_WITH_SYNC_SLIRP
    757707                for (so = udb.so_next; so != &udb; so = so_next) {
    758                         so_next = so->so_next;
    759708#else
    760                 RTSemMutexRequest(pData->udb_mutex, RT_INDEFINITE_WAIT);
    761                 so = udb.so_next;
    762709                while(1) {
    763710                    if (so == &udb) {
    764                         RTSemMutexRelease(pData->udb_mutex);
     711                        VBOX_SLIRP_UNLOCK(pData->udb_mutex);
    765712                        break;
    766713                    }
     714#endif
    767715                    so_next = so->so_next;
    768                     RTSemMutexRequest(so->so_mutex, RT_INDEFINITE_WAIT);
    769                     RTSemMutexRelease(pData->udb_mutex);
    770 #endif
     716                    VBOX_SLIRP_LOCK(so->so_mutex);
     717                    VBOX_SLIRP_UNLOCK(pData->udb_mutex);
    771718
    772719                        if (so->s != -1 && FD_ISSET(so->s, readfds)) {
    773720                            sorecvfrom(pData, so);
    774721                        }
     722                    VBOX_SLIRP_UNLOCK(so->so_mutex);
     723                    VBOX_SLIRP_LOCK(pData->udb_mutex);
    775724#ifdef VBOX_WITH_SYNC_SLIRP
    776                     RTSemMutexRelease(so->so_mutex);
    777                     RTSemMutexRequest(pData->udb_mutex, RT_INDEFINITE_WAIT);
    778725                    so = so_next;
    779726#endif
    … …  
    790737#if 0
    791738        if (link_up) {
    792             RTSemMutexRequest(pData->if_queued_mutex, RT_INDEFINITE_WAIT);
     739            VBOX_SLIRP_LOCK(pData->if_queued_mutex);
    793740            if (if_queued > 0){
    794                 RTSemMutexRelease(pData->if_queued_mutex);
     741VBOX_SLIRP_UNLOCK(pData->if_queued_mutex);
    795742                if_start(pData);
    796743            }
    797744            else {
    798                 RTSemMutexRelease(pData->if_queued_mutex);
     745VBOX_SLIRP_UNLOCK(pData->if_queued_mutex);
    799746            }
    800747        }
    … …  
    891838    struct mbuf *m;
    892839    int proto;
    893 #ifdef VBOX_WITH_SYNC_SLIRP
    894     int rc;
    895 #endif
    896840
    897841    if (pkt_len < ETH_HLEN)
    … …  
    909853
    910854        m = m_get(pData);
    911 #ifdef VBOX_WITH_SYNC_SLIRP
    912         if (m != NULL) {
    913             rc = RTSemMutexRequest(m->m_mutex, RT_INDEFINITE_WAIT);
    914             AssertReleaseRC(rc);
    915         }
    916 #endif
    917855        if (!m)
    918856            return;
     857        VBOX_SLIRP_LOCK(m->m_mutex);
    919858        /* Note: we add to align the IP header */
    920859        if (M_FREEROOM(m) < pkt_len + 2) {
    … …  
    928867
    929868        ip_input(pData, m);
    930 #ifdef VBOX_WITH_SYNC_SLIRP
    931         rc = RTSemMutexRelease(m->m_mutex);
    932         AssertReleaseRC(rc);
    933 #endif
     869        VBOX_SLIRP_UNLOCK(m->m_mutex);
    934870        break;
    935871    default:
Note: See TracChangeset for help on using the changeset viewer.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette