VirtualBox

Changeset 13783 in vbox for trunk/src/VBox/Devices/Network


Ignore:
Timestamp:
Nov 4, 2008 12:48:28 PM (16 years ago)
Author:
vboxsync
Message:

per-socket and per-mbuf mutexes are removed
only global locks are stayin on their places

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

Legend:

Unmodified
Added
Removed

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

    r13740 r13783  
    5050
    5151        VBOX_SLIRP_LOCK_CREATE(&pData->if_fastq_mutex);
    52         VBOX_SLIRP_LOCK_CREATE(&if_fastq.m_mutex);
    5352
    5453        if_batchq.ifq_next = if_batchq.ifq_prev = &if_batchq;
    5554
    5655        VBOX_SLIRP_LOCK_CREATE(&pData->if_batchq_mutex);
    57         VBOX_SLIRP_LOCK_CREATE(&if_batchq.m_mutex);
    5856
    5957        /*      sl_compress_init(&comp_s); */
    … …  
    173171         */
    174172        VBOX_SLIRP_LOCK(pData->m_usedlist_mutex);
    175         VBOX_SLIRP_LOCK(ifm->m_mutex);
    176173
    177174        if (ifm->m_flags & M_USEDLIST) {
    … …  
    200197            ifqprev = ifq->ifq_prev;
    201198#endif
    202             VBOX_SLIRP_LOCK(ifq->m_mutex);
    203199            VBOX_SLIRP_UNLOCK(pData->if_batchq_mutex);
    204200            if (so == ifq->ifq_so) {
    … …  
    208204                        goto diddit;
    209205            }
    210             VBOX_SLIRP_UNLOCK(ifq->m_mutex);
    211206            VBOX_SLIRP_LOCK(pData->if_batchq_mutex);
    212207#ifdef VBOX_WITH_SYNC_SLIRP
    … …  
    219214                VBOX_SLIRP_LOCK(pData->if_fastq_mutex);
    220215                ifq = if_fastq.ifq_prev;
    221                 VBOX_SLIRP_LOCK(ifq->m_mutex);
    222216                VBOX_SLIRP_UNLOCK(pData->if_fastq_mutex);
    223217                on_fastq = 1;
    … …  
    235229                VBOX_SLIRP_LOCK(pData->if_batchq_mutex);
    236230                ifq = if_batchq.ifq_prev;
    237                 if (ifq != &if_batchq) {
    238                     VBOX_SLIRP_LOCK(ifq->m_mutex);
    239                 }
    240231                VBOX_SLIRP_UNLOCK(pData->if_batchq_mutex);
    241232        }
    … …  
    255246        if (so) {
    256247                /* Update *_queued */
    257                 VBOX_SLIRP_LOCK(so->so_mutex);
    258248                so->so_queued++;
    259249                so->so_nqueued++;
    … …  
    279269                        VBOX_SLIRP_UNLOCK(pData->if_batchq_mutex);
    280270                }
    281                 VBOX_SLIRP_UNLOCK(so->so_mutex);
    282         }
    283         VBOX_SLIRP_UNLOCK(ifq->m_mutex);
    284         VBOX_SLIRP_UNLOCK(ifm->m_mutex);
     271        }
    285272
    286273#ifndef FULL_BOLT
    … …  
    341328                on_fast = 1;
    342329#endif
    343             VBOX_SLIRP_LOCK(ifm->m_mutex);
    344330            VBOX_SLIRP_UNLOCK(pData->if_fastq_mutex);
    345331        } else {
    … …  
    359345                VBOX_SLIRP_UNLOCK(pData->if_batchq_mutex);
    360346        }
    361         VBOX_SLIRP_LOCK(ifm->m_mutex);
    362347        VBOX_SLIRP_LOCK(pData->if_queued_mutex);
    363348#ifdef VBOX_WITH_SYNC_SLIRP
    … …  
    373358        /* Remove it from the queue */
    374359        ifqt = ifm->ifq_prev;
    375         remque(pData, ifm);
     360        if (ifm->m_prev != ifm && ifm->m_prev != NULL)
     361            remque(pData, ifm);
    376362
    377363        --if_queued;
    … …  
    387373
    388374        /* If there are more packets for this session, re-queue them */
    389         if (ifm->ifs_next != /* ifm->ifs_prev != */ ifm) {
     375        if (ifm->ifs_next != /* ifm->ifs_prev != */ ifm && ifm->ifs_next != NULL) {
    390376                insque(pData, ifm->ifs_next, ifqt);
    391377                ifs_remque(ifm);
    … …  
    394380        /* Update so_queued */
    395381        if (ifm->ifq_so) {
    396                 VBOX_SLIRP_LOCK(ifm->ifq_so->so_mutex);
    397382                if (--ifm->ifq_so->so_queued == 0)
    398383                   /* If there's no more queued, reset nqueued */
    399384                   ifm->ifq_so->so_nqueued = 0;
    400                 VBOX_SLIRP_UNLOCK(ifm->ifq_so->so_mutex);
    401385        }
    402386
    … …  
    406390        m_free(pData, ifm);
    407391
    408         if (ifm != NULL)VBOX_SLIRP_UNLOCK(ifm->m_mutex);
    409             VBOX_SLIRP_LOCK(pData->if_queued_mutex);
     392        VBOX_SLIRP_LOCK(pData->if_queued_mutex);
    410393        /*We release if_queued_mutex after again label and before return*/
    411394

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

    r13710 r13783  
    7777        DEBUG_ARG("m_len = %d", m->m_len);
    7878
    79         VBOX_SLIRP_LOCK(m->m_mutex);
    8079
    8180        ipstat.ips_total++;
    … …  
    8382        if (m->m_len < sizeof (struct ip)) {
    8483                ipstat.ips_toosmall++;
    85                 VBOX_SLIRP_UNLOCK(m->m_mutex);
    8684                return;
    8785        }
    … …  
    197195                        ip = ip_reass(pData, (struct ipasfrag *)ip, fp);
    198196                        if (ip == 0) {
    199                             VBOX_SLIRP_UNLOCK(m->m_mutex);
    200197                            return;
    201198                        }
    202199                        ipstat.ips_reassembled++;
    203                         VBOX_SLIRP_UNLOCK(m->m_mutex);
    204200                        m = dtom(pData, ip);
    205                         VBOX_SLIRP_LOCK(m->m_mutex);
    206201                } else
    207202                        if (fp)
    … …  
    229224                m_free(pData, m);
    230225        }
    231         if (m != NULL) {
    232                 VBOX_SLIRP_UNLOCK(m->m_mutex);
    233         }
    234226        return;
    235227bad:
    236228        m_freem(pData, m);
    237         if (m != NULL) {
    238                 VBOX_SLIRP_UNLOCK(m->m_mutex);
    239         }
    240229        return;
    241230}

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

    r13710 r13783  
    7272                }
    7373
    74                 VBOX_SLIRP_LOCK_CREATE(&m->m_mutex);
    7574                VBOX_SLIRP_LOCK(pData->mbuf_alloced_mutex);
    7675
    … …  
    8685        }
    8786
    88         VBOX_SLIRP_LOCK(m->m_mutex);
    8987        VBOX_SLIRP_UNLOCK(pData->m_freelist_mutex);
    9088
    … …  
    103101        m->m_prevpkt = 0;
    104102
    105         VBOX_SLIRP_UNLOCK(m->m_mutex);
    106103end_error:
    107104        DEBUG_ARG("m = %lx", (long )m);
    … …  
    118115  if(m) {
    119116        /* Remove from m_usedlist */
    120         VBOX_SLIRP_LOCK(m->m_mutex);
    121117        if (m->m_flags & M_USEDLIST) {
    122118           VBOX_SLIRP_LOCK(pData->m_usedlist_mutex);
    … …  
    134130        if (m->m_flags & M_DOFREE) {
    135131                u32ptr_done(pData, ptr_to_u32(pData, m), m);
    136                 VBOX_SLIRP_UNLOCK(m->m_mutex);
    137                 VBOX_SLIRP_LOCK_DESTROY(m->m_mutex);
    138132                free(m);
    139133#ifdef VBOX_WITH_SYNC_SLIRP
    … …  
    149143                VBOX_SLIRP_UNLOCK(pData->m_freelist_mutex);
    150144        }
    151         if (m != NULL) VBOX_SLIRP_UNLOCK(m->m_mutex);
    152145  } /* if(m) */
    153146}
    … …  
    164157         * If there's no room, realloc
    165158         */
    166         VBOX_SLIRP_LOCK(m->m_mutex);
    167         VBOX_SLIRP_LOCK(n->m_mutex);
    168159
    169160        if (M_FREEROOM(m) < n->m_len)
    … …  
    175166        m_free(pData, n);
    176167
    177         VBOX_SLIRP_UNLOCK(m->m_mutex);
    178         if (n != NULL) VBOX_SLIRP_UNLOCK(n->m_mutex);
    179168}
    180169
    … …  
    189178
    190179        /* some compiles throw up on gotos.  This one we can fake. */
    191         VBOX_SLIRP_LOCK(m->m_mutex);
    192180        if(m->m_size>size) {
    193             VBOX_SLIRP_UNLOCK(m->m_mutex);
    194181            return;
    195182        }
    … …  
    217204
    218205        m->m_size = size;
    219         VBOX_SLIRP_UNLOCK(m->m_mutex);
    220206}
    221207
    … …  
    229215        if (m == NULL)
    230216                return;
    231         VBOX_SLIRP_LOCK(m->m_mutex);
    232217        if (len >= 0) {
    233218                /* Trim from head */
    … …  
    239224                m->m_len -= len;
    240225        }
    241         VBOX_SLIRP_UNLOCK(m->m_mutex);
    242226}
    243227
    … …  
    251235        int off, len;
    252236{
    253         VBOX_SLIRP_LOCK(m->m_mutex);
    254         VBOX_SLIRP_LOCK(n->m_mutex);
    255237        if (len > M_FREEROOM(n)) {
    256                 VBOX_SLIRP_UNLOCK(n->m_mutex);
    257                 VBOX_SLIRP_UNLOCK(m->m_mutex);
    258238                return -1;
    259239        }
    … …  
    261241        memcpy((n->m_data + n->m_len), (m->m_data + off), len);
    262242        n->m_len += len;
    263         VBOX_SLIRP_UNLOCK(n->m_mutex);
    264         VBOX_SLIRP_UNLOCK(m->m_mutex);
    265243        return 0;
    266244}
    … …  
    288266        m = m_usedlist.m_next;
    289267        while(1) {
    290             VBOX_SLIRP_LOCK(m->m_mutex);
    291268            mnext = m->m_next;
    292             VBOX_SLIRP_UNLOCK(pData->m_usedlist_mutex);
    293269#endif
    294270          if (m->m_flags & M_EXT) {
    295271            if( (char *)dat>=m->m_ext && (char *)dat<(m->m_ext + m->m_size) ) {
    296               VBOX_SLIRP_UNLOCK(m->m_mutex);
    297272              return m;
    298273            }
    299274          } else {
    300275            if( (char *)dat >= m->m_dat && (char *)dat<(m->m_dat + m->m_size) ) {
    301               VBOX_SLIRP_UNLOCK(m->m_mutex);
    302276              return m;
    303277            }
    304278          }
    305           VBOX_SLIRP_UNLOCK(m->m_mutex);
    306           VBOX_SLIRP_LOCK(pData->m_usedlist_mutex);
    307279#ifdef VBOX_WITH_SYNC_SLIRP
    308280          m = mnext;

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

    r13738 r13783  
    7676        caddr_t mh_data;                /* Location of data */
    7777        int     mh_len;                 /* Amount of data in this mbuf */
    78 #ifdef VBOX_WITH_SYNC_SLIRP
    79         RTSEMFASTMUTEX mh_mutex;
    80 #endif
    8178};
    8279

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

    r13776 r13783  
    384384#endif
    385385                    so_next = so->so_next;
    386 #ifdef VBOX_WITH_SYNC_SLIRP
    387                     VBOX_SLIRP_LOCK(so->so_mutex);
    388                     while (so->so_destroy == 1) {
    389                         VBOX_SLIRP_UNLOCK(so->so_mutex);
    390                         VBOX_SLIRP_LOCK_DESTROY(so->so_mutex);
    391                         free(so);
    392                         so = so_next;
    393                         so_next = so->so_next;
    394                         if (so == &tcb) {
    395                             goto tcp_loop_begin;
    396                         }
    397                         VBOX_SLIRP_LOCK(so->so_mutex);
    398                     }
    399 #endif
    400386                    VBOX_SLIRP_UNLOCK(pData->tcb_mutex);
    401387
    … …  
    403389                         * See if we need a tcp_fasttimo
    404390                         */
    405                         if (time_fasttimo == 0 && so->so_tcpcb->t_flags & TF_DELACK)
     391                        if (time_fasttimo == 0
     392                            && so->so_tcpcb
     393                            &&  so->so_tcpcb->t_flags & TF_DELACK)
    406394                           time_fasttimo = curtime; /* Flag when we want a fasttimo */
    407395
    … …  
    451439                before_loop_ends:
    452440                        /*Release of global tcb mutex happens in the head of loop*/
    453                         VBOX_SLIRP_UNLOCK(so->so_mutex);
    454441                        VBOX_SLIRP_LOCK(pData->tcb_mutex);
    455442#ifdef VBOX_WITH_SYNC_SLIRP
    … …  
    473460#endif
    474461                    so_next = so->so_next;
    475                     VBOX_SLIRP_LOCK(so->so_mutex);
    476462                    VBOX_SLIRP_UNLOCK(pData->udb_mutex);
    477463
    … …  
    502488                        }
    503489                        before_udp_loop_end:
    504                         VBOX_SLIRP_UNLOCK(so->so_mutex);
    505490                        VBOX_SLIRP_LOCK(pData->udb_mutex);
    506491#ifdef VBOX_WITH_SYNC_SLIRP
    … …  
    591576
    592577
    593                     VBOX_SLIRP_LOCK(so->so_mutex);
    594 #ifdef VBOX_WITH_SYNC_SLIRP
    595                     while (so->so_destroy == 1) {
    596                         VBOX_SLIRP_UNLOCK(so->so_mutex);
    597                         VBOX_SLIRP_LOCK_DESTROY(so->so_mutex);
    598                         free(so);
    599                         so = so_next;
    600                         so_next = so->so_next;
    601                         if (so == &tcb)
    602                             goto loop_begin;
    603                         VBOX_SLIRP_LOCK(so->so_mutex);
    604                     }
    605 #endif
    606578                    VBOX_SLIRP_UNLOCK(pData->tcb_mutex);
    607579
    … …  
    719691#endif
    720692                    before_loop_ends:
    721                     VBOX_SLIRP_UNLOCK(so->so_mutex);
    722693                    VBOX_SLIRP_LOCK(pData->tcb_mutex);
    723694#ifdef VBOX_WITH_SYNC_SLIRP
    … …  
    743714#endif
    744715                    so_next = so->so_next;
    745                     VBOX_SLIRP_LOCK(so->so_mutex);
    746716                    VBOX_SLIRP_UNLOCK(pData->udb_mutex);
    747717
    … …  
    749719                            sorecvfrom(pData, so);
    750720                        }
    751                     VBOX_SLIRP_UNLOCK(so->so_mutex);
    752721                    VBOX_SLIRP_LOCK(pData->udb_mutex);
    753722#ifdef VBOX_WITH_SYNC_SLIRP
    … …  
    884853        if (!m)
    885854            return;
    886         VBOX_SLIRP_LOCK(m->m_mutex);
    887855        /* Note: we add to align the IP header */
    888856        if (M_FREEROOM(m) < pkt_len + 2) {
    … …  
    896864
    897865        ip_input(pData, m);
    898         VBOX_SLIRP_UNLOCK(m->m_mutex);
    899866        break;
    900867    default:

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

    r13738 r13783  
    6464    so->so_state = SS_NOFDREF;
    6565    so->s = -1;
    66     VBOX_SLIRP_LOCK_CREATE(&so->so_mutex);
    6766  }
    6867  return(so);
    … …  
    9291    /*Take global mutexes of udb and tcb, because we dont know which is mutex */
    9392    /*XXX: don't forget to set correct so_type in corresponded attach operation */
    94     VBOX_SLIRP_LOCK(so->so_mutex);
    9593    if (so->so_emu==EMU_RSH && so->extra) {
    9694          sofree(pData, so->extra);
    … …  
    113111      udp_last_so = &udb;
    114112
    115 #if 0
    116113    if(so->so_next && so->so_prev) {
    117114      remque(pData, so);  /* crashes if so is not in a queue */
    118115    }
    119 #else
    120       remque(pData, so);  /* crashes if so is not in a queue */
    121 #endif
     116
    122117    if (so->so_type == IPPROTO_UDP) {
    123118        VBOX_SLIRP_UNLOCK(pData->udp_last_so_mutex);
    … …  
    132127
    133128    m_free(pData, so->so_m);
    134     so->so_destroy = 1;
    135 
    136 
    137     VBOX_SLIRP_UNLOCK(so->so_mutex);
     129    free(so);
     130
     131
    138132#endif
    139133
    … …  
    156150        struct iovec iov[2];
    157151        int mss;
    158         VBOX_SLIRP_LOCK(so->so_mutex);
    159152        sb = &so->so_snd;
    160         VBOX_SLIRP_UNLOCK(so->so_mutex);
    161153        len = sb->sb_datalen - sb->sb_cc;
    162154        mss = so->so_tcpcb->t_maxseg;
    … …  
    213205        }
    214206
    215         VBOX_SLIRP_LOCK(so->so_mutex);
    216207#ifdef HAVE_READV
    217208        nn = readv(so->s, (struct iovec *)iov, n);
    … …  
    222213        if (nn <= 0) {
    223214                if (nn < 0 && (errno == EINTR || errno == EAGAIN)) {
    224                         VBOX_SLIRP_UNLOCK(so->so_mutex);
    225215                        return 0;
    226216                }
    … …  
    229219                        sofcantrcvmore(so);
    230220                        tcp_sockclosed(pData, sototcpcb(so));
    231                         VBOX_SLIRP_UNLOCK(so->so_mutex);
    232221                        return -1;
    233222                }
    234223        }
    235         VBOX_SLIRP_UNLOCK(so->so_mutex);
    236224
    237225#ifndef HAVE_READV
    … …  
    274262{
    275263        struct tcpcb *tp;
    276         VBOX_SLIRP_LOCK(so->so_mutex);
    277264        tp = sototcpcb(so);
    278265
    … …  
    290277        soread(pData, so);
    291278        tp->snd_up = tp->snd_una + so->so_snd.sb_cc;
    292         VBOX_SLIRP_UNLOCK(so->so_mutex);
    293279        tp->t_force = 1;
    294280        tcp_output(pData, tp);
    … …  
    309295        int n, len;
    310296
    311         VBOX_SLIRP_LOCK(so->so_mutex);
    312297        sb = &so->so_rcv;
    313298
    … …  
    355340                sb->sb_rptr -= sb->sb_datalen;
    356341
    357         VBOX_SLIRP_UNLOCK(so->so_mutex);
    358342        return n;
    359343}
    … …  
    370354        int len;
    371355        struct iovec iov[2];
    372         VBOX_SLIRP_LOCK(so->so_mutex);
    373356        sb = &so->so_rcv;
    374357        len = sb->sb_cc;
    … …  
    380363                sosendoob(so);
    381364                if (sb->sb_cc == 0) {
    382                         VBOX_SLIRP_UNLOCK(so->so_mutex);
    383365                        return 0;
    384366                }
    … …  
    423405        /* This should never happen, but people tell me it does *shrug* */
    424406        if (nn < 0 && (errno == EAGAIN || errno == EINTR)) {
    425                 VBOX_SLIRP_UNLOCK(so->so_mutex);
    426407                return 0;
    427408        }
    … …  
    432413                sofcantsendmore(so);
    433414                tcp_sockclosed(pData, sototcpcb(so));
    434                 VBOX_SLIRP_UNLOCK(so->so_mutex);
    435415                return -1;
    436416        }
    … …  
    459439                sofcantsendmore(so);
    460440
    461         VBOX_SLIRP_UNLOCK(so->so_mutex);
    462441        return nn;
    463442}
    … …  
    475454        DEBUG_ARG("so = %lx", (long)so);
    476455
    477         VBOX_SLIRP_LOCK(so->so_mutex);
    478456
    479457        if (so->so_type == IPPROTO_ICMP) {   /* This is a "ping" reply */
    … …  
    562540          } /* rx error */
    563541        } /* if ping packet */
    564         VBOX_SLIRP_UNLOCK(so->so_mutex);
    565542}
    566543
    … …  
    576553        struct sockaddr_in host_addr;
    577554#endif
    578         VBOX_SLIRP_LOCK(so->so_mutex);
    579555
    580556        DEBUG_CALL("sosendto");
    … …  
    629605                     (struct sockaddr *)&addr, sizeof (struct sockaddr));
    630606        if (ret < 0) {
    631                 VBOX_SLIRP_UNLOCK(so->so_mutex);
    632607                return -1;
    633608        }
    … …  
    640615                so->so_expire = curtime + SO_EXPIRE;
    641616        so->so_state = SS_ISFCONNECTED; /* So that it gets select()ed */
    642         VBOX_SLIRP_UNLOCK(so->so_mutex);
    643617        return 0;
    644618}
    … …  
    676650
    677651        VBOX_SLIRP_LOCK(pData->tcb_mutex);
    678         VBOX_SLIRP_LOCK(so->so_mutex);
    679652        insque(pData, so,&tcb);
    680653        VBOX_SLIRP_UNLOCK(pData->tcb_mutex);
    … …  
    711684                errno = tmperrno;
    712685#endif
    713                 if(so != NULL) VBOX_SLIRP_UNLOCK(so->so_mutex);
    714686                return NULL;
    715687        }
    … …  
    725697        so->s = s;
    726698
    727         VBOX_SLIRP_UNLOCK(so->so_mutex);
    728699        return so;
    729700}
    … …  
    764735        register struct socket *so;
    765736{
    766     VBOX_SLIRP_LOCK(so->so_mutex);
    767737        so->so_state &= ~(SS_NOFDREF|SS_ISFCONNECTED|SS_FCANTRCVMORE|
    768738                          SS_FCANTSENDMORE|SS_FWDRAIN);
    769739        so->so_state |= SS_ISFCONNECTING; /* Clobber other states */
    770     VBOX_SLIRP_UNLOCK(so->so_mutex);
    771740}
    772741
    … …  
    775744        register struct socket *so;
    776745{
    777         VBOX_SLIRP_LOCK(so->so_mutex);
    778746        so->so_state &= ~(SS_ISFCONNECTING|SS_FWDRAIN|SS_NOFDREF);
    779747        so->so_state |= SS_ISFCONNECTED; /* Clobber other states */
    780         VBOX_SLIRP_UNLOCK(so->so_mutex);
    781748}
    782749
    … …  
    785752        struct  socket *so;
    786753{
    787         VBOX_SLIRP_LOCK(so->so_mutex);
    788754        if ((so->so_state & SS_NOFDREF) == 0) {
    789755                shutdown(so->s,0);
    … …  
    794760        else
    795761           so->so_state |= SS_FCANTRCVMORE;
    796         VBOX_SLIRP_UNLOCK(so->so_mutex);
    797762}
    798763
    … …  
    801766        struct socket *so;
    802767{
    803         VBOX_SLIRP_LOCK(so->so_mutex);
    804768        if ((so->so_state & SS_NOFDREF) == 0) {
    805769            shutdown(so->s,1);           /* send FIN to fhost */
    … …  
    810774        else
    811775           so->so_state |= SS_FCANTSENDMORE;
    812         VBOX_SLIRP_UNLOCK(so->so_mutex);
    813776}
    814777
    … …  
    833796        struct socket *so;
    834797{
    835         VBOX_SLIRP_LOCK(so->so_mutex);
    836798        if (so->so_rcv.sb_cc)
    837799                so->so_state |= SS_FWDRAIN;
    838800        else
    839801                sofcantsendmore(so);
    840         VBOX_SLIRP_UNLOCK(so->so_mutex);
    841 }
    842 
     802}
     803

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

    r13738 r13783  
    5555  struct sbuf so_snd;           /* Send buffer */
    5656  void * extra;                 /* Extra pointer */
    57 #ifdef VBOX_WITH_SYNC_SLIRP
    58   RTSEMFASTMUTEX so_mutex;          /*per socket mutex*/
    59   int   so_destroy;
    60 #endif
    6157};
    6258

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

    r13738 r13783  
    256256#endif
    257257
    258         if (inso != NULL) {
    259             VBOX_SLIRP_LOCK(inso->so_mutex);
    260         }
    261 
    262258        /*
    263259         * If called with m == 0, then we're continuing the connect
    … …  
    269265                tp = sototcpcb(so);
    270266                m = so->so_m;
    271                 VBOX_SLIRP_LOCK(m->m_mutex);
    272267                so->so_m = 0;
    273268                ti = so->so_ti;
    … …  
    277272                goto cont_conn;
    278273        }
    279         if (inso != NULL) {
    280             VBOX_SLIRP_UNLOCK(inso->so_mutex);
    281         }
    282         VBOX_SLIRP_LOCK(m->m_mutex);
    283274
    284275
    … …  
    374365         */
    375366findso:
    376         if (so != NULL) {
    377             VBOX_SLIRP_UNLOCK(so->so_mutex);
    378         }
    379367        VBOX_SLIRP_LOCK(pData->tcp_last_so_mutex);
    380368        so = tcp_last_so;
    381369        /* this checking for making sure that we're not trying to hold mutex on head list*/
    382         if (tcp_last_so != &tcb) {
    383             VBOX_SLIRP_LOCK(so->so_mutex);
    384         }
    385370        VBOX_SLIRP_UNLOCK(pData->tcp_last_so_mutex);
    386371
    … …  
    390375            so->so_faddr.s_addr != ti->ti_dst.s_addr) {
    391376                /*To make sure that we don't try to release mutex on head of the socket queue*/
    392                 if (so != &tcb) {
    393                     VBOX_SLIRP_UNLOCK(so->so_mutex);
    394                 }
    395377                so = solookup(&tcb, ti->ti_src, ti->ti_sport,
    396378                               ti->ti_dst, ti->ti_dport);
    397379                if (so) {
    398                         VBOX_SLIRP_LOCK(so->so_mutex);
    399380                        VBOX_SLIRP_LOCK(pData->tcp_last_so_mutex);
    400381                        tcp_last_so = so;
    … …  
    424405            goto dropwithreset;
    425406
    426           if (inso != NULL) VBOX_SLIRP_UNLOCK(inso->so_mutex);
    427407          if (tcp_attach(pData, so) < 0) {
    428             VBOX_SLIRP_UNLOCK(so->so_mutex);
    429             VBOX_SLIRP_LOCK_DESTROY(so->so_mutex);
    430408            free(so); /* Not sofree (if it failed, it's not insqued) */
    431409#ifdef VBOX_WITH_SYNC_SLIRP
    … …  
    434412            goto dropwithreset;
    435413          }
    436           VBOX_SLIRP_LOCK(so->so_mutex);
    437414
    438415          sbreserve(&so->so_snd, tcp_sndspace);
    … …  
    550527                                tp->snd_una = ti->ti_ack;
    551528                                m_freem(pData, m);
    552                                 if (m != NULL) {
    553                                     VBOX_SLIRP_UNLOCK(m->m_mutex);
    554                                 }
    555529
    556530                                /*
    … …  
    582556                                if (so->so_snd.sb_cc)
    583557                                        (void) tcp_output(pData, tp);
    584                                 VBOX_SLIRP_UNLOCK(so->so_mutex);
    585558                                return;
    586559                        }
    … …  
    622595                        tp->t_flags |= TF_ACKNOW;
    623596                        tcp_output(pData, tp);
    624                         VBOX_SLIRP_UNLOCK(so->so_mutex);
    625                         if (m != NULL) {
    626                            VBOX_SLIRP_UNLOCK(m->m_mutex);
    627                         }
    628597                        return;
    629598                }
    … …  
    726695            tp = tcp_close(pData, tp);
    727696            m_free(pData, m);
    728             if (m != NULL) {
    729                 VBOX_SLIRP_UNLOCK(m->m_mutex);
    730             }
    731697          } else {
    732698            /*
    … …  
    741707            tp->t_state = TCPS_SYN_RECEIVED;
    742708          }
    743           VBOX_SLIRP_UNLOCK(so->so_mutex);
    744           if (m != NULL) {
    745             VBOX_SLIRP_UNLOCK(m->m_mutex);
    746           }
    747709          return;
    748710
    … …  
    15031465        }
    15041466
    1505           VBOX_SLIRP_UNLOCK(so->so_mutex);
    1506           if (m != NULL) {
    1507             VBOX_SLIRP_UNLOCK(m->m_mutex);
    1508           }
    15091467        return;
    15101468
    … …  
    15191477        tp->t_flags |= TF_ACKNOW;
    15201478        (void) tcp_output(pData, tp);
    1521         VBOX_SLIRP_UNLOCK(so->so_mutex);
    1522         if (m != NULL) {
    1523           VBOX_SLIRP_UNLOCK(m->m_mutex);
    1524         }
    15251479        return;
    15261480
    … …  
    15351489        }
    15361490
    1537         if (so != NULL) VBOX_SLIRP_UNLOCK(so->so_mutex);
    1538         if (m != NULL) VBOX_SLIRP_UNLOCK(m->m_mutex);
    15391491        return;
    15401492
    … …  
    15441496         */
    15451497        m_free(pData, m);
    1546         VBOX_SLIRP_UNLOCK(so->so_mutex);
    1547         if (m != NULL) {
    1548           VBOX_SLIRP_UNLOCK(m->m_mutex);
    1549         }
    1550 
    15511498        return;
    15521499#ifdef VBOX_WITH_SYNC_SLIRP

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

    r13738 r13783  
    276276 */
    277277/*      free(tp, M_PCB);  */
    278         VBOX_SLIRP_LOCK(so->so_mutex);
    279278
    280279        u32ptr_done(pData, ptr_to_u32(pData, tp), tp);
    … …  
    291290        sbfree(&so->so_snd);
    292291        sofree(pData, so);
    293         if(so != NULL) VBOX_SLIRP_UNLOCK(so->so_mutex);
    294292        tcpstat.tcps_closed++;
    295293        return ((struct tcpcb *)0);
    … …  
    453451        DEBUG_CALL("tcp_connect");
    454452        DEBUG_ARG("inso = %lx", (long)inso);
    455         VBOX_SLIRP_LOCK(inso->so_mutex);
    456453
    457454        /*
    … …  
    463460                so = inso;
    464461        } else {
    465                 VBOX_SLIRP_UNLOCK(inso->so_mutex);
    466462                if ((so = socreate()) == NULL) {
    467463                        /* If it failed, get rid of the pending connection */
    468464                        closesocket(accept(inso->s,(struct sockaddr *)&addr,&addrlen));
    469                         VBOX_SLIRP_UNLOCK(inso->so_mutex);
    470465                        return;
    471466                }
    472                 VBOX_SLIRP_LOCK(so->so_mutex);
    473467                if (tcp_attach(pData, so) < 0) {
    474                         if(so != NULL) VBOX_SLIRP_UNLOCK(so->so_mutex);
    475468                        free(so); /* NOT sofree */
    476469                        return;
    … …  
    484477        if ((s = accept(inso->s,(struct sockaddr *)&addr,&addrlen)) < 0) {
    485478                tcp_close(pData, sototcpcb(so)); /* This will sofree() as well */
    486                 if (so != inso) {
    487                     VBOX_SLIRP_UNLOCK(inso->so_mutex);
    488                 }
    489                 VBOX_SLIRP_UNLOCK(so->so_mutex);
    490479                return;
    491480        }
    … …  
    510499                                           /* if it's not FACCEPTONCE, it's already NOFDREF */
    511500        }
    512         if (so != inso) {
    513             VBOX_SLIRP_UNLOCK(inso->so_mutex);
    514         }
    515501        so->s = s;
    516502
    … …  
    535521        tcp_sendseqinit(tp);
    536522        tcp_output(pData, tp);
    537         VBOX_SLIRP_UNLOCK(so->so_mutex);
    538523}
    539524
    … …  
    550535
    551536        VBOX_SLIRP_LOCK(pData->tcb_mutex);
    552         VBOX_SLIRP_LOCK(so->so_mutex);
    553537        insque(pData, so, &tcb);
    554538        VBOX_SLIRP_UNLOCK(pData->tcb_mutex);
    … …  
    559543#endif
    560544
    561         VBOX_SLIRP_UNLOCK(so->so_mutex);
    562545        return 0;
    563546}

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

    r13727 r13783  
    6464            }
    6565            so_next = so->so_next;
    66             VBOX_SLIRP_LOCK(so->so_mutex);
    6766            VBOX_SLIRP_UNLOCK(pData->tcb_mutex);
    6867#endif
    … …  
    7473                        (void) tcp_output(pData, tp);
    7574                }
    76                 VBOX_SLIRP_UNLOCK(so->so_mutex);
    7775                VBOX_SLIRP_LOCK(pData->tcb_mutex);
    7876#ifdef VBOX_WITH_SYNC_SLIRP
    … …  
    117115                }
    118116                ipnxt = ip->so_next;
    119                 VBOX_SLIRP_LOCK(ip->so_mutex);
    120117                VBOX_SLIRP_UNLOCK(pData->tcb_mutex);
    121118#endif
    … …  
    137134                ;
    138135before_loop_ends:
    139                 VBOX_SLIRP_UNLOCK(ip->so_mutex);
    140136                VBOX_SLIRP_LOCK(pData->tcb_mutex);
    141137#ifdef VBOX_WITH_SYNC_SLIRP

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

    r13710 r13783  
    7878        DEBUG_ARG("iphlen = %d", iphlen);
    7979
    80         VBOX_SLIRP_LOCK(m->m_mutex);
    8180
    8281        udpstat.udps_ipackets++;
    … …  
    160159        VBOX_SLIRP_LOCK(pData->udp_last_so_mutex);
    161160        so = udp_last_so;
    162         if (so != &udb) {
    163             VBOX_SLIRP_LOCK(so->so_mutex);
    164         }
    165161
    166162        VBOX_SLIRP_UNLOCK(pData->udp_last_so_mutex);
    … …  
    169165            so->so_laddr.s_addr != ip->ip_src.s_addr) {
    170166                struct socket *tmp;
    171                 if (so != &udb) {
    172                     /*we don't interesting in this socket any more*/
    173                     VBOX_SLIRP_UNLOCK(so->so_mutex);
    174                 }
    175167#ifndef VBOX_WITH_SYNC_SLIRP
    176168                for (tmp = udb.so_next; tmp != &udb; tmp = tmp->so_next) {
    … …  
    186178                        break; /* end of loop*/
    187179                    }
    188                     VBOX_SLIRP_LOCK(tmp->so_mutex);
    189180                    VBOX_SLIRP_UNLOCK(pData->udb_mutex);
    190181                    tmp_next = tmp->so_next;
    … …  
    195186                                break;
    196187                        }
    197                         VBOX_SLIRP_UNLOCK(tmp->so_mutex);
    198188                        VBOX_SLIRP_LOCK(pData->udb_mutex);
    199189#ifdef VBOX_WITH_SYNC_SLIRP
    … …  
    221211           */
    222212          if ((so = socreate()) == NULL) goto bad;
    223           VBOX_SLIRP_LOCK(so->so_mutex);
    224213          if(udp_attach(pData, so) == -1) {
    225214            DEBUG_MISC((dfd," udp_attach errno = %d-%s\n",
    … …  
    274263        so->so_m=m;         /* ICMP backup */
    275264
    276         VBOX_SLIRP_UNLOCK(so->so_mutex);
    277         VBOX_SLIRP_UNLOCK(m->m_mutex);
    278265        return;
    279266bad:
    280267        m_freem(pData, m);
    281268        /* if (opts) m_freem(opts); */
    282         if (m != NULL) {
    283             VBOX_SLIRP_UNLOCK(m->m_mutex);
    284         }
    285269        return;
    286270}
    … …  
    292276        register struct udpiphdr *ui;
    293277        int error = 0;
    294         if(so != NULL) {
    295             VBOX_SLIRP_LOCK(so->so_mutex);
    296         }
    297         VBOX_SLIRP_LOCK(m->m_mutex);
    298278
    299279        DEBUG_CALL("udp_output");
    … …  
    341321
    342322        error = ip_output(pData, so, m);
    343         if (so != NULL) VBOX_SLIRP_UNLOCK(so->so_mutex);
    344         VBOX_SLIRP_UNLOCK(m->m_mutex);
    345323        return (error);
    346324}
    … …  
    351329    struct sockaddr_in saddr, daddr;
    352330    int status;
    353     VBOX_SLIRP_LOCK(so->so_mutex);
    354331
    355332    saddr = *addr;
    … …  
    369346
    370347    status = udp_output2(pData, so, m, &saddr, &daddr, so->so_iptos);
    371     VBOX_SLIRP_UNLOCK(so->so_mutex);
    372348    return status;
    373349}
    … …  
    377353{
    378354  struct sockaddr_in addr;
    379     VBOX_SLIRP_LOCK(so->so_mutex);
    380355
    381356  if((so->s = socket(AF_INET,SOCK_DGRAM,0)) != -1) {
    … …  
    411386  so->so_type = IPPROTO_UDP;
    412387#endif
    413   VBOX_SLIRP_UNLOCK(so->so_mutex);
    414388  return(so->s);
    415389}
    … …  
    419393{
    420394        /* Correctly update list if detaching last socket in list. */
    421         VBOX_SLIRP_LOCK(so->so_mutex);
    422395        VBOX_SLIRP_LOCK(pData->udp_last_so_mutex);
    423396        if (so == udp_last_so) udp_last_so = &udb;
    … …  
    428401        sofree(pData, so);
    429402
    430         if (so != NULL) {
    431             VBOX_SLIRP_UNLOCK(so->so_mutex);
    432         }
    433403}
    434404
    … …  
    450420                if ((udptos[i].fport && ntohs(so->so_fport) == udptos[i].fport) ||
    451421                    (udptos[i].lport && ntohs(so->so_lport) == udptos[i].lport)) {
    452                         VBOX_SLIRP_LOCK(so->so_mutex);
    453422                        so->so_emu = udptos[i].emu;
    454                         VBOX_SLIRP_UNLOCK(so->so_mutex);
    455423                        return udptos[i].tos;
    456424                }
    … …  
    502470} *cu_head;
    503471
    504         VBOX_SLIRP_LOCK(so->so_mutex);
    505 #ifdef VBOX_WITH_SYNC_SLIRP
    506 #define return \
    507                 do {                                        \
    508                     VBOX_SLIRP_UNLOCK(so->so_mutex);        \
    509                     return;                                 \
    510                 }while(0)
    511 #endif
    512472
    513473        switch(so->so_emu) {
    … …  
    701661                return;
    702662        }
    703 /*see macro definition in the begining of method*/
    704 #ifdef VBOX_WITH_SYNC_SLIRP
    705     return;
    706 #undef return
    707 #endif
    708663}
    709664
    … …  
    722677        so->s = socket(AF_INET,SOCK_DGRAM,0);
    723678        so->so_expire = curtime + SO_EXPIRE;
    724         VBOX_SLIRP_LOCK(so->so_mutex);
    725679        VBOX_SLIRP_LOCK(pData->udb_mutex);
    726680        insque(pData, so,&udb);
    … …  
    733687        if (bind(so->s,(struct sockaddr *)&addr, addrlen) < 0) {
    734688                udp_detach(pData, so);
    735                 VBOX_SLIRP_UNLOCK(so->so_mutex);
    736689                return NULL;
    737690        }
    … …  
    755708
    756709        so->so_state = SS_ISFCONNECTED;
    757         VBOX_SLIRP_UNLOCK(so->so_mutex);
    758710
    759711        return so;
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