VirtualBox

Changeset 13733 in vbox


Ignore:
Timestamp:
Nov 2, 2008 7:09:23 AM (16 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
38704
Message:

The rest of macro replacment was added

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

Legend:

Unmodified
Added
Removed

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

    r13670 r13733  
    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
     50
     51        VBOX_SLIRP_LOCK_CREATE(&pData->if_fastq_mutex);
     52        VBOX_SLIRP_LOCK_CREATE(&if_fastq.m_mutex);
    5453
    5554        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
     55
     56        VBOX_SLIRP_LOCK_CREATE(&pData->if_batchq_mutex);
     57        VBOX_SLIRP_LOCK_CREATE(&if_batchq.m_mutex);
     58
    6059        /*      sl_compress_init(&comp_s); */
    6160        next_m = &if_batchq;
    … …  
    166165        DEBUG_ARG("so = %lx", (long)so);
    167166        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
     167
     168        if (so != NULL) VBOX_SLIRP_LOCK(so->so_mutex);
    172169
    173170        /*
    … …  
    176173         * XXX Shouldn't need this, gotta change dtom() etc.
    177174         */
    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
     175        VBOX_SLIRP_LOCK(pData->m_usedlist_mutex);
     176        VBOX_SLIRP_LOCK(ifm->m_mutex);
     177
    182178        if (ifm->m_flags & M_USEDLIST) {
    183179                remque(pData, ifm);
    184180                ifm->m_flags &= ~M_USEDLIST;
    185181        }
    186 #ifdef VBOX_WITH_SYNC_SLIRP
    187         RTSemMutexRelease(pData->m_usedlist_mutex);
    188 #endif
     182        VBOX_SLIRP_UNLOCK(pData->m_usedlist_mutex);
    189183
    190184        /*
    … …  
    195189         * XXX add cache here?
    196190         */
     191        VBOX_SLIRP_LOCK(pData->if_batchq_mutex);
    197192#ifndef VBOX_WITH_SYNC_SLIRP
    198193        for (ifq = if_batchq.ifq_prev; ifq != &if_batchq; ifq = ifq->ifq_prev) {
    199194#else
    200         RTSemMutexRequest(pData->if_batchq_mutex, RT_INDEFINITE_WAIT);
    201195        ifq = if_batchq.ifq_prev;
    202196        while(1){
    203197            if (ifq == &if_batchq) {
    204                 RTSemMutexRelease(pData->if_batchq_mutex);
     198                VBOX_SLIRP_UNLOCK(pData->if_batchq_mutex);
    205199                break;
    206200            }
    207201            ifqprev = ifq->ifq_prev;
    208             RTSemMutexRequest(ifq->m_mutex, RT_INDEFINITE_WAIT);
    209             RTSemMutexRelease(pData->if_batchq_mutex);
    210 #endif
    211                 if (so == ifq->ifq_so) {
     202#endif
     203            VBOX_SLIRP_LOCK(ifq->m_mutex);
     204            VBOX_SLIRP_UNLOCK(pData->if_batchq_mutex);
     205            if (so == ifq->ifq_so) {
    212206                        /* A match! */
    213207                        ifm->ifq_so = so;
    214208                        ifs_insque(ifm, ifq->ifs_prev);
    215209                        goto diddit;
    216                 }
    217 #ifdef VBOX_WITH_SYNC_SLIRP
    218             RTSemMutexRelease(ifq->m_mutex);
    219             RTSemMutexRequest(pData->if_batchq_mutex, RT_INDEFINITE_WAIT);
     210            }
     211            VBOX_SLIRP_UNLOCK(ifq->m_mutex);
     212            VBOX_SLIRP_LOCK(pData->if_batchq_mutex);
     213#ifdef VBOX_WITH_SYNC_SLIRP
    220214            ifq = ifqprev;
    221215#endif
    … …  
    224218        /* No match, check which queue to put it on */
    225219        if (so && (so->so_iptos & IPTOS_LOWDELAY)) {
    226 #ifdef VBOX_WITH_SYNC_SLIRP
    227                 RTSemMutexRequest(pData->if_fastq_mutex, RT_INDEFINITE_WAIT);
    228 #endif
     220                VBOX_SLIRP_LOCK(pData->if_fastq_mutex);
    229221                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
     222                VBOX_SLIRP_LOCK(ifq->m_mutex);
     223                VBOX_SLIRP_UNLOCK(pData->if_fastq_mutex);
    234224                on_fastq = 1;
    235225                /*
    … …  
    244234        }
    245235        else {
    246 #ifdef VBOX_WITH_SYNC_SLIRP
    247                 RTSemMutexRequest(pData->if_batchq_mutex, RT_INDEFINITE_WAIT);
    248 #endif
     236                VBOX_SLIRP_LOCK(pData->if_batchq_mutex);
    249237                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
     238                VBOX_SLIRP_LOCK(ifq->m_mutex);
     239                VBOX_SLIRP_UNLOCK(pData->if_batchq_mutex);
    254240        }
    255241
    … …  
    260246
    261247diddit:
    262 #ifdef VBOX_WITH_SYNC_SLIRP
    263     RTSemMutexRequest(pData->if_queued_mutex, RT_INDEFINITE_WAIT);
    264 #endif
     248        VBOX_SLIRP_LOCK(pData->if_queued_mutex);
     249
    265250        ++if_queued;
    266 #ifdef VBOX_WITH_SYNC_SLIRP
    267     RTSemMutexRelease(pData->if_queued_mutex);
    268 #endif
     251
     252        VBOX_SLIRP_UNLOCK(pData->if_queued_mutex);
    269253
    270254        if (so) {
    … …  
    282266                                 (so->so_nqueued - so->so_queued) >= 3)) {
    283267
    284 #ifdef VBOX_WITH_SYNC_SLIRP
    285                         RTSemMutexRequest(pData->if_fastq_mutex, RT_INDEFINITE_WAIT);
    286 #endif
     268                        VBOX_SLIRP_LOCK(pData->if_fastq_mutex);
    287269                        /* Remove from current queue... */
    288270                        remque(pData, ifm->ifs_next);
    289 #ifdef VBOX_WITH_SYNC_SLIRP
    290                         RTSemMutexRelease(pData->if_fastq_mutex);
    291                         RTSemMutexRequest(pData->if_batchq_mutex, RT_INDEFINITE_WAIT);
    292 #endif
     271
     272                        VBOX_SLIRP_UNLOCK(pData->if_fastq_mutex);
     273                        VBOX_SLIRP_LOCK(pData->if_batchq_mutex);
    293274
    294275                        /* ...And insert in the new.  That'll teach ya! */
    295276                        insque(pData, ifm->ifs_next, &if_batchq);
    296 #ifdef VBOX_WITH_SYNC_SLIRP
    297                         RTSemMutexRelease(pData->if_batchq_mutex);
    298 #endif
     277                        VBOX_SLIRP_UNLOCK(pData->if_batchq_mutex);
    299278                }
    300 #ifdef VBOX_WITH_SYNC_SLIRP
    301                 RTSemMutexRelease(so->so_mutex);
    302 #endif
    303         }
    304 #ifdef VBOX_WITH_SYNC_SLIRP
    305         RTSemMutexRelease(ifq->m_mutex);
    306         RTSemMutexRelease(ifm->m_mutex);
    307 #endif
     279                VBOX_SLIRP_UNLOCK(so->so_mutex);
     280        }
     281        VBOX_SLIRP_UNLOCK(ifq->m_mutex);
     282        VBOX_SLIRP_UNLOCK(ifm->m_mutex);
    308283
    309284#ifndef FULL_BOLT
    … …  
    341316        DEBUG_CALL("if_start");
    342317
    343 #ifdef VBOX_WITH_SYNC_SLIRP
    344         RTSemMutexRequest(pData->if_queued_mutex, RT_INDEFINITE_WAIT);
    345 #endif
     318        VBOX_SLIRP_LOCK(pData->if_queued_mutex);
    346319        if (if_queued <= 0) {
    347 #ifdef VBOX_WITH_SYNC_SLIRP
    348             RTSemMutexRelease(pData->if_queued_mutex);
    349 #endif
     320           VBOX_SLIRP_UNLOCK(pData->if_queued_mutex);
    350321           return; /* Nothing to do */
    351322        }
    352323
    353324 again:
    354 #ifdef VBOX_WITH_SYNC_SLIRP
    355         RTSemMutexRelease(pData->if_queued_mutex);
    356 #endif
     325        VBOX_SLIRP_UNLOCK(pData->if_queued_mutex);
     326
    357327        /* check if we can really output */
    358328        if (!slirp_can_output(pData->pvUser))
    … …  
    363333         * If there's something in the fastq, select it immediately
    364334         */
    365 #ifdef VBOX_WITH_SYNC_SLIRP
    366         RTSemMutexRequest(pData->if_fastq_mutex, RT_INDEFINITE_WAIT);
    367 #endif
     335        VBOX_SLIRP_LOCK(pData->if_fastq_mutex);
    368336        if (if_fastq.ifq_next != &if_fastq) {
    369337                ifm = if_fastq.ifq_next;
    370338#ifdef VBOX_WITH_SYNC_SLIRP
    371339                on_fast = 1;
    372                 RTSemMutexRequest(ifm->m_mutex, RT_INDEFINITE_WAIT);
    373 #endif
     340#endif
     341            VBOX_SLIRP_LOCK(ifm->m_mutex);
    374342        } else {
    375 #ifdef VBOX_WITH_SYNC_SLIRP
    376                 RTSemMutexRelease(pData->if_fastq_mutex);
    377 
    378                 RTSemMutexRequest(pData->if_batchq_mutex, RT_INDEFINITE_WAIT);
    379                 RTSemMutexRequest(pData->next_m_mutex, RT_INDEFINITE_WAIT);
    380 #endif
     343            VBOX_SLIRP_UNLOCK(pData->if_fastq_mutex);
     344
     345            VBOX_SLIRP_LOCK(pData->if_batchq_mutex);
     346            VBOX_SLIRP_LOCK(pData->next_m_mutex);
    381347                /* Nothing on fastq, see if next_m is valid */
    382348                if (next_m != &if_batchq)
    … …  
    387353                /* Set which packet to send on next iteration */
    388354                next_m = ifm->ifq_next;
    389 #ifdef VBOX_WITH_SYNC_SLIRP
    390                 RTSemMutexRelease(pData->next_m_mutex);
    391 #endif
    392         }
    393 #ifdef VBOX_WITH_SYNC_SLIRP
    394         RTSemMutexRequest(ifm->m_mutex, RT_INDEFINITE_WAIT);
    395         RTSemMutexRequest(pData->if_queued_mutex, RT_INDEFINITE_WAIT);
     355                VBOX_SLIRP_UNLOCK(pData->next_m_mutex);
     356        }
     357#ifdef VBOX_WITH_SYNC_SLIRP
     358        VBOX_SLIRP_LOCK(ifm->m_mutex);
     359        VBOX_SLIRP_LOCK(pData->if_queued_mutex);
    396360        if (if_queued == 0) {
    397361            if (on_fast) {
    398                 RTSemMutexRelease(pData->if_fastq_mutex);
     362                VBOX_SLIRP_UNLOCK(pData->if_fastq_mutex);
    399363            }else {
    400                 RTSemMutexRelease(pData->if_batchq_mutex);
     364                VBOX_SLIRP_UNLOCK(pData->if_batchq_mutex);
    401365            }
    402366            goto done;
    … …  
    409373        --if_queued;
    410374#ifdef VBOX_WITH_SYNC_SLIRP
    411         RTSemMutexRelease(pData->if_queued_mutex);
     375        VBOX_SLIRP_UNLOCK(pData->if_queued_mutex);
    412376        if (on_fast == 1) {
    413             RTSemMutexRelease(pData->if_fastq_mutex);
     377            VBOX_SLIRP_UNLOCK(pData->if_fastq_mutex);
    414378        }
    415379        else {
    416             RTSemMutexRelease(pData->if_batchq_mutex);
     380            VBOX_SLIRP_UNLOCK(pData->if_batchq_mutex);
    417381        }
    418382#endif
    … …  
    426390        /* Update so_queued */
    427391        if (ifm->ifq_so) {
    428 #ifdef VBOX_WITH_SYNC_SLIRP
    429             RTSemMutexRequest(ifm->ifq_so->so_mutex, RT_INDEFINITE_WAIT);
    430 #endif
     392                VBOX_SLIRP_LOCK(ifm->ifq_so->so_mutex);
    431393                if (--ifm->ifq_so->so_queued == 0)
    432394                   /* If there's no more queued, reset nqueued */
    433395                   ifm->ifq_so->so_nqueued = 0;
    434 #ifdef VBOX_WITH_SYNC_SLIRP
    435             RTSemMutexRelease(ifm->ifq_so->so_mutex);
    436 #endif
     396                VBOX_SLIRP_UNLOCK(ifm->ifq_so->so_mutex);
    437397        }
    438398
    … …  
    442402        m_free(pData, ifm);
    443403
    444 #ifdef VBOX_WITH_SYNC_SLIRP
    445         if (ifm != NULL) RTSemMutexRelease(ifm->m_mutex);
    446         RTSemMutexRequest(pData->if_queued_mutex, RT_INDEFINITE_WAIT);
     404        if (ifm != NULL)VBOX_SLIRP_UNLOCK(ifm->m_mutex);
     405            VBOX_SLIRP_LOCK(pData->if_queued_mutex);
    447406        /*We release if_queued_mutex after again label and before return*/
    448 #endif
     407
    449408        if (if_queued > 0)
    450409           goto again;
    451 #ifdef VBOX_WITH_SYNC_SLIRP
    452410        done:
    453         RTSemMutexRelease(pData->if_queued_mutex);
    454 #endif
    455 }
     411        VBOX_SLIRP_UNLOCK(pData->if_queued_mutex);
     412}

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

    r13727 r13733  
    566566#ifndef VBOX_WITH_SYNC_SLIRP
    567567                for (so = tcb.so_next; so != &tcb; so = so_next) {
     568                    so_next = so->so_next;
    568569#else
    569570                while (1) {
    … …  
    572573                        break;
    573574                    }
    574 #endif
    575575                    so_next = so->so_next;
     576
     577                    AssertRelease(so->so_mutex != NULL);
     578                    AssertRelease(so->so_next != NULL &&  so->so_prev != NULL);
     579#endif
    576580                    VBOX_SLIRP_LOCK(so->so_mutex);
    577581                    VBOX_SLIRP_UNLOCK(pData->tcb_mutex);

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

    r13727 r13733  
    113113      udp_last_so = &udb;
    114114
    115     if(so->so_next && so->so_prev)
     115    AssertRelease(so->so_next != NULL &&  so->so_prev != NULL);
     116    if(so->so_next && so->so_prev) {
    116117      remque(pData, so);  /* crashes if so is not in a queue */
     118    }
     119#ifdef VBOX_SLIRP_LOCK
     120    else {
     121        Assert(!"shouldn't happens");
     122    }
     123#endif
    117124
    118125    if (so->so_type == IPPROTO_UDP) {
    … …  
    679686        if ((so->so_tcpcb = tcp_newtcpcb(pData, so)) == NULL) {
    680687                free(so);
     688#ifdef VBOX_SLIRP_UNLOCK
     689                so = NULL;
     690#endif
    681691                return NULL;
    682692        }

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

    r13710 r13733  
    424424            goto dropwithreset;
    425425
     426          if (inso != NULL) VBOX_SLIRP_UNLOCK(inso->so_mutex);
    426427          VBOX_SLIRP_LOCK(so->so_mutex);
    427428          if (tcp_attach(pData, so) < 0) {

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

    r13704 r13733  
    276276 */
    277277/*      free(tp, M_PCB);  */
    278 #ifdef VBOX_WITH_SYNC_SLIRP
    279         RTSemMutexRequest(pData->tcp_last_so_mutex, RT_INDEFINITE_WAIT);
    280         /*sofree destrys so_mutex*/
    281         RTSemMutexRequest(so->so_mutex, RT_INDEFINITE_WAIT);
    282 #endif
     278        VBOX_SLIRP_LOCK(so->so_mutex);
     279
    283280        u32ptr_done(pData, ptr_to_u32(pData, tp), tp);
    284281        free(tp);
    285282        so->so_tcpcb = 0;
    286283        soisfdisconnected(so);
     284        VBOX_SLIRP_LOCK(pData->tcp_last_so_mutex);
    287285        /* clobber input socket cache if we're closing the cached connection */
    288286        if (so == tcp_last_so)
    289287                tcp_last_so = &tcb;
     288        VBOX_SLIRP_UNLOCK(pData->tcp_last_so_mutex);
    290289        closesocket(so->s);
    291290        sbfree(&so->so_rcv);
    292291        sbfree(&so->so_snd);
    293292        sofree(pData, so);
     293        if(so != NULL) VBOX_SLIRP_LOCK(so->so_mutex);
    294294        tcpstat.tcps_closed++;
    295 #ifdef VBOX_WITH_SYNC_SLIRP
    296         RTSemMutexRelease(pData->tcp_last_so_mutex);
    297 #endif
    298295        return ((struct tcpcb *)0);
    299296}
    … …  
    456453        DEBUG_CALL("tcp_connect");
    457454        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
     455        VBOX_SLIRP_LOCK(inso->so_mutex);
    465456
    466457        /*
    … …  
    472463                so = inso;
    473464        } else {
     465                VBOX_SLIRP_UNLOCK(inso->so_mutex);
    474466                if ((so = socreate()) == NULL) {
    475467                        /* If it failed, get rid of the pending connection */
    476468                        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
     469                        VBOX_SLIRP_UNLOCK(inso->so_mutex);
    483470                        return;
    484471                }
    485 #ifdef VBOX_WITH_SYNC_SLIRP
    486                 rc = RTSemMutexRequest(so->so_mutex, RT_INDEFINITE_WAIT);
    487                 AssertReleaseRC(rc);
    488 #endif
     472                VBOX_SLIRP_LOCK(so->so_mutex);
    489473                if (tcp_attach(pData, so) < 0) {
    490 #ifndef VBOX_WITH_SYNC_SLIRP
     474                        if(so != NULL) VBOX_SLIRP_UNLOCK(so->so_mutex);
    491475                        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
    503476                        return;
    504477                }
    505 #ifdef VBOX_WITH_SYNC_SLIRP
    506                 rc = RTSemMutexRelease(pData->tcb_mutex);
    507                 AssertReleaseRC(rc);
    508 #endif
    509478                so->so_laddr = inso->so_laddr;
    510479                so->so_lport = inso->so_lport;
    … …  
    515484        if ((s = accept(inso->s,(struct sockaddr *)&addr,&addrlen)) < 0) {
    516485                tcp_close(pData, sototcpcb(so)); /* This will sofree() as well */
    517 #ifdef VBOX_WITH_SYNC_SLIRP
    518486                if (so != inso) {
    519                     rc = RTSemMutexRelease(inso->so_mutex);
    520                     AssertReleaseRC(rc);
     487                    VBOX_SLIRP_UNLOCK(inso->so_mutex);
    521488                }
    522                 rc = RTSemMutexRelease(so->so_mutex);
    523                 AssertReleaseRC(rc);
    524 #endif
     489                VBOX_SLIRP_UNLOCK(so->so_mutex);
    525490                return;
    526491        }
    … …  
    545510                                           /* if it's not FACCEPTONCE, it's already NOFDREF */
    546511        }
    547 #ifdef VBOX_WITH_SYNC_SLIRP
    548512        if (so != inso) {
    549             rc = RTSemMutexRelease(inso->so_mutex);
    550             AssertReleaseRC(rc);
     513            VBOX_SLIRP_UNLOCK(inso->so_mutex);
    551514        }
    552 #endif
    553515        so->s = s;
    554516
    … …  
    573535        tcp_sendseqinit(tp);
    574536        tcp_output(pData, tp);
    575 #ifdef VBOX_WITH_SYNC_SLIRP
    576         rc = RTSemMutexRelease(so->so_mutex);
    577         AssertReleaseRC(rc);
    578 #endif
     537        VBOX_SLIRP_UNLOCK(so->so_mutex);
    579538}
    580539
    … …  
    585544tcp_attach(PNATState pData, struct socket *so)
    586545{
    587         if ((so->so_tcpcb = tcp_newtcpcb(pData, so)) == NULL)
     546        if ((so->so_tcpcb = tcp_newtcpcb(pData, so)) == NULL){
    588547           return -1;
     548        }
     549
     550
     551        VBOX_SLIRP_LOCK(pData->tcb_mutex);
     552        VBOX_SLIRP_LOCK(so->so_mutex);
     553        insque(pData, so, &tcb);
     554        VBOX_SLIRP_UNLOCK(pData->tcb_mutex);
     555
    589556#ifdef VBOX_WITH_SYNC_SLIRP
    590         int rc = RTSemMutexRequest(so->so_mutex, RT_INDEFINITE_WAIT);
    591         AssertReleaseRC(rc);
     557        /*we use this field to identify cache socket to lock/unlock*/
    592558        so->so_type = IPPROTO_TCP;
    593 
    594         rc = RTSemMutexRequest(pData->tcb_mutex, RT_INDEFINITE_WAIT);
    595         AssertReleaseRC(rc);
    596         insque(pData, so, &tcb);
    597         rc = RTSemMutexRelease(pData->tcb_mutex);
    598         AssertReleaseRC(rc);
    599 
    600         rc = RTSemMutexRelease(so->so_mutex);
    601         AssertReleaseRC(rc);
    602 #else
    603         insque(pData, so, &tcb);
    604559#endif
    605560
     561        VBOX_SLIRP_UNLOCK(so->so_mutex);
    606562        return 0;
    607563}
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