VirtualBox

Changeset 13710 in vbox


Ignore:
Timestamp:
Oct 31, 2008 12:04:30 PM (17 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
38677
Message:

mid point in replacing on VBOX_SLIRP_LOCK/UNLOCK macroces
resolved deadlock

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

Legend:

Unmodified
Added
Removed

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

    r13704 r13710  
    6969        register struct ip *ip;
    7070        int hlen;
     71#ifdef VBOX_WITH_SYNC_SLIRP
     72        int rc;
     73#endif
    7174
    7275        DEBUG_CALL("ip_input");
    … …  
    7477        DEBUG_ARG("m_len = %d", m->m_len);
    7578
    76 #ifdef VBOX_WITH_SYNC_SLIRP
    77         int rc;
    78         rc = RTSemMutexRequest(m->m_mutex, RT_INDEFINITE_WAIT);
    79         AssertReleaseRC(rc);
    80 #endif
     79        VBOX_SLIRP_LOCK(m->m_mutex);
    8180
    8281        ipstat.ips_total++;
    … …  
    8483        if (m->m_len < sizeof (struct ip)) {
    8584                ipstat.ips_toosmall++;
    86 #ifdef VBOX_WITH_SYNC_SLIRP
    87                 rc = RTSemMutexRelease(m->m_mutex);
    88                 AssertReleaseRC(rc);
    89 #endif
     85                VBOX_SLIRP_UNLOCK(m->m_mutex);
    9086                return;
    9187        }
    … …  
    200196                        ipstat.ips_fragments++;
    201197                        ip = ip_reass(pData, (struct ipasfrag *)ip, fp);
    202                         if (ip == 0)
    203 #ifndef VBOX_WITH_SYNC_SLIRP
    204                                 return;
    205 #else
    206                         {
    207                             rc = RTSemMutexRelease(m->m_mutex);
    208                             AssertReleaseRC(rc);
     198                        if (ip == 0) {
     199                            VBOX_SLIRP_UNLOCK(m->m_mutex);
    209200                            return;
    210201                        }
    211 #endif
    212202                        ipstat.ips_reassembled++;
    213 #ifndef VBOX_WITH_SYNC_SLIRP
     203                        VBOX_SLIRP_UNLOCK(m->m_mutex);
    214204                        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
     205                        VBOX_SLIRP_LOCK(m->m_mutex);
    222206                } else
    223207                        if (fp)
    … …  
    234218         case IPPROTO_TCP:
    235219                tcp_input(pData, m, hlen, (struct socket *)NULL);
    236 #ifdef VBOX_WITH_SYNC_SLIRP
    237                 rc = RTSemMutexRelease(m->m_mutex);
    238                 AssertReleaseRC(rc);
    239 #endif
    240220                break;
    241221         case IPPROTO_UDP:
    242222                udp_input(pData, m, hlen);
    243 #ifdef VBOX_WITH_SYNC_SLIRP
    244                 rc = RTSemMutexRelease(m->m_mutex);
    245                 AssertReleaseRC(rc);
    246 #endif
    247223                break;
    248224         case IPPROTO_ICMP:
    249225                icmp_input(pData, m, hlen);
    250 #ifdef VBOX_WITH_SYNC_SLIRP
    251                 rc = RTSemMutexRelease(m->m_mutex);
    252                 AssertReleaseRC(rc);
    253 #endif
    254226                break;
    255227         default:
    256228                ipstat.ips_noproto++;
    257229                m_free(pData, m);
    258 #ifdef VBOX_WITH_SYNC_SLIRP
    259                 if (m != NULL) {
    260                         rc = RTSemMutexRelease(m->m_mutex);
    261                         AssertReleaseRC(rc);
    262                 }
    263 #endif
    264         }
     230        }
     231        if (m != NULL) {
     232                VBOX_SLIRP_UNLOCK(m->m_mutex);
     233        }
    265234        return;
    266235bad:
    267236        m_freem(pData, m);
    268 #ifdef VBOX_WITH_SYNC_SLIRP
    269237        if (m != NULL) {
    270                 rc = RTSemMutexRelease(m->m_mutex);
    271                 AssertReleaseRC(rc);
     238                VBOX_SLIRP_UNLOCK(m->m_mutex);
    272239        }
    273 #endif
    274240        return;
    275241}

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

    r13670 r13710  
    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
     27
     28        VBOX_SLIRP_LOCK_CREATE(&pData->m_usedlist_mutex);
     29        VBOX_SLIRP_LOCK_CREATE(&pData->m_freelist_mutex);
     30        VBOX_SLIRP_LOCK_CREATE(&pData->mbuf_alloced_mutex);
     31
    3232        msize_init(pData);
    3333}
    … …  
    6363        DEBUG_CALL("m_get");
    6464
    65 #ifdef VBOX_WITH_SYNC_SLIRP
    66         RTSemMutexRequest(pData->m_freelist_mutex, RT_INDEFINITE_WAIT);
    67 #endif
     65        VBOX_SLIRP_LOCK(pData->m_freelist_mutex);
     66
    6867        if (m_freelist.m_next == &m_freelist) {
    6968                m = (struct mbuf *)malloc(msize);
    7069                if (m == NULL) {
    71 #ifdef VBOX_WITH_SYNC_SLIRP
    72                     RTSemMutexRelease(pData->m_freelist_mutex);
    73 #endif
     70                    VBOX_SLIRP_UNLOCK(pData->m_freelist_mutex);
    7471                    goto end_error;
    7572                }
    76 #ifdef VBOX_WITH_SYNC_SLIRP
    77                 RTSemMutexCreate(&m->m_mutex);
    78                 RTSemMutexRequest(pData->mbuf_alloced_mutex, RT_INDEFINITE_WAIT);
    79 #endif
     73
     74                VBOX_SLIRP_LOCK_CREATE(&m->m_mutex);
     75                VBOX_SLIRP_LOCK(pData->mbuf_alloced_mutex);
     76
    8077                mbuf_alloced++;
    8178                if (mbuf_alloced > mbuf_thresh)
    … …  
    8380                if (mbuf_alloced > mbuf_max)
    8481                        mbuf_max = mbuf_alloced;
    85 #ifdef VBOX_WITH_SYNC_SLIRP
    86                 RTSemMutexRelease(pData->mbuf_alloced_mutex);
    87 #endif
     82                VBOX_SLIRP_UNLOCK(pData->mbuf_alloced_mutex);
    8883        } else {
    8984                m = m_freelist.m_next;
    9085                remque(pData, m);
    9186        }
    92 #ifdef VBOX_WITH_SYNC_SLIRP
    93         RTSemMutexRequest(m->m_mutex, RT_INDEFINITE_WAIT);
    94         RTSemMutexRelease(pData->m_freelist_mutex);
    95         RTSemMutexRequest(pData->m_usedlist_mutex, RT_INDEFINITE_WAIT);
    96 #endif
    97 
     87
     88        VBOX_SLIRP_LOCK(m->m_mutex);
     89        VBOX_SLIRP_UNLOCK(pData->m_freelist_mutex);
     90
     91        VBOX_SLIRP_LOCK(pData->m_usedlist_mutex);
    9892        /* Insert it in the used list */
    9993        insque(pData, m,&m_usedlist);
    100 #ifdef VBOX_WITH_SYNC_SLIRP
    101         RTSemMutexRelease(pData->m_usedlist_mutex);
    102 #endif
     94        VBOX_SLIRP_UNLOCK(pData->m_usedlist_mutex);
     95
    10396        m->m_flags = (flags | M_USEDLIST);
    10497
    … …  
    109102        m->m_nextpkt = 0;
    110103        m->m_prevpkt = 0;
    111 #ifdef VBOX_WITH_SYNC_SLIRP
    112         RTSemMutexRelease(m->m_mutex);
    113 #endif
     104
     105        VBOX_SLIRP_UNLOCK(m->m_mutex);
    114106end_error:
    115107        DEBUG_ARG("m = %lx", (long )m);
    … …  
    126118  if(m) {
    127119        /* Remove from m_usedlist */
    128 #ifdef VBOX_WITH_SYNC_SLIRP
    129         RTSemMutexRequest(m->m_mutex, RT_INDEFINITE_WAIT);
    130 #endif
     120        VBOX_SLIRP_LOCK(m->m_mutex);
    131121        if (m->m_flags & M_USEDLIST) {
    132 #ifdef VBOX_WITH_SYNC_SLIRP
    133            RTSemMutexRequest(pData->m_usedlist_mutex, RT_INDEFINITE_WAIT);
    134 #endif
     122           VBOX_SLIRP_LOCK(pData->m_usedlist_mutex);
    135123           remque(pData, m);
    136 #ifdef VBOX_WITH_SYNC_SLIRP
    137            RTSemMutexRelease(pData->m_usedlist_mutex);
    138 #endif
     124           VBOX_SLIRP_UNLOCK(pData->m_usedlist_mutex);
    139125        }
    140126
    … …  
    148134        if (m->m_flags & M_DOFREE) {
    149135                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
     136                VBOX_SLIRP_UNLOCK(m->m_mutex);
     137                VBOX_SLIRP_LOCK_DESTROY(m->m_mutex);
    154138                free(m);
    155139#ifdef VBOX_WITH_SYNC_SLIRP
    156140                m = NULL;
    157                 RTSemMutexRequest(pData->mbuf_alloced_mutex, RT_INDEFINITE_WAIT);
     141#endif
     142                VBOX_SLIRP_LOCK(pData->mbuf_alloced_mutex);
    158143                mbuf_alloced--;
    159                 RTSemMutexRelease(pData->mbuf_alloced_mutex);
    160 #else
    161                 mbuf_alloced--;
    162 #endif
     144                VBOX_SLIRP_UNLOCK(pData->mbuf_alloced_mutex);
    163145        } else if ((m->m_flags & M_FREELIST) == 0) {
    164 #ifdef VBOX_WITH_SYNC_SLIRP
    165                 RTSemMutexRequest(pData->m_freelist_mutex, RT_INDEFINITE_WAIT);
    166 #endif
     146                VBOX_SLIRP_LOCK(pData->m_freelist_mutex);
    167147                insque(pData, m,&m_freelist);
    168148                m->m_flags = M_FREELIST; /* Clobber other flags */
    169 #ifdef VBOX_WITH_SYNC_SLIRP
    170                 RTSemMutexRelease(pData->m_freelist_mutex);
    171 #endif
     149                VBOX_SLIRP_UNLOCK(pData->m_freelist_mutex);
    172150        }
    173 #ifdef VBOX_WITH_SYNC_SLIRP
    174         if (m != NULL) RTSemMutexRelease(m->m_mutex);
    175 #endif
     151        if (m != NULL) VBOX_SLIRP_UNLOCK(m->m_mutex);
    176152  } /* if(m) */
    177153}
    … …  
    188164         * If there's no room, realloc
    189165         */
    190 #ifdef VBOX_WITH_SYNC_SLIRP
    191         RTSemMutexRequest(m->m_mutex, RT_INDEFINITE_WAIT);
    192         RTSemMutexRequest(n->m_mutex, RT_INDEFINITE_WAIT);
    193 #endif
     166        VBOX_SLIRP_LOCK(m->m_mutex);
     167        VBOX_SLIRP_LOCK(n->m_mutex);
     168
    194169        if (M_FREEROOM(m) < n->m_len)
    195170                m_inc(m,m->m_size+MINCSIZE);
    … …  
    199174
    200175        m_free(pData, n);
    201 #ifdef VBOX_WITH_SYNC_SLIRP
    202         RTSemMutexRelease(m->m_mutex);
    203         if (n != NULL) RTSemMutexRelease(n->m_mutex);
    204 #endif
     176
     177        VBOX_SLIRP_UNLOCK(m->m_mutex);
     178        if (n != NULL) VBOX_SLIRP_UNLOCK(n->m_mutex);
    205179}
    206180
    … …  
    215189
    216190        /* some compiles throw up on gotos.  This one we can fake. */
    217 #ifdef VBOX_WITH_SYNC_SLIRP
    218         RTSemMutexRequest(m->m_mutex, RT_INDEFINITE_WAIT);
    219 #endif
     191        VBOX_SLIRP_LOCK(m->m_mutex);
    220192        if(m->m_size>size) {
    221 #ifdef VBOX_WITH_SYNC_SLIRP
    222             RTSemMutexRelease(m->m_mutex);
    223 #endif
     193            VBOX_SLIRP_UNLOCK(m->m_mutex);
    224194            return;
    225195        }
    … …  
    247217
    248218        m->m_size = size;
    249 #ifdef VBOX_WITH_SYNC_SLIRP
    250         RTSemMutexRelease(m->m_mutex);
    251 #endif
     219        VBOX_SLIRP_UNLOCK(m->m_mutex);
    252220}
    253221
    … …  
    261229        if (m == NULL)
    262230                return;
    263 #ifdef VBOX_WITH_SYNC_SLIRP
    264         RTSemMutexRequest(m->m_mutex, RT_INDEFINITE_WAIT);
    265 #endif
     231        VBOX_SLIRP_LOCK(m->m_mutex);
    266232        if (len >= 0) {
    267233                /* Trim from head */
    … …  
    273239                m->m_len -= len;
    274240        }
    275 #ifdef VBOX_WITH_SYNC_SLIRP
    276         RTSemMutexRelease(m->m_mutex);
    277 #endif
     241        VBOX_SLIRP_UNLOCK(m->m_mutex);
    278242}
    279243
    … …  
    287251        int off, len;
    288252{
    289 #ifdef VBOX_WITH_SYNC_SLIRP
    290         RTSemMutexRequest(m->m_mutex, RT_INDEFINITE_WAIT);
    291         RTSemMutexRequest(n->m_mutex, RT_INDEFINITE_WAIT);
    292 #endif
     253        VBOX_SLIRP_LOCK(m->m_mutex);
     254        VBOX_SLIRP_LOCK(n->m_mutex);
    293255        if (len > M_FREEROOM(n)) {
    294 #ifdef VBOX_WITH_SYNC_SLIRP
    295                 RTSemMutexRelease(n->m_mutex);
    296                 RTSemMutexRelease(m->m_mutex);
    297 #endif
     256                VBOX_SLIRP_UNLOCK(n->m_mutex);
     257                VBOX_SLIRP_UNLOCK(m->m_mutex);
    298258                return -1;
    299259        }
    … …  
    301261        memcpy((n->m_data + n->m_len), (m->m_data + off), len);
    302262        n->m_len += len;
    303 #ifdef VBOX_WITH_SYNC_SLIRP
    304         RTSemMutexRelease(n->m_mutex);
    305         RTSemMutexRelease(m->m_mutex);
    306 #endif
     263        VBOX_SLIRP_UNLOCK(n->m_mutex);
     264        VBOX_SLIRP_UNLOCK(m->m_mutex);
    307265        return 0;
    308266}
    … …  
    327285#else
    328286        struct mbuf *mnext;
    329         RTSemMutexRequest(pData->m_usedlist_mutex, RT_INDEFINITE_WAIT);
     287        VBOX_SLIRP_LOCK(pData->m_usedlist_mutex);
    330288        m = m_usedlist.m_next;
    331289        while(1) {
    332             RTSemMutexRequest(m->m_mutex, RT_INDEFINITE_WAIT);
     290            VBOX_SLIRP_LOCK(m->m_mutex);
    333291            mnext = m->m_next;
    334             RTSemMutexRelease(pData->m_usedlist_mutex);
     292            VBOX_SLIRP_UNLOCK(pData->m_usedlist_mutex);
    335293#endif
    336294          if (m->m_flags & M_EXT) {
    337295            if( (char *)dat>=m->m_ext && (char *)dat<(m->m_ext + m->m_size) ) {
    338 #ifdef VBOX_WITH_SYNC_SLIRP
    339               RTSemMutexRelease(m->m_mutex);
    340 #endif
     296              VBOX_SLIRP_UNLOCK(m->m_mutex);
    341297              return m;
    342298            }
    343299          } else {
    344300            if( (char *)dat >= m->m_dat && (char *)dat<(m->m_dat + m->m_size) ) {
    345 #ifdef VBOX_WITH_SYNC_SLIRP
    346               RTSemMutexRelease(m->m_mutex);
    347 #endif
     301              VBOX_SLIRP_UNLOCK(m->m_mutex);
    348302              return m;
    349303            }
    350304          }
     305          VBOX_SLIRP_UNLOCK(m->m_mutex);
     306          VBOX_SLIRP_LOCK(pData->m_usedlist_mutex);
    351307#ifdef VBOX_WITH_SYNC_SLIRP
    352           RTSemMutexRelease(m->m_mutex);
    353           RTSemMutexRequest(pData->m_usedlist_mutex, RT_INDEFINITE_WAIT);
    354308          m = mnext;
    355309#endif

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

    r5716 r13710  
    384384#endif
    385385
    386 #endif
     386#ifdef VBOX_WITH_SYNC_SLIRP
     387#define VBOX_SLIRP_LOCK_SUFFIX _mutex
     388
     389#define VBOX_SLIRP_LOCK(x)                                                  \
     390do{                                                                         \
     391    int rc;                                                                 \
     392    rc = RTSemMutexRequest((x), RT_INDEFINITE_WAIT);                        \
     393    AssertReleaseRC(rc);                                                    \
     394}while (0)
     395
     396#define VBOX_SLIRP_UNLOCK(x)                                                \
     397do{                                                                         \
     398    int rc;                                                                 \
     399    rc = RTSemMutexRelease((x));                                            \
     400    AssertReleaseRC(rc);                                                    \
     401}while (0)
     402
     403#define VBOX_SLIRP_LOCK_CREATE(x)                                           \
     404do{                                                                         \
     405    int rc;                                                                 \
     406    rc = RTSemMutexCreate((x));                                             \
     407    AssertReleaseRC(rc);                                                    \
     408}while (0)
     409
     410#define VBOX_SLIRP_LOCK_DESTROY(x)                                          \
     411do{                                                                         \
     412    int rc;                                                                 \
     413    rc = RTSemMutexDestroy((x));                                            \
     414    AssertReleaseRC(rc);                                                    \
     415}while (0)
     416#else
     417#define VBOX_SLIRP_LOCK(x) /* ignore */
     418#define VBOX_SLIRP_UNLOCK(x) /* ignore */
     419#define VBOX_SLIRP_LOCK_DESTROY(x) /* ignore */
     420#define VBOX_SLIRP_LOCK_CREATE(x) /* ignore */
     421#endif
     422
     423#endif

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

    r13704 r13710  
    6464    so->so_state = SS_NOFDREF;
    6565    so->s = -1;
    66 #ifdef VBOX_WITH_SYNC_SLIRP
    67     RTSemMutexCreate(&so->so_mutex);
    68 #endif
     66    VBOX_SLIRP_LOCK_CREATE(&so->so_mutex);
    6967  }
    7068  return(so);
    … …  
    9492    /*Take global mutexes of udb and tcb, because we dont know which is mutex */
    9593    /*XXX: don't forget to set correct so_type in corresponded attach operation */
    96     RTSemMutexRequest(so->so_mutex, RT_INDEFINITE_WAIT);
     94    VBOX_SLIRP_LOCK(so->so_mutex);
    9795    if (so->so_emu==EMU_RSH && so->extra) {
    9896          sofree(pData, so->extra);
    … …  
    10199
    102100    if (so->so_type == IPPROTO_UDP) {
    103         RTSemMutexRequest(pData->udp_last_so_mutex, RT_INDEFINITE_WAIT);
     101        VBOX_SLIRP_LOCK(pData->udp_last_so_mutex);
    104102    }
    105103    else if (so->so_type == IPPROTO_TCP) {
    106         RTSemMutexRequest(pData->tcp_last_so_mutex, RT_INDEFINITE_WAIT);
     104        VBOX_SLIRP_LOCK(pData->tcp_last_so_mutex);
    107105    }
    108106    else {
    … …  
    119117
    120118    if (so->so_type == IPPROTO_UDP) {
    121         RTSemMutexRelease(pData->udp_last_so_mutex);
     119        VBOX_SLIRP_UNLOCK(pData->udp_last_so_mutex);
    122120    }
    123121    else if (so->so_type == IPPROTO_TCP) {
    124         RTSemMutexRelease(pData->tcp_last_so_mutex);
     122        VBOX_SLIRP_UNLOCK(pData->tcp_last_so_mutex);
    125123    }
    126124    else {
    … …  
    128126    }
    129127    /* socket's mutex could be released because socket none accessible via queue anymore*/
    130     RTSemMutexRelease(so->so_mutex);
     128    VBOX_SLIRP_UNLOCK(so->so_mutex);
    131129
    132130    m_free(pData, so->so_m);
    133131
    134132
    135     RTSemMutexDestroy(so->so_mutex);
     133    VBOX_SLIRP_UNLOCK(so->so_mutex);
    136134#endif
    137135
    … …  
    156154        int mss = so->so_tcpcb->t_maxseg;
    157155
    158 #ifdef VBOX_WITH_SYNC_SLIRP
    159         RTSemMutexRequest(so->so_mutex, RT_INDEFINITE_WAIT);
    160 #endif
     156        VBOX_SLIRP_LOCK(so->so_mutex);
    161157        DEBUG_CALL("soread");
    162158        DEBUG_ARG("so = %lx", (long )so);
    … …  
    218214        if (nn <= 0) {
    219215                if (nn < 0 && (errno == EINTR || errno == EAGAIN)) {
    220 #ifdef VBOX_WITH_SYNC_SLIRP
    221                         RTSemMutexRelease(so->so_mutex);
    222 #endif
     216                        VBOX_SLIRP_UNLOCK(so->so_mutex);
    223217                        return 0;
    224218                }
    … …  
    227221                        sofcantrcvmore(so);
    228222                        tcp_sockclosed(pData, sototcpcb(so));
    229 #ifdef VBOX_WITH_SYNC_SLIRP
    230                         RTSemMutexRelease(so->so_mutex);
    231 #endif
     223                        VBOX_SLIRP_UNLOCK(so->so_mutex);
    232224                        return -1;
    233225                }
    … …  
    259251        if (sb->sb_wptr >= (sb->sb_data + sb->sb_datalen))
    260252                sb->sb_wptr -= sb->sb_datalen;
    261 #ifdef VBOX_WITH_SYNC_SLIRP
    262         RTSemMutexRelease(so->so_mutex);
    263 #endif
     253        VBOX_SLIRP_UNLOCK(so->so_mutex);
    264254        return nn;
    265255}
    … …  
    275265sorecvoob(PNATState pData, struct socket *so)
    276266{
    277 #ifdef VBOX_WITH_SYNC_SLIRP
    278         RTSemMutexRequest(so->so_mutex, RT_INDEFINITE_WAIT);
    279 #endif
     267        VBOX_SLIRP_LOCK(so->so_mutex);
    280268        struct tcpcb *tp = sototcpcb(so);
    281269
    … …  
    293281        soread(pData, so);
    294282        tp->snd_up = tp->snd_una + so->so_snd.sb_cc;
     283        VBOX_SLIRP_UNLOCK(so->so_mutex);
    295284        tp->t_force = 1;
    296285        tcp_output(pData, tp);
    297286        tp->t_force = 0;
    298 #ifdef VBOX_WITH_SYNC_SLIRP
    299         RTSemMutexRelease(so->so_mutex);
    300 #endif
    301287}
    302288
    … …  
    314300        int n, len;
    315301#ifdef VBOX_WITH_SYNC_SLIRP
    316         RTSemMutexRequest(so->so_mutex, RT_INDEFINITE_WAIT);
     302        VBOX_SLIRP_LOCK(so->so_mutex);
    317303#endif
    318304
    … …  
    361347
    362348#ifdef VBOX_WITH_SYNC_SLIRP
    363         RTSemMutexRelease(so->so_mutex);
     349        VBOX_SLIRP_UNLOCK(so->so_mutex);
    364350#endif
    365351        return n;
    … …  
    378364        struct iovec iov[2];
    379365#ifdef VBOX_WITH_SYNC_SLIRP
    380         RTSemMutexRequest(so->so_mutex, RT_INDEFINITE_WAIT);
     366        VBOX_SLIRP_LOCK(so->so_mutex);
    381367#endif
    382368
    … …  
    388374                if (sb->sb_cc == 0)
    389375#ifdef VBOX_WITH_SYNC_SLIRP
    390        RTSemMutexRelease(so->so_mutex);
     376       VBOX_SLIRP_UNLOCK(so->so_mutex);
    391377#endif
    392378                        return 0;
    … …  
    432418        if (nn < 0 && (errno == EAGAIN || errno == EINTR)) {
    433419#ifdef VBOX_WITH_SYNC_SLIRP
    434                 RTSemMutexRelease(so->so_mutex);
     420                VBOX_SLIRP_UNLOCK(so->so_mutex);
    435421#endif
    436422                return 0;
    … …  
    443429                tcp_sockclosed(pData, sototcpcb(so));
    444430#ifdef VBOX_WITH_SYNC_SLIRP
    445                 RTSemMutexRelease(so->so_mutex);
     431                VBOX_SLIRP_UNLOCK(so->so_mutex);
    446432#endif
    447433                return -1;
    … …  
    472458
    473459#ifdef VBOX_WITH_SYNC_SLIRP
    474         RTSemMutexRelease(so->so_mutex);
     460        VBOX_SLIRP_UNLOCK(so->so_mutex);
    475461#endif
    476462        return nn;
    … …  
    490476
    491477#ifdef VBOX_WITH_SYNC_SLIRP
    492         RTSemMutexRequest(so->so_mutex, RT_INDEFINITE_WAIT);
     478        VBOX_SLIRP_LOCK(so->so_mutex);
    493479#endif
    494480
    … …  
    579565        } /* if ping packet */
    580566#ifdef VBOX_WITH_SYNC_SLIRP
    581         RTSemMutexRelease(so->so_mutex);
     567        VBOX_SLIRP_UNLOCK(so->so_mutex);
    582568#endif
    583569}
    … …  
    595581#endif
    596582#ifdef VBOX_WITH_SYNC_SLIRP
    597         RTSemMutexRequest(so->so_mutex, RT_INDEFINITE_WAIT);
     583        VBOX_SLIRP_LOCK(so->so_mutex);
    598584#endif
    599585
    … …  
    650636        if (ret < 0) {
    651637#ifdef VBOX_WITH_SYNC_SLIRP
    652                 RTSemMutexRelease(so->so_mutex);
     638                VBOX_SLIRP_UNLOCK(so->so_mutex);
    653639#endif
    654640                return -1;
    … …  
    663649        so->so_state = SS_ISFCONNECTED; /* So that it gets select()ed */
    664650#ifdef VBOX_WITH_SYNC_SLIRP
    665                 RTSemMutexRelease(so->so_mutex);
     651                VBOX_SLIRP_UNLOCK(so->so_mutex);
    666652#endif
    667653        return 0;
    … …  
    698684        insque(pData, so,&tcb);
    699685#else
    700         RTSemMutexRequest(so->so_mutex, RT_INDEFINITE_WAIT);
     686        VBOX_SLIRP_LOCK(so->so_mutex);
    701687        /*after adding to global queue probably we should keep lock*/
    702         RTSemMutexRequest(pData->tcb_mutex, RT_INDEFINITE_WAIT);
     688        VBOX_SLIRP_LOCK(pData->tcb_mutex);
    703689        insque(pData, so,&tcb);
    704         RTSemMutexRelease(pData->tcb_mutex);
     690        VBOX_SLIRP_UNLOCK(pData->tcb_mutex);
    705691#endif
    706692
    … …  
    749735        so->s = s;
    750736#ifdef VBOX_WITH_SYNC_SLIRP
    751         RTSemMutexRelease(so->so_mutex);
     737        VBOX_SLIRP_UNLOCK(so->so_mutex);
    752738#endif
    753739        return so;
    … …  
    790776{
    791777#ifdef VBOX_WITH_SYNC_SLIRP
    792     RTSemMutexRequest(so->so_mutex, RT_INDEFINITE_WAIT);
     778    VBOX_SLIRP_LOCK(so->so_mutex);
    793779#endif
    794780        so->so_state &= ~(SS_NOFDREF|SS_ISFCONNECTED|SS_FCANTRCVMORE|
    … …  
    796782        so->so_state |= SS_ISFCONNECTING; /* Clobber other states */
    797783#ifdef VBOX_WITH_SYNC_SLIRP
    798     RTSemMutexRelease(so->so_mutex);
     784    VBOX_SLIRP_UNLOCK(so->so_mutex);
    799785#endif
    800786}
    … …  
    805791{
    806792#ifdef VBOX_WITH_SYNC_SLIRP
    807     RTSemMutexRequest(so->so_mutex, RT_INDEFINITE_WAIT);
     793    VBOX_SLIRP_LOCK(so->so_mutex);
    808794#endif
    809795        so->so_state &= ~(SS_ISFCONNECTING|SS_FWDRAIN|SS_NOFDREF);
    810796        so->so_state |= SS_ISFCONNECTED; /* Clobber other states */
    811797#ifdef VBOX_WITH_SYNC_SLIRP
    812     RTSemMutexRelease(so->so_mutex);
     798    VBOX_SLIRP_UNLOCK(so->so_mutex);
    813799#endif
    814800}
    … …  
    819805{
    820806#ifdef VBOX_WITH_SYNC_SLIRP
    821     RTSemMutexRequest(so->so_mutex, RT_INDEFINITE_WAIT);
     807    VBOX_SLIRP_LOCK(so->so_mutex);
    822808#endif
    823809        if ((so->so_state & SS_NOFDREF) == 0) {
    … …  
    830816           so->so_state |= SS_FCANTRCVMORE;
    831817#ifdef VBOX_WITH_SYNC_SLIRP
    832     RTSemMutexRelease(so->so_mutex);
     818    VBOX_SLIRP_UNLOCK(so->so_mutex);
    833819#endif
    834820}
    … …  
    839825{
    840826#ifdef VBOX_WITH_SYNC_SLIRP
    841     RTSemMutexRequest(so->so_mutex, RT_INDEFINITE_WAIT);
     827    VBOX_SLIRP_LOCK(so->so_mutex);
    842828#endif
    843829        if ((so->so_state & SS_NOFDREF) == 0) {
    … …  
    850836           so->so_state |= SS_FCANTSENDMORE;
    851837#ifdef VBOX_WITH_SYNC_SLIRP
    852     RTSemMutexRelease(so->so_mutex);
     838    VBOX_SLIRP_UNLOCK(so->so_mutex);
    853839#endif
    854840}
    … …  
    875861{
    876862#ifdef VBOX_WITH_SYNC_SLIRP
    877     RTSemMutexRequest(so->so_mutex, RT_INDEFINITE_WAIT);
     863    VBOX_SLIRP_LOCK(so->so_mutex);
    878864#endif
    879865        if (so->so_rcv.sb_cc)
    … …  
    882868                sofcantsendmore(so);
    883869#ifdef VBOX_WITH_SYNC_SLIRP
    884     RTSemMutexRelease(so->so_mutex);
    885 #endif
    886 }
    887 
     870    VBOX_SLIRP_UNLOCK(so->so_mutex);
     871#endif
     872}
     873

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

    r13704 r13710  
    254254}while(0)
    255255#endif
    256 
    257         int rc;
     256#endif
     257
    258258        if (inso != NULL) {
    259             rc = RTSemMutexRequest(inso->so_mutex, RT_INDEFINITE_WAIT);
    260             AssertReleaseRC(rc);
     259            VBOX_SLIRP_LOCK(inso->so_mutex);
    261260        }
    262 #endif
    263261
    264262        /*
    … …  
    271269                tp = sototcpcb(so);
    272270                m = so->so_m;
    273 #ifdef VBOX_WITH_SYNC_SLIRP
    274                 rc = RTSemMutexRequest(m->m_mutex, RT_INDEFINITE_WAIT);
    275                 AssertReleaseRC(rc);
    276 #endif
     271                VBOX_SLIRP_LOCK(m->m_mutex);
    277272                so->so_m = 0;
    278273                ti = so->so_ti;
    … …  
    282277                goto cont_conn;
    283278        }
    284 #ifdef VBOX_WITH_SYNC_SLIRP
    285         rc = RTSemMutexRequest(m->m_mutex, RT_INDEFINITE_WAIT);
    286         AssertReleaseRC(rc);
    287 #endif
     279        if (inso != NULL) {
     280            VBOX_SLIRP_UNLOCK(inso->so_mutex);
     281        }
     282        VBOX_SLIRP_LOCK(m->m_mutex);
    288283
    289284
    … …  
    379374         */
    380375findso:
    381 #ifdef VBOX_WITH_SYNC_SLIRP
    382         rc = RTSemMutexRequest(pData->tcp_last_so_mutex, RT_INDEFINITE_WAIT);
    383         AssertReleaseRC(rc);
    384 #endif
     376        if (so != NULL) {
     377            VBOX_SLIRP_UNLOCK(so->so_mutex);
     378        }
     379        VBOX_SLIRP_LOCK(pData->tcp_last_so_mutex);
    385380        so = tcp_last_so;
    386 #ifdef VBOX_WITH_SYNC_SLIRP
    387381        /* this checking for making sure that we're not trying to hold mutex on head list*/
    388382        if (tcp_last_so != &tcb) {
    389             rc = RTSemMutexRequest(so->so_mutex, RT_INDEFINITE_WAIT);
    390             AssertReleaseRC(rc);
     383            VBOX_SLIRP_LOCK(so->so_mutex);
    391384        }
    392         rc = RTSemMutexRelease(pData->tcp_last_so_mutex);
    393         AssertReleaseRC(rc);
    394 #endif
     385        VBOX_SLIRP_UNLOCK(pData->tcp_last_so_mutex);
     386
    395387        if (so->so_fport != ti->ti_dport ||
    396388            so->so_lport != ti->ti_sport ||
    397389            so->so_laddr.s_addr != ti->ti_src.s_addr ||
    398390            so->so_faddr.s_addr != ti->ti_dst.s_addr) {
    399 #ifndef VBOX_WITH_SYNC_SLIRP
    400                 so = solookup(&tcb, ti->ti_src, ti->ti_sport,
    401                                ti->ti_dst, ti->ti_dport);
    402                 if (so)
    403                         tcp_last_so = so;
    404 #else
    405391                /*To make sure that we don't try to release mutex on head of the socket queue*/
    406392                if (so != &tcb) {
    407                     rc = RTSemMutexRelease(so->so_mutex);
    408                     AssertReleaseRC(rc);
     393                    VBOX_SLIRP_UNLOCK(so->so_mutex);
    409394                }
    410395                so = solookup(&tcb, ti->ti_src, ti->ti_sport,
    411396                               ti->ti_dst, ti->ti_dport);
    412397                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);
     398                        VBOX_SLIRP_LOCK(so->so_mutex);
     399                        VBOX_SLIRP_LOCK(pData->tcp_last_so_mutex);
    417400                        tcp_last_so = so;
    418                         rc = RTSemMutexRelease(pData->tcp_last_so_mutex);
    419                         AssertReleaseRC(rc);
     401                        VBOX_SLIRP_UNLOCK(pData->tcp_last_so_mutex);
    420402                }
    421 #endif
    422403                ++tcpstat.tcps_socachemiss;
    423404        }
    … …  
    442423          if ((so = socreate()) == NULL)
    443424            goto dropwithreset;
    444 #ifdef VBOX_WITH_SYNC_SLIRP
    445           rc = RTSemMutexRequest(so->so_mutex, RT_INDEFINITE_WAIT);
    446           AssertReleaseRC(rc);
    447 #endif
     425
     426          VBOX_SLIRP_LOCK(so->so_mutex);
    448427          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
     428            VBOX_SLIRP_UNLOCK(so->so_mutex);
     429            VBOX_SLIRP_LOCK_DESTROY(so->so_mutex);
    455430            free(so); /* Not sofree (if it failed, it's not insqued) */
    456431#ifdef VBOX_WITH_SYNC_SLIRP
    … …  
    574549                                tp->snd_una = ti->ti_ack;
    575550                                m_freem(pData, m);
    576 #ifdef VBOX_WITH_SYNC_SLIRP
    577551                                if (m != NULL) {
    578                                     rc = RTSemMutexRelease(m->m_mutex);
    579                                     AssertReleaseRC(rc);
     552                                    VBOX_SLIRP_UNLOCK(m->m_mutex);
    580553                                }
    581 #endif
    582554
    583555                                /*
    … …  
    609581                                if (so->so_snd.sb_cc)
    610582                                        (void) tcp_output(pData, tp);
    611 #ifdef VBOX_WITH_SYNC_SLIRP
    612                                 rc = RTSemMutexRelease(so->so_mutex);
    613                                 AssertReleaseRC(rc);
    614 #endif
     583                                VBOX_SLIRP_UNLOCK(so->so_mutex);
    615584                                return;
    616585                        }
    … …  
    652621                        tp->t_flags |= TF_ACKNOW;
    653622                        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
     623                        VBOX_SLIRP_UNLOCK(so->so_mutex);
     624                        if (m != NULL) {
     625                           VBOX_SLIRP_UNLOCK(m->m_mutex);
     626                        }
    662627                        return;
    663628                }
    … …  
    760725            tp = tcp_close(pData, tp);
    761726            m_free(pData, m);
    762 #ifdef VBOX_WITH_SYNC_SLIRP
    763727            if (m != NULL) {
    764                 rc = RTSemMutexRelease(m->m_mutex);
    765                 AssertReleaseRC(rc);
     728                VBOX_SLIRP_UNLOCK(m->m_mutex);
    766729            }
    767 #endif
    768730          } else {
    769731            /*
    … …  
    778740            tp->t_state = TCPS_SYN_RECEIVED;
    779741          }
    780 #ifdef VBOX_WITH_SYNC_SLIRP
    781           rc = RTSemMutexRelease(so->so_mutex);
    782           AssertReleaseRC(rc);
     742          VBOX_SLIRP_UNLOCK(so->so_mutex);
    783743          if (m != NULL) {
    784             rc = RTSemMutexRelease(m->m_mutex);
    785             AssertReleaseRC(rc);
     744            VBOX_SLIRP_UNLOCK(m->m_mutex);
    786745          }
    787 #endif
    788746          return;
    789747
    … …  
    15431501                (void) tcp_output(pData, tp);
    15441502        }
    1545 #ifdef VBOX_WITH_SYNC_SLIRP
    1546           rc = RTSemMutexRelease(so->so_mutex);
    1547           AssertReleaseRC(rc);
    1548 
     1503
     1504          VBOX_SLIRP_UNLOCK(so->so_mutex);
    15491505          if (m != NULL) {
    1550             rc = RTSemMutexRelease(m->m_mutex);
    1551             AssertReleaseRC(rc);
     1506            VBOX_SLIRP_UNLOCK(m->m_mutex);
    15521507          }
    1553 #endif
    15541508        return;
    15551509
    … …  
    15641518        tp->t_flags |= TF_ACKNOW;
    15651519        (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
     1520        VBOX_SLIRP_UNLOCK(so->so_mutex);
     1521        if (m != NULL) {
     1522          VBOX_SLIRP_UNLOCK(m->m_mutex);
     1523        }
    15741524        return;
    15751525
    … …  
    15841534        }
    15851535
    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
     1536        if (so != NULL) VBOX_SLIRP_UNLOCK(so->so_mutex);
     1537        if (m != NULL) VBOX_SLIRP_UNLOCK(m->m_mutex);
    15941538        return;
    15951539
    … …  
    15991543         */
    16001544        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
     1545        VBOX_SLIRP_UNLOCK(so->so_mutex);
     1546        if (m != NULL) {
     1547          VBOX_SLIRP_UNLOCK(m->m_mutex);
     1548        }
    16091549
    16101550        return;

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

    r13604 r13710  
    5252        DEBUG_CALL("tcp_fasttimo");
    5353
     54        VBOX_SLIRP_LOCK(pData->tcb_mutex);
     55        so = tcb.so_next;
    5456#ifndef VBOX_WITH_SYNC_SLIRP
    55         so = tcb.so_next;
    5657        if (so)
    57         for (; so != &tcb; so = so->so_next)
     58        for (; so != &tcb; so = so->so_next) {
    5859#else
    59         RTSemMutexRequest(pData->tcb_mutex, RT_INDEFINITE_WAIT);
    60         so = tcb.so_next;
    6160        while(1) {
    6261            if ( so == &tcb) {
    63                 RTSemMutexRelease(pData->tcb_mutex);
     62                VBOX_SLIRP_UNLOCK(pData->tcb_mutex);
    6463                break;
    6564            }
    6665            so_next = so->so_next;
    67             RTSemMutexRequest(so->so_mutex, RT_INDEFINITE_WAIT);
    68             RTSemMutexRelease(pData->tcb_mutex);
     66            VBOX_SLIRP_LOCK(so->so_mutex);
     67            VBOX_SLIRP_UNLOCK(pData->tcb_mutex);
    6968#endif
    7069                if ((tp = (struct tcpcb *)so->so_tcpcb) &&
    … …  
    7574                        (void) tcp_output(pData, tp);
    7675                }
     76                VBOX_SLIRP_LOCK(pData->tcb_mutex);
     77                VBOX_SLIRP_UNLOCK(so->so_mutex);
    7778#ifdef VBOX_WITH_SYNC_SLIRP
    78                 RTSemMutexRequest(pData->tcb_mutex, RT_INDEFINITE_WAIT);
    79                 RTSemMutexRelease(so->so_mutex);
    8079                so = so_next;
     80#endif
    8181        }
    82 #endif
    8382
    8483}
    … …  
    101100         * Search through tcb's and update active timers.
    102101         */
     102        VBOX_SLIRP_LOCK(pData->tcb_mutex);
     103        ip = tcb.so_next;
    103104#ifndef VBOX_WITH_SYNC_SLIRP
    104         ip = tcb.so_next;
    105105        if (ip == 0)
    106106           return;
    107107        for (; ip != &tcb; ip = ipnxt) {
    108108#else
    109         RTSemMutexRequest(pData->tcb_mutex, RT_INDEFINITE_WAIT);
    110         ip = tcb.so_next;
    111109        if (ip == NULL) {
    112             RTSemMutexRelease(pData->tcb_mutex);
     110            VBOX_SLIRP_UNLOCK(pData->tcb_mutex);
    113111            return;
    114112        }
    115113        while (1) {
    116114                if (ip == &tcb) {
    117                     RTSemMutexRelease(pData->tcb_mutex);
     115                    VBOX_SLIRP_UNLOCK(pData->tcb_mutex);
    118116                    break;
    119117                }
    120118                ipnxt = ip->so_next;
    121                 RTSemMutexRequest(ip->so_mutex, RT_INDEFINITE_WAIT);
    122                 RTSemMutexRelease(pData->tcb_mutex);
     119                VBOX_SLIRP_LOCK(ip->so_mutex);
     120                VBOX_SLIRP_UNLOCK(pData->tcb_mutex);
    123121#endif
    124122                ipnxt = ip->so_next;
    125123                tp = sototcpcb(ip);
    126124                if (tp == 0)
    127 #ifndef VBOX_WITH_SYNC_SLIRP
    128                         continue;
    129 #else
    130                         goto before_loop_ends;
    131 #endif
     125                        goto before_loop_ends; /*vvl:the same as continue in original code*/
    132126                for (i = 0; i < TCPT_NTIMERS; i++) {
    133127                        if (tp->t_timer[i] && --tp->t_timer[i] == 0) {
    … …  
    142136tpgone:
    143137                ;
     138before_loop_ends:
     139                VBOX_SLIRP_LOCK(pData->tcb_mutex);
     140                VBOX_SLIRP_UNLOCK(ip->so_mutex);
    144141#ifdef VBOX_WITH_SYNC_SLIRP
    145 before_loop_ends:
    146                 RTSemMutexRequest(pData->tcb_mutex, RT_INDEFINITE_WAIT);
    147                 RTSemMutexRelease(ip->so_mutex);
    148142                ip=ipnxt;
    149143#endif

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

    r13704 r13710  
    7777        DEBUG_ARG("m = %lx", (long)m);
    7878        DEBUG_ARG("iphlen = %d", iphlen);
    79 #ifdef VBOX_WITH_SYNC_SLIRP
    80         int rc;
    81         rc = RTSemMutexRequest(m->m_mutex, RT_INDEFINITE_WAIT);
    82         AssertReleaseRC(rc);
    83 #endif
     79
     80        VBOX_SLIRP_LOCK(m->m_mutex);
    8481
    8582        udpstat.udps_ipackets++;
    … …  
    161158         * Locate pcb for datagram.
    162159         */
    163 #ifndef VBOX_WITH_SYNC_SLIRP
    164         so = udp_last_so;
     160        VBOX_SLIRP_LOCK(pData->udp_last_so_mutex);
     161        so = udp_last_so;
     162        if (so != &udb) {
     163            VBOX_SLIRP_LOCK(so->so_mutex);
     164        }
     165
     166        VBOX_SLIRP_UNLOCK(pData->udp_last_so_mutex);
     167
    165168        if (so->so_lport != uh->uh_sport ||
    166169            so->so_laddr.s_addr != ip->ip_src.s_addr) {
    167170                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                }
     175#ifndef VBOX_WITH_SYNC_SLIRP
    168176                for (tmp = udb.so_next; tmp != &udb; tmp = tmp->so_next) {
    169177#else
    170         rc = RTSemMutexRequest(pData->udp_last_so_mutex, RT_INDEFINITE_WAIT);
    171         AssertReleaseRC(rc);
    172 
    173         so = udp_last_so;
    174         if (so != &udb) {
    175             rc = RTSemMutexRequest(so->so_mutex, RT_INDEFINITE_WAIT);
    176             AssertReleaseRC(rc);
    177         }
    178 
    179         rc = RTSemMutexRelease(pData->udp_last_so_mutex);
    180         AssertReleaseRC(rc);
    181 
    182         if (so->so_lport != uh->uh_sport ||
    183             so->so_laddr.s_addr != ip->ip_src.s_addr) {
    184                 struct socket *tmp;
     178
    185179                struct socket *tmp_next;
    186             if (so != &udb) {
    187                 /*we don't interesting in this socket any more*/
    188                 rc = RTSemMutexRelease(so->so_mutex);
    189                 AssertReleaseRC(rc);
    190             }
    191             rc = RTSemMutexRequest(pData->udb_mutex, RT_INDEFINITE_WAIT);
    192             AssertReleaseRC(rc);
    193             tmp = udb.so_next;
    194 
    195             while (1) {
    196                 if (tmp == &udb) {
    197                     rc = RTSemMutexRelease(pData->udb_mutex);
    198                     AssertReleaseRC(rc);
    199                     break;
    200                 }
    201                 tmp_next = tmp->so_next;
    202                 rc = RTSemMutexRequest(tmp->so_mutex, RT_INDEFINITE_WAIT);
    203                 AssertReleaseRC(rc);
    204                 rc = RTSemMutexRelease(pData->udb_mutex);
    205                 AssertReleaseRC(rc);
     180                VBOX_SLIRP_LOCK(pData->udb_mutex);
     181                tmp = udb.so_next;
     182
     183                while (1) {
     184                    if (tmp == &udb) {
     185                        VBOX_SLIRP_UNLOCK(pData->udb_mutex);
     186                        break; /* end of loop*/
     187                    }
     188                    VBOX_SLIRP_LOCK(tmp->so_mutex);
     189                    VBOX_SLIRP_UNLOCK(pData->udb_mutex);
     190                    tmp_next = tmp->so_next;
    206191#endif
    207192                        if (tmp->so_lport == uh->uh_sport &&
    … …  
    210195                                break;
    211196                        }
     197                        VBOX_SLIRP_UNLOCK(tmp->so_mutex);
     198                        VBOX_SLIRP_LOCK(pData->udb_mutex);
    212199#ifdef VBOX_WITH_SYNC_SLIRP
    213                         rc = RTSemMutexRelease(tmp->so_mutex);
    214                         AssertReleaseRC(rc);
    215                         rc = RTSemMutexRequest(pData->udb_mutex, RT_INDEFINITE_WAIT);
    216                         AssertReleaseRC(rc);
    217200                        tmp = tmp_next;
    218201#endif
    … …  
    221204                  so = NULL;
    222205                } else {
    223 #ifdef VBOX_WITH_SYNC_SLIRP
    224                   rc = RTSemMutexRequest(pData->udp_last_so_mutex, RT_INDEFINITE_WAIT);
    225                   AssertReleaseRC(rc);
    226 #endif
    227206                  udpstat.udpps_pcbcachemiss++;
     207                  VBOX_SLIRP_LOCK(pData->udp_last_so_mutex);
    228208                  udp_last_so = so;
    229 #ifdef VBOX_WITH_SYNC_SLIRP
    230                   rc = RTSemMutexRelease(pData->udp_last_so_mutex);
    231                   AssertReleaseRC(rc);
    232 #endif
     209                  VBOX_SLIRP_UNLOCK(pData->udp_last_so_mutex);
    233210                }
    234211        }
    … …  
    244221           */
    245222          if ((so = socreate()) == NULL) goto bad;
    246 #ifdef VBOX_WITH_SYNC_SLIRP
    247           rc = RTSemMutexRequest(so->so_mutex, RT_INDEFINITE_WAIT);
    248           AssertReleaseRC(rc);
    249 #endif
     223          VBOX_SLIRP_LOCK(so->so_mutex);
    250224          if(udp_attach(pData, so) == -1) {
    251225            DEBUG_MISC((dfd," udp_attach errno = %d-%s\n",
    … …  
    300274        so->so_m=m;         /* ICMP backup */
    301275
    302 #ifdef VBOX_WITH_SYNC_SLIRP
    303         rc = RTSemMutexRelease(so->so_mutex);
    304         AssertReleaseRC(rc);
    305         rc = RTSemMutexRelease(m->m_mutex);
    306         AssertReleaseRC(rc);
    307 #endif
     276        VBOX_SLIRP_UNLOCK(so->so_mutex);
     277        VBOX_SLIRP_UNLOCK(m->m_mutex);
    308278        return;
    309279bad:
    310280        m_freem(pData, m);
    311281        /* if (opts) m_freem(opts); */
    312 #ifdef VBOX_WITH_SYNC_SLIRP
    313282        if (m != NULL) {
    314             rc = RTSemMutexRelease(m->m_mutex);
    315             AssertReleaseRC(rc);
     283            VBOX_SLIRP_UNLOCK(m->m_mutex);
    316284        }
    317 #endif
    318285        return;
    319286}
    … …  
    325292        register struct udpiphdr *ui;
    326293        int error = 0;
    327 #ifdef VBOX_WITH_SYNC_SLIRP
    328         int rc;
    329294        if(so != NULL) {
    330             rc = RTSemMutexRequest(so->so_mutex, RT_INDEFINITE_WAIT);
    331             AssertReleaseRC(rc);
     295            VBOX_SLIRP_LOCK(so->so_mutex);
    332296        }
    333         rc = RTSemMutexRequest(m->m_mutex, RT_INDEFINITE_WAIT);
    334         AssertReleaseRC(rc);
    335 #endif
     297        VBOX_SLIRP_LOCK(m->m_mutex);
    336298
    337299        DEBUG_CALL("udp_output");
    … …  
    379341
    380342        error = ip_output(pData, so, m);
    381 #ifdef VBOX_WITH_SYNC_SLIRP
    382         if (so != NULL) rc = RTSemMutexRelease(so->so_mutex);
    383         rc = RTSemMutexRelease(m->m_mutex);
    384 #endif
     343        if (so != NULL) VBOX_SLIRP_UNLOCK(so->so_mutex);
     344        VBOX_SLIRP_UNLOCK(m->m_mutex);
    385345        return (error);
    386346}
    … …  
    390350{
    391351    struct sockaddr_in saddr, daddr;
    392 #ifdef VBOX_WITH_SYNC_SLIRP
    393352    int status;
    394     int rc;
    395     rc = RTSemMutexRequest(so->so_mutex, RT_INDEFINITE_WAIT);
    396     AssertReleaseRC(rc);
    397 #endif
     353    VBOX_SLIRP_LOCK(so->so_mutex);
    398354
    399355    saddr = *addr;
    … …  
    412368    daddr.sin_port = so->so_lport;
    413369
    414 #ifdef VBOX_WITH_SYNC_SLIRP
    415370    status = udp_output2(pData, so, m, &saddr, &daddr, so->so_iptos);
    416     rc = RTSemMutexRelease(so->so_mutex);
    417     AssertReleaseRC(rc);
     371    VBOX_SLIRP_UNLOCK(so->so_mutex);
    418372    return status;
    419 #else
    420     return udp_output2(pData, so, m, &saddr, &daddr, so->so_iptos);
    421 #endif
    422373}
    423374
    … …  
    426377{
    427378  struct sockaddr_in addr;
    428 #ifdef VBOX_WITH_SYNC_SLIRP
    429     int rc;
    430     rc = RTSemMutexRequest(so->so_mutex, RT_INDEFINITE_WAIT);
    431     AssertReleaseRC(rc);
    432 #endif
     379    VBOX_SLIRP_LOCK(so->so_mutex);
    433380
    434381  if((so->s = socket(AF_INET,SOCK_DGRAM,0)) != -1) {
    … …  
    445392      closesocket(so->s);
    446393      so->s=-1;
    447 #ifdef VBOX_WITH_SYNC_SLIRP
    448      AssertRelease(so->s != -1);
    449 #endif
    450394#ifdef _WIN32
    451395      WSASetLastError(lasterrno);
    … …  
    459403      /* enable broadcast for later use */
    460404      setsockopt(so->s, SOL_SOCKET, SO_BROADCAST, (const char *)&opt, sizeof(opt));
    461 #ifdef VBOX_WITH_SYNC_SLIRP
    462      rc = RTSemMutexRequest(pData->udb_mutex, RT_INDEFINITE_WAIT);
    463      AssertReleaseRC(rc);
    464 #endif
     405      VBOX_SLIRP_LOCK(pData->udb_mutex);
    465406      insque(pData, so,&udb);
    466 #ifdef VBOX_WITH_SYNC_SLIRP
    467      rc = RTSemMutexRelease(pData->udb_mutex);
    468      AssertReleaseRC(rc);
    469 #endif
     407      VBOX_SLIRP_UNLOCK(pData->udb_mutex);
    470408    }
    471409  }
    472410#ifdef VBOX_WITH_SYNC_SLIRP
    473411  so->so_type = IPPROTO_UDP;
    474   rc = RTSemMutexRelease(so->so_mutex);
    475   AssertReleaseRC(rc);
    476 #endif
     412#endif
     413  VBOX_SLIRP_UNLOCK(so->so_mutex);
    477414  return(so->s);
    478415}
    … …  
    482419{
    483420        /* Correctly update list if detaching last socket in list. */
    484 #ifdef VBOX_WITH_SYNC_SLIRP
    485         int rc;
    486         rc = RTSemMutexRequest(so->so_mutex, RT_INDEFINITE_WAIT);
    487         AssertReleaseRC(rc);
    488         rc = RTSemMutexRequest(pData->udp_last_so_mutex, RT_INDEFINITE_WAIT);
    489         AssertReleaseRC(rc);
    490 #endif
     421        VBOX_SLIRP_LOCK(so->so_mutex);
     422        VBOX_SLIRP_LOCK(pData->udp_last_so_mutex);
    491423        if (so == udp_last_so) udp_last_so = &udb;
    492 #ifdef VBOX_WITH_SYNC_SLIRP
    493         rc = RTSemMutexRelease(pData->udp_last_so_mutex);
    494         AssertReleaseRC(rc);
    495 #endif
     424        VBOX_SLIRP_UNLOCK(pData->udp_last_so_mutex);
    496425        closesocket(so->s);
    497426        /* if (so->so_m) m_free(so->so_m);    done by sofree */
    498427
    499428        sofree(pData, so);
    500 #ifdef VBOX_WITH_SYNC_SLIRP
     429
    501430        if (so != NULL) {
    502             rc = RTSemMutexRelease(so->so_mutex);
    503             AssertReleaseRC(rc);
     431            VBOX_SLIRP_UNLOCK(so->so_mutex);
    504432        }
    505 #endif
    506433}
    507434
    … …  
    519446{
    520447        int i = 0;
    521 #ifdef VBOX_WITH_SYNC_SLIRP
    522         int rc;
    523 #endif
    524448
    525449        while(udptos[i].tos) {
    526450                if ((udptos[i].fport && ntohs(so->so_fport) == udptos[i].fport) ||
    527451                    (udptos[i].lport && ntohs(so->so_lport) == udptos[i].lport)) {
    528 #ifdef VBOX_WITH_SYNC_SLIRP
    529                         rc = RTSemMutexRequest(so->so_mutex, RT_INDEFINITE_WAIT);
    530                         AssertReleaseRC(rc);
    531 #endif
     452                        VBOX_SLIRP_LOCK(so->so_mutex);
    532453                        so->so_emu = udptos[i].emu;
    533 #ifdef VBOX_WITH_SYNC_SLIRP
    534                         rc = RTSemMutexRelease(so->so_mutex);
    535                         AssertReleaseRC(rc);
    536 #endif
     454                        VBOX_SLIRP_UNLOCK(so->so_mutex);
    537455                        return udptos[i].tos;
    538456                }
    … …  
    555473        struct sockaddr_in addr;
    556474        socklen_t addrlen = sizeof(addr);
    557 #ifdef VBOX_WITH_SYNC_SLIRP
    558         int rc;
    559 #endif
    560475#ifdef EMULATE_TALK
    561476        CTL_MSG_OLD *omsg;
    … …  
    587502} *cu_head;
    588503
     504        VBOX_SLIRP_LOCK(so->so_mutex);
    589505#ifdef VBOX_WITH_SYNC_SLIRP
    590         rc = RTSemMutexRequest(so->so_mutex, RT_INDEFINITE_WAIT);
    591         AssertReleaseRC(rc);
    592506#define return \
    593507                do {                                        \
    594                     int rc;                                 \
    595                     rc = RTSemMutexRelease(so->so_mutex);   \
    596                     AssertReleaseRC(rc);                    \
     508                    VBOX_SLIRP_UNLOCK(so->so_mutex);        \
    597509                    return;                                 \
    598510                }while(0)
    … …  
    789701                return;
    790702        }
     703/*see macro definition in the begining of method*/
    791704#ifdef VBOX_WITH_SYNC_SLIRP
    792705    return;
    … …  
    802715        socklen_t addrlen = sizeof(struct sockaddr_in);
    803716        int opt = 1;
    804 #ifdef VBOX_WITH_SYNC_SLIRP
    805         int rc;
    806 #endif
    807717
    808718        if ((so = socreate()) == NULL) {
    … …  
    812722        so->s = socket(AF_INET,SOCK_DGRAM,0);
    813723        so->so_expire = curtime + SO_EXPIRE;
    814 #ifdef VBOX_WITH_SYNC_SLIRP
    815         rc = RTSemMutexRequest(so->so_mutex, RT_INDEFINITE_WAIT);
    816         AssertReleaseRC(rc);
    817         rc = RTSemMutexRequest(pData->udb_mutex, RT_INDEFINITE_WAIT);
    818         AssertReleaseRC(rc);
    819 #endif
     724        VBOX_SLIRP_LOCK(so->so_mutex);
     725        VBOX_SLIRP_LOCK(pData->udb_mutex);
    820726        insque(pData, so,&udb);
    821 #ifdef VBOX_WITH_SYNC_SLIRP
    822         rc = RTSemMutexRelease(pData->udb_mutex);
    823         AssertReleaseRC(rc);
    824 #endif
     727        VBOX_SLIRP_UNLOCK(pData->udb_mutex);
    825728
    826729        addr.sin_family = AF_INET;
    … …  
    830733        if (bind(so->s,(struct sockaddr *)&addr, addrlen) < 0) {
    831734                udp_detach(pData, so);
    832 #ifdef VBOX_WITH_SYNC_SLIRP
    833                 rc = RTSemMutexRelease(so->so_mutex);
    834                 AssertReleaseRC(rc);
    835 #endif
     735                VBOX_SLIRP_UNLOCK(so->so_mutex);
    836736                return NULL;
    837737        }
    … …  
    855755
    856756        so->so_state = SS_ISFCONNECTED;
    857 #ifdef VBOX_WITH_SYNC_SLIRP
    858         rc = RTSemMutexRelease(so->so_mutex);
    859         AssertReleaseRC(rc);
    860 #endif
     757        VBOX_SLIRP_UNLOCK(so->so_mutex);
    861758
    862759        return so;
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