VirtualBox

Changeset 20377 in vbox for trunk/src


Ignore:
Timestamp:
Jun 8, 2009 4:49:01 AM (16 years ago)
Author:
vboxsync
Message:

NAT: sbuf perfomance counters

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

Legend:

Unmodified
Added
Removed
  • trunk/src/VBox/Devices/Network/slirp/sbuf.c

    r17191 r20377  
    3939
    4040void
    41 sbreserve(struct sbuf *sb, int size)
     41sbreserve(PNATState pData, struct sbuf *sb, int size)
    4242{
    4343    if (sb->sb_data)
     
    8383    DEBUG_ARG("m->m_len = %d", m->m_len);
    8484
     85    SLIRP_COUNTER_RESET(IOSBAppend);
     86    SLIRP_COUNTER_RESET(IOSBAppend_zm);
     87    SLIRP_COUNTER_RESET(IOSBAppend_wa);
     88    SLIRP_COUNTER_RESET(IOSBAppend_wf);
     89    SLIRP_COUNTER_RESET(IOSBAppend_wp);
     90
     91    SLIRP_COUNTER_INC(IOSBAppend);
    8592    /* Shouldn't happen, but...  e.g. foreign host closes connection */
    8693    if (m->m_len <= 0)
    8794    {
    88         m_free(pData, m);
    89         return;
     95        SLIRP_COUNTER_INC(IOSBAppend_zm);
     96        goto done;
    9097    }
    9198
     
    97104    if (so->so_urgc)
    98105    {
    99         sbappendsb(&so->so_rcv, m);
     106        sbappendsb(pData, &so->so_rcv, m);
    100107        m_free(pData, m);
    101108        sosendoob(so);
     
    112119    if (ret <= 0)
    113120    {
     121        SLIRP_COUNTER_INC(IOSBAppend_wf);
    114122        /*
    115123         * Nothing was written
     
    118126         * it will be detected in the normal way by soread()
    119127         */
    120         sbappendsb(&so->so_rcv, m);
     128        sbappendsb(pData, &so->so_rcv, m);
     129        goto done;
    121130    }
    122131    else if (ret != m->m_len)
    123132    {
     133        SLIRP_COUNTER_INC(IOSBAppend_wp);
    124134        /*
    125135         * Something was written, but not everything..
     
    128138        m->m_len -= ret;
    129139        m->m_data += ret;
    130         sbappendsb(&so->so_rcv, m);
     140        sbappendsb(pData, &so->so_rcv, m);
     141        goto done;
    131142    } /* else */
    132143    /* Whatever happened, we free the mbuf */
     144    SLIRP_COUNTER_INC(IOSBAppend_wa);
     145done:
    133146    m_free(pData, m);
    134147}
     
    139152 */
    140153void
    141 sbappendsb(struct sbuf *sb, struct mbuf *m)
     154sbappendsb(PNATState pData, struct sbuf *sb, struct mbuf *m)
    142155{
    143156    int len, n,  nn;
     
    145158    len = m->m_len;
    146159
     160    SLIRP_COUNTER_RESET(IOSBAppendSB);
     161    SLIRP_COUNTER_RESET(IOSBAppendSB_w_l_r);
     162    SLIRP_COUNTER_RESET(IOSBAppendSB_w_ge_r);
     163    SLIRP_COUNTER_RESET(IOSBAppendSB_w_alter);
     164
     165    SLIRP_COUNTER_INC(IOSBAppendSB);
    147166    if (sb->sb_wptr < sb->sb_rptr)
    148167    {
     168        SLIRP_COUNTER_INC(IOSBAppendSB_w_l_r);
    149169        n = sb->sb_rptr - sb->sb_wptr;
    150170        if (n > len)
     
    154174    else
    155175    {
     176        SLIRP_COUNTER_INC(IOSBAppendSB_w_ge_r);
    156177        /* Do the right edge first */
    157178        n = sb->sb_data + sb->sb_datalen - sb->sb_wptr;
     
    174195    sb->sb_wptr += n;
    175196    if (sb->sb_wptr >= sb->sb_data + sb->sb_datalen)
     197    {
     198        SLIRP_COUNTER_INC(IOSBAppendSB_w_alter);
    176199        sb->sb_wptr -= sb->sb_datalen;
     200    }
    177201}
    178202
  • trunk/src/VBox/Devices/Network/slirp/sbuf.h

    r20306 r20377  
    2525void sbfree (struct sbuf *);
    2626void sbdrop (struct sbuf *, int);
    27 void sbreserve (struct sbuf *, int);
     27void sbreserve (PNATState, struct sbuf *, int);
    2828void sbappend (PNATState, struct socket *, struct mbuf *);
    29 void sbappendsb (struct sbuf *, struct mbuf *);
     29void sbappendsb (PNATState, struct sbuf *, struct mbuf *);
    3030void sbcopy (struct sbuf *, int, int, char *);
    3131
  • trunk/src/VBox/Devices/Network/slirp/tcp_input.c

    r19899 r20377  
    346346    {
    347347        tcpstat.tcps_rcvbadsum++;
    348         Log2(("checksum is invalid => drop\n"));
    349348        goto drop;
    350349    }
     
    359358    {
    360359        tcpstat.tcps_rcvbadoff++;
    361         Log2(("ti_off(tlen(%d)<%d<(tcphdr(%d))) is invalid =>drop\n", tlen, off, sizeof(struct tcphdr)));
    362360        goto drop;
    363361    }
     
    435433                && so->so_deleted != 1)
    436434            {
    437                 Log2(("lock: %s:%d We found socket %R[natsock]\n", __FUNCTION__, __LINE__, so));
    438435                break; /* so is locked here */
    439436            }
     
    441438        }
    442439        if (so == &tcb) {
    443             Log2(("lock: %s:%d Haven't find anything \n", __FUNCTION__, __LINE__));
    444440            so = NULL;
    445441        }
     
    470466     * as if it was LISTENING, and continue...
    471467     */
    472     Log2(("so = %R[natsock]\n", so));
    473468    if (so == 0)
    474469    {
     
    484479        }
    485480        SOCKET_LOCK(so);
    486         sbreserve(&so->so_snd, tcp_sndspace);
    487         sbreserve(&so->so_rcv, tcp_rcvspace);
     481        sbreserve(pData, &so->so_snd, tcp_sndspace);
     482        sbreserve(pData, &so->so_rcv, tcp_rcvspace);
    488483
    489484/*      tcp_last_so = so; */  /* XXX ? */
     
    509504    if (so->so_state & SS_ISFCONNECTING)
    510505    {
    511         Log2(("so_state(%x) of %R[natsock] is still connecting =>drop\n", so->so_state, so));
    512506        goto drop;
    513507    }
     
    520514    if (tp->t_state == TCPS_CLOSED)
    521515    {
    522         Log2(("t_state(%x) is closed =>drop\n", tp->t_state));
    523516        goto drop;
    524517    }
     
    724717        {
    725718            if (tiflags & TH_RST) {
    726                 Log2(("RST(%x) is on listen =>drop\n", tiflags));
    727719                goto drop;
    728720            }
     
    731723            if ((tiflags & TH_SYN) == 0)
    732724            {
    733                 Log2(("SYN(%x) is off on listen =>drop\n", tiflags));
    734725                goto drop;
    735726            }
     
    819810            tp->t_timer[TCPT_KEEP] = TCPTV_KEEP_INIT;
    820811            tcpstat.tcps_accepts++;
    821             Log2(("hit trimthenstep6\n"));
    822812            goto trimthenstep6;
    823813        } /* case TCPS_LISTEN */
     
    845835                if (tiflags & TH_ACK)
    846836                    tp = tcp_drop(pData, tp, 0); /* XXX Check t_softerror! */
    847                 Log2(("RST(%x) is on SYN_SENT =>drop\n", tiflags));
    848837                goto drop;
    849838            }
     
    851840            if ((tiflags & TH_SYN) == 0)
    852841            {
    853                 Log2(("SYN(%x) bit is off on SYN_SENT =>drop\n", tiflags));
    854842                goto drop;
    855843            }
     
    11031091/*              so->so_error = ECONNRESET; */
    11041092close:
    1105                 Log2(("closing...=>drop\n", tp->t_state));
    11061093                tp->t_state = TCPS_CLOSED;
    11071094                tcpstat.tcps_drops++;
     
    11121099            case TCPS_LAST_ACK:
    11131100            case TCPS_TIME_WAIT:
    1114                 Log2(("t_state is (%x) sort of close =>drop\n", tp->t_state));
    11151101                tp = tcp_close(pData, tp);
    11161102                goto drop;
     
    11321118    if ((tiflags & TH_ACK) == 0)
    11331119    {
    1134         Log2(("ACK(%x) bit is off =>drop\n", tiflags));
    11351120        goto drop;
    11361121    }
     
    11741159            tp->snd_wl1 = ti->ti_seq - 1;
    11751160            /* Avoid ack processing; snd_una==ti_ack  =>  dup ack */
    1176             Log2(("hit synrx_to_est\n"));
    11771161            goto synrx_to_est;
    11781162            /* fall into ... */
     
    12431227                        if (SEQ_GT(onxt, tp->snd_nxt))
    12441228                            tp->snd_nxt = onxt;
    1245                         Log2(("t_dupacks(%d) == tcprexmtthresh(%d)=>drop\n", tp->t_dupacks, tcprexmtthresh));
    12461229                        goto drop;
    12471230                    }
     
    12501233                        tp->snd_cwnd += tp->t_maxseg;
    12511234                        (void) tcp_output(pData, tp);
    1252                         Log2(("t_dupacks(%d) > tcprexmtthresh(%d)=>drop\n", tp->t_dupacks, tcprexmtthresh));
    12531235                        goto drop;
    12541236                    }
     
    12591241            }
    12601242synrx_to_est:
    1261             Log2(("enter synrx_to_est\n"));
    12621243            /*
    12631244             * If the congestion window was inflated to account
     
    13971378                    if (ourfinisacked)
    13981379                    {
    1399                         Log2(("ourfinisacked=>drop\n"));
    14001380                        tp = tcp_close(pData, tp);
    14011381                        goto drop;
     
    14881468            tp->rcv_up = tp->rcv_nxt;
    14891469dodata:
    1490     Log2(("do data hit!\n"));
    14911470
    14921471    /*
     
    18981877    tp->snd_cwnd = mss;
    18991878
    1900     sbreserve(&so->so_snd, tcp_sndspace+((tcp_sndspace%mss)?(mss-(tcp_sndspace%mss)):0));
    1901     sbreserve(&so->so_rcv, tcp_rcvspace+((tcp_rcvspace%mss)?(mss-(tcp_rcvspace%mss)):0));
     1879    sbreserve(pData, &so->so_snd, tcp_sndspace+((tcp_sndspace%mss)?(mss-(tcp_sndspace%mss)):0));
     1880    sbreserve(pData, &so->so_rcv, tcp_rcvspace+((tcp_rcvspace%mss)?(mss-(tcp_rcvspace%mss)):0));
    19021881
    19031882    DEBUG_MISC((dfd, " returning mss = %d\n", mss));
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