1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21 
  22 /*
  23  * Copyright (c) 2010, Oracle and/or its affiliates. All rights reserved.
  24  */
  25 
  26 #include <sys/types.h>
  27 #include <sys/tihdr.h>
  28 #include <sys/policy.h>
  29 #include <sys/tsol/tnet.h>
  30 
  31 #include <inet/common.h>
  32 #include <inet/ip.h>
  33 #include <inet/tcp.h>
  34 #include <inet/tcp_impl.h>
  35 #include <inet/tcp_stats.h>
  36 #include <inet/kstatcom.h>
  37 #include <inet/snmpcom.h>
  38 
  39 static int      tcp_snmp_state(tcp_t *);
  40 static int      tcp_kstat_update(kstat_t *, int);
  41 static int      tcp_kstat2_update(kstat_t *, int);
  42 static void     tcp_sum_mib(tcp_stack_t *, mib2_tcp_t *);
  43 
  44 static void     tcp_add_mib(mib2_tcp_t *, mib2_tcp_t *);
  45 static void     tcp_add_stats(tcp_stat_counter_t *, tcp_stat_t *);
  46 static void     tcp_clr_stats(tcp_stat_t *);
  47 
  48 tcp_g_stat_t    tcp_g_statistics;
  49 kstat_t         *tcp_g_kstat;
  50 
  51 /* Translate TCP state to MIB2 TCP state. */
  52 static int
  53 tcp_snmp_state(tcp_t *tcp)
  54 {
  55         if (tcp == NULL)
  56                 return (0);
  57 
  58         switch (tcp->tcp_state) {
  59         case TCPS_CLOSED:
  60         case TCPS_IDLE: /* RFC1213 doesn't have analogue for IDLE & BOUND */
  61         case TCPS_BOUND:
  62                 return (MIB2_TCP_closed);
  63         case TCPS_LISTEN:
  64                 return (MIB2_TCP_listen);
  65         case TCPS_SYN_SENT:
  66                 return (MIB2_TCP_synSent);
  67         case TCPS_SYN_RCVD:
  68                 return (MIB2_TCP_synReceived);
  69         case TCPS_ESTABLISHED:
  70                 return (MIB2_TCP_established);
  71         case TCPS_CLOSE_WAIT:
  72                 return (MIB2_TCP_closeWait);
  73         case TCPS_FIN_WAIT_1:
  74                 return (MIB2_TCP_finWait1);
  75         case TCPS_CLOSING:
  76                 return (MIB2_TCP_closing);
  77         case TCPS_LAST_ACK:
  78                 return (MIB2_TCP_lastAck);
  79         case TCPS_FIN_WAIT_2:
  80                 return (MIB2_TCP_finWait2);
  81         case TCPS_TIME_WAIT:
  82                 return (MIB2_TCP_timeWait);
  83         default:
  84                 return (0);
  85         }
  86 }
  87 
  88 /*
  89  * Return SNMP stuff in buffer in mpdata.
  90  */
  91 mblk_t *
  92 tcp_snmp_get(queue_t *q, mblk_t *mpctl, boolean_t legacy_req)
  93 {
  94         mblk_t                  *mpdata;
  95         mblk_t                  *mp_conn_ctl = NULL;
  96         mblk_t                  *mp_conn_tail;
  97         mblk_t                  *mp_attr_ctl = NULL;
  98         mblk_t                  *mp_attr_tail;
  99         mblk_t                  *mp6_conn_ctl = NULL;
 100         mblk_t                  *mp6_conn_tail;
 101         mblk_t                  *mp6_attr_ctl = NULL;
 102         mblk_t                  *mp6_attr_tail;
 103         struct opthdr           *optp;
 104         mib2_tcpConnEntry_t     tce;
 105         mib2_tcp6ConnEntry_t    tce6;
 106         mib2_transportMLPEntry_t mlp;
 107         connf_t                 *connfp;
 108         int                     i;
 109         boolean_t               ispriv;
 110         zoneid_t                zoneid;
 111         int                     v4_conn_idx;
 112         int                     v6_conn_idx;
 113         conn_t                  *connp = Q_TO_CONN(q);
 114         tcp_stack_t             *tcps;
 115         ip_stack_t              *ipst;
 116         mblk_t                  *mp2ctl;
 117         mib2_tcp_t              tcp_mib;
 118         size_t                  tcp_mib_size, tce_size, tce6_size;
 119 
 120         /*
 121          * make a copy of the original message
 122          */
 123         mp2ctl = copymsg(mpctl);
 124 
 125         if (mpctl == NULL ||
 126             (mpdata = mpctl->b_cont) == NULL ||
 127             (mp_conn_ctl = copymsg(mpctl)) == NULL ||
 128             (mp_attr_ctl = copymsg(mpctl)) == NULL ||
 129             (mp6_conn_ctl = copymsg(mpctl)) == NULL ||
 130             (mp6_attr_ctl = copymsg(mpctl)) == NULL) {
 131                 freemsg(mp_conn_ctl);
 132                 freemsg(mp_attr_ctl);
 133                 freemsg(mp6_conn_ctl);
 134                 freemsg(mp6_attr_ctl);
 135                 freemsg(mpctl);
 136                 freemsg(mp2ctl);
 137                 return (NULL);
 138         }
 139 
 140         ipst = connp->conn_netstack->netstack_ip;
 141         tcps = connp->conn_netstack->netstack_tcp;
 142 
 143         if (legacy_req) {
 144                 tcp_mib_size = LEGACY_MIB_SIZE(&tcp_mib, mib2_tcp_t);
 145                 tce_size = LEGACY_MIB_SIZE(&tce, mib2_tcpConnEntry_t);
 146                 tce6_size = LEGACY_MIB_SIZE(&tce6, mib2_tcp6ConnEntry_t);
 147         } else {
 148                 tcp_mib_size = sizeof (mib2_tcp_t);
 149                 tce_size = sizeof (mib2_tcpConnEntry_t);
 150                 tce6_size = sizeof (mib2_tcp6ConnEntry_t);
 151         }
 152 
 153         bzero(&tcp_mib, sizeof (tcp_mib));
 154 
 155         /* build table of connections -- need count in fixed part */
 156         SET_MIB(tcp_mib.tcpRtoAlgorithm, 4);   /* vanj */
 157         SET_MIB(tcp_mib.tcpRtoMin, tcps->tcps_rexmit_interval_min);
 158         SET_MIB(tcp_mib.tcpRtoMax, tcps->tcps_rexmit_interval_max);
 159         SET_MIB(tcp_mib.tcpMaxConn, -1);
 160         SET_MIB(tcp_mib.tcpCurrEstab, 0);
 161 
 162         ispriv =
 163             secpolicy_ip_config((Q_TO_CONN(q))->conn_cred, B_TRUE) == 0;
 164         zoneid = Q_TO_CONN(q)->conn_zoneid;
 165 
 166         v4_conn_idx = v6_conn_idx = 0;
 167         mp_conn_tail = mp_attr_tail = mp6_conn_tail = mp6_attr_tail = NULL;
 168 
 169         for (i = 0; i < CONN_G_HASH_SIZE; i++) {
 170                 ipst = tcps->tcps_netstack->netstack_ip;
 171 
 172                 connfp = &ipst->ips_ipcl_globalhash_fanout[i];
 173 
 174                 connp = NULL;
 175 
 176                 while ((connp =
 177                     ipcl_get_next_conn(connfp, connp, IPCL_TCPCONN)) != NULL) {
 178                         tcp_t *tcp;
 179                         boolean_t needattr;
 180 
 181                         if (connp->conn_zoneid != zoneid)
 182                                 continue;       /* not in this zone */
 183 
 184                         tcp = connp->conn_tcp;
 185                         TCPS_UPDATE_MIB(tcps, tcpHCInSegs, tcp->tcp_ibsegs);
 186                         tcp->tcp_ibsegs = 0;
 187                         TCPS_UPDATE_MIB(tcps, tcpHCOutSegs, tcp->tcp_obsegs);
 188                         tcp->tcp_obsegs = 0;
 189 
 190                         tce6.tcp6ConnState = tce.tcpConnState =
 191                             tcp_snmp_state(tcp);
 192                         if (tce.tcpConnState == MIB2_TCP_established ||
 193                             tce.tcpConnState == MIB2_TCP_closeWait)
 194                                 BUMP_MIB(&tcp_mib, tcpCurrEstab);
 195 
 196                         needattr = B_FALSE;
 197                         bzero(&mlp, sizeof (mlp));
 198                         if (connp->conn_mlp_type != mlptSingle) {
 199                                 if (connp->conn_mlp_type == mlptShared ||
 200                                     connp->conn_mlp_type == mlptBoth)
 201                                         mlp.tme_flags |= MIB2_TMEF_SHARED;
 202                                 if (connp->conn_mlp_type == mlptPrivate ||
 203                                     connp->conn_mlp_type == mlptBoth)
 204                                         mlp.tme_flags |= MIB2_TMEF_PRIVATE;
 205                                 needattr = B_TRUE;
 206                         }
 207                         if (connp->conn_anon_mlp) {
 208                                 mlp.tme_flags |= MIB2_TMEF_ANONMLP;
 209                                 needattr = B_TRUE;
 210                         }
 211                         switch (connp->conn_mac_mode) {
 212                         case CONN_MAC_DEFAULT:
 213                                 break;
 214                         case CONN_MAC_AWARE:
 215                                 mlp.tme_flags |= MIB2_TMEF_MACEXEMPT;
 216                                 needattr = B_TRUE;
 217                                 break;
 218                         case CONN_MAC_IMPLICIT:
 219                                 mlp.tme_flags |= MIB2_TMEF_MACIMPLICIT;
 220                                 needattr = B_TRUE;
 221                                 break;
 222                         }
 223                         if (connp->conn_ixa->ixa_tsl != NULL) {
 224                                 ts_label_t *tsl;
 225 
 226                                 tsl = connp->conn_ixa->ixa_tsl;
 227                                 mlp.tme_flags |= MIB2_TMEF_IS_LABELED;
 228                                 mlp.tme_doi = label2doi(tsl);
 229                                 mlp.tme_label = *label2bslabel(tsl);
 230                                 needattr = B_TRUE;
 231                         }
 232 
 233                         /* Create a message to report on IPv6 entries */
 234                         if (connp->conn_ipversion == IPV6_VERSION) {
 235                         tce6.tcp6ConnLocalAddress = connp->conn_laddr_v6;
 236                         tce6.tcp6ConnRemAddress = connp->conn_faddr_v6;
 237                         tce6.tcp6ConnLocalPort = ntohs(connp->conn_lport);
 238                         tce6.tcp6ConnRemPort = ntohs(connp->conn_fport);
 239                         if (connp->conn_ixa->ixa_flags & IXAF_SCOPEID_SET) {
 240                                 tce6.tcp6ConnIfIndex =
 241                                     connp->conn_ixa->ixa_scopeid;
 242                         } else {
 243                                 tce6.tcp6ConnIfIndex = connp->conn_bound_if;
 244                         }
 245                         /* Don't want just anybody seeing these... */
 246                         if (ispriv) {
 247                                 tce6.tcp6ConnEntryInfo.ce_snxt =
 248                                     tcp->tcp_snxt;
 249                                 tce6.tcp6ConnEntryInfo.ce_suna =
 250                                     tcp->tcp_suna;
 251                                 tce6.tcp6ConnEntryInfo.ce_rnxt =
 252                                     tcp->tcp_rnxt;
 253                                 tce6.tcp6ConnEntryInfo.ce_rack =
 254                                     tcp->tcp_rack;
 255                         } else {
 256                                 /*
 257                                  * Netstat, unfortunately, uses this to
 258                                  * get send/receive queue sizes.  How to fix?
 259                                  * Why not compute the difference only?
 260                                  */
 261                                 tce6.tcp6ConnEntryInfo.ce_snxt =
 262                                     tcp->tcp_snxt - tcp->tcp_suna;
 263                                 tce6.tcp6ConnEntryInfo.ce_suna = 0;
 264                                 tce6.tcp6ConnEntryInfo.ce_rnxt =
 265                                     tcp->tcp_rnxt - tcp->tcp_rack;
 266                                 tce6.tcp6ConnEntryInfo.ce_rack = 0;
 267                         }
 268 
 269                         tce6.tcp6ConnEntryInfo.ce_swnd = tcp->tcp_swnd;
 270                         tce6.tcp6ConnEntryInfo.ce_rwnd = tcp->tcp_rwnd;
 271                         tce6.tcp6ConnEntryInfo.ce_rto =  tcp->tcp_rto;
 272                         tce6.tcp6ConnEntryInfo.ce_mss =  tcp->tcp_mss;
 273                         tce6.tcp6ConnEntryInfo.ce_state = tcp->tcp_state;
 274 
 275                         tce6.tcp6ConnCreationProcess =
 276                             (connp->conn_cpid < 0) ? MIB2_UNKNOWN_PROCESS :
 277                             connp->conn_cpid;
 278                         tce6.tcp6ConnCreationTime = connp->conn_open_time;
 279 
 280                         (void) snmp_append_data2(mp6_conn_ctl->b_cont,
 281                             &mp6_conn_tail, (char *)&tce6, tce6_size);
 282 
 283                         mlp.tme_connidx = v6_conn_idx++;
 284                         if (needattr)
 285                                 (void) snmp_append_data2(mp6_attr_ctl->b_cont,
 286                                     &mp6_attr_tail, (char *)&mlp, sizeof (mlp));
 287                         }
 288                         /*
 289                          * Create an IPv4 table entry for IPv4 entries and also
 290                          * for IPv6 entries which are bound to in6addr_any
 291                          * but don't have IPV6_V6ONLY set.
 292                          * (i.e. anything an IPv4 peer could connect to)
 293                          */
 294                         if (connp->conn_ipversion == IPV4_VERSION ||
 295                             (tcp->tcp_state <= TCPS_LISTEN &&
 296                             !connp->conn_ipv6_v6only &&
 297                             IN6_IS_ADDR_UNSPECIFIED(&connp->conn_laddr_v6))) {
 298                                 if (connp->conn_ipversion == IPV6_VERSION) {
 299                                         tce.tcpConnRemAddress = INADDR_ANY;
 300                                         tce.tcpConnLocalAddress = INADDR_ANY;
 301                                 } else {
 302                                         tce.tcpConnRemAddress =
 303                                             connp->conn_faddr_v4;
 304                                         tce.tcpConnLocalAddress =
 305                                             connp->conn_laddr_v4;
 306                                 }
 307                                 tce.tcpConnLocalPort = ntohs(connp->conn_lport);
 308                                 tce.tcpConnRemPort = ntohs(connp->conn_fport);
 309                                 /* Don't want just anybody seeing these... */
 310                                 if (ispriv) {
 311                                         tce.tcpConnEntryInfo.ce_snxt =
 312                                             tcp->tcp_snxt;
 313                                         tce.tcpConnEntryInfo.ce_suna =
 314                                             tcp->tcp_suna;
 315                                         tce.tcpConnEntryInfo.ce_rnxt =
 316                                             tcp->tcp_rnxt;
 317                                         tce.tcpConnEntryInfo.ce_rack =
 318                                             tcp->tcp_rack;
 319                                 } else {
 320                                         /*
 321                                          * Netstat, unfortunately, uses this to
 322                                          * get send/receive queue sizes.  How
 323                                          * to fix?
 324                                          * Why not compute the difference only?
 325                                          */
 326                                         tce.tcpConnEntryInfo.ce_snxt =
 327                                             tcp->tcp_snxt - tcp->tcp_suna;
 328                                         tce.tcpConnEntryInfo.ce_suna = 0;
 329                                         tce.tcpConnEntryInfo.ce_rnxt =
 330                                             tcp->tcp_rnxt - tcp->tcp_rack;
 331                                         tce.tcpConnEntryInfo.ce_rack = 0;
 332                                 }
 333 
 334                                 tce.tcpConnEntryInfo.ce_swnd = tcp->tcp_swnd;
 335                                 tce.tcpConnEntryInfo.ce_rwnd = tcp->tcp_rwnd;
 336                                 tce.tcpConnEntryInfo.ce_rto =  tcp->tcp_rto;
 337                                 tce.tcpConnEntryInfo.ce_mss =  tcp->tcp_mss;
 338                                 tce.tcpConnEntryInfo.ce_state =
 339                                     tcp->tcp_state;
 340 
 341                                 tce.tcpConnCreationProcess =
 342                                     (connp->conn_cpid < 0) ?
 343                                     MIB2_UNKNOWN_PROCESS :
 344                                     connp->conn_cpid;
 345                                 tce.tcpConnCreationTime = connp->conn_open_time;
 346 
 347                                 (void) snmp_append_data2(mp_conn_ctl->b_cont,
 348                                     &mp_conn_tail, (char *)&tce, tce_size);
 349 
 350                                 mlp.tme_connidx = v4_conn_idx++;
 351                                 if (needattr)
 352                                         (void) snmp_append_data2(
 353                                             mp_attr_ctl->b_cont,
 354                                             &mp_attr_tail, (char *)&mlp,
 355                                             sizeof (mlp));
 356                         }
 357                 }
 358         }
 359 
 360         tcp_sum_mib(tcps, &tcp_mib);
 361 
 362         /* Fixed length structure for IPv4 and IPv6 counters */
 363         SET_MIB(tcp_mib.tcpConnTableSize, tce_size);
 364         SET_MIB(tcp_mib.tcp6ConnTableSize, tce6_size);
 365 
 366         /*
 367          * Synchronize 32- and 64-bit counters.  Note that tcpInSegs and
 368          * tcpOutSegs are not updated anywhere in TCP.  The new 64 bits
 369          * counters are used.  Hence the old counters' values in tcp_sc_mib
 370          * are always 0.
 371          */
 372         SYNC32_MIB(&tcp_mib, tcpInSegs, tcpHCInSegs);
 373         SYNC32_MIB(&tcp_mib, tcpOutSegs, tcpHCOutSegs);
 374 
 375         optp = (struct opthdr *)&mpctl->b_rptr[sizeof (struct T_optmgmt_ack)];
 376         optp->level = MIB2_TCP;
 377         optp->name = 0;
 378         (void) snmp_append_data(mpdata, (char *)&tcp_mib, tcp_mib_size);
 379         optp->len = msgdsize(mpdata);
 380         qreply(q, mpctl);
 381 
 382         /* table of connections... */
 383         optp = (struct opthdr *)&mp_conn_ctl->b_rptr[
 384             sizeof (struct T_optmgmt_ack)];
 385         optp->level = MIB2_TCP;
 386         optp->name = MIB2_TCP_CONN;
 387         optp->len = msgdsize(mp_conn_ctl->b_cont);
 388         qreply(q, mp_conn_ctl);
 389 
 390         /* table of MLP attributes... */
 391         optp = (struct opthdr *)&mp_attr_ctl->b_rptr[
 392             sizeof (struct T_optmgmt_ack)];
 393         optp->level = MIB2_TCP;
 394         optp->name = EXPER_XPORT_MLP;
 395         optp->len = msgdsize(mp_attr_ctl->b_cont);
 396         if (optp->len == 0)
 397                 freemsg(mp_attr_ctl);
 398         else
 399                 qreply(q, mp_attr_ctl);
 400 
 401         /* table of IPv6 connections... */
 402         optp = (struct opthdr *)&mp6_conn_ctl->b_rptr[
 403             sizeof (struct T_optmgmt_ack)];
 404         optp->level = MIB2_TCP6;
 405         optp->name = MIB2_TCP6_CONN;
 406         optp->len = msgdsize(mp6_conn_ctl->b_cont);
 407         qreply(q, mp6_conn_ctl);
 408 
 409         /* table of IPv6 MLP attributes... */
 410         optp = (struct opthdr *)&mp6_attr_ctl->b_rptr[
 411             sizeof (struct T_optmgmt_ack)];
 412         optp->level = MIB2_TCP6;
 413         optp->name = EXPER_XPORT_MLP;
 414         optp->len = msgdsize(mp6_attr_ctl->b_cont);
 415         if (optp->len == 0)
 416                 freemsg(mp6_attr_ctl);
 417         else
 418                 qreply(q, mp6_attr_ctl);
 419         return (mp2ctl);
 420 }
 421 
 422 /* Return 0 if invalid set request, 1 otherwise, including non-tcp requests  */
 423 /* ARGSUSED */
 424 int
 425 tcp_snmp_set(queue_t *q, int level, int name, uchar_t *ptr, int len)
 426 {
 427         mib2_tcpConnEntry_t     *tce = (mib2_tcpConnEntry_t *)ptr;
 428 
 429         switch (level) {
 430         case MIB2_TCP:
 431                 switch (name) {
 432                 case 13:
 433                         if (tce->tcpConnState != MIB2_TCP_deleteTCB)
 434                                 return (0);
 435                         /* TODO: delete entry defined by tce */
 436                         return (1);
 437                 default:
 438                         return (0);
 439                 }
 440         default:
 441                 return (1);
 442         }
 443 }
 444 
 445 /*
 446  * TCP Kstats implementation
 447  */
 448 void *
 449 tcp_kstat_init(netstackid_t stackid)
 450 {
 451         kstat_t *ksp;
 452 
 453         tcp_named_kstat_t template = {
 454                 { "rtoAlgorithm",       KSTAT_DATA_INT32, 0 },
 455                 { "rtoMin",             KSTAT_DATA_INT32, 0 },
 456                 { "rtoMax",             KSTAT_DATA_INT32, 0 },
 457                 { "maxConn",            KSTAT_DATA_INT32, 0 },
 458                 { "activeOpens",        KSTAT_DATA_UINT32, 0 },
 459                 { "passiveOpens",       KSTAT_DATA_UINT32, 0 },
 460                 { "attemptFails",       KSTAT_DATA_UINT32, 0 },
 461                 { "estabResets",        KSTAT_DATA_UINT32, 0 },
 462                 { "currEstab",          KSTAT_DATA_UINT32, 0 },
 463                 { "inSegs",             KSTAT_DATA_UINT64, 0 },
 464                 { "outSegs",            KSTAT_DATA_UINT64, 0 },
 465                 { "retransSegs",        KSTAT_DATA_UINT32, 0 },
 466                 { "connTableSize",      KSTAT_DATA_INT32, 0 },
 467                 { "outRsts",            KSTAT_DATA_UINT32, 0 },
 468                 { "outDataSegs",        KSTAT_DATA_UINT32, 0 },
 469                 { "outDataBytes",       KSTAT_DATA_UINT32, 0 },
 470                 { "retransBytes",       KSTAT_DATA_UINT32, 0 },
 471                 { "outAck",             KSTAT_DATA_UINT32, 0 },
 472                 { "outAckDelayed",      KSTAT_DATA_UINT32, 0 },
 473                 { "outUrg",             KSTAT_DATA_UINT32, 0 },
 474                 { "outWinUpdate",       KSTAT_DATA_UINT32, 0 },
 475                 { "outWinProbe",        KSTAT_DATA_UINT32, 0 },
 476                 { "outControl",         KSTAT_DATA_UINT32, 0 },
 477                 { "outFastRetrans",     KSTAT_DATA_UINT32, 0 },
 478                 { "inAckSegs",          KSTAT_DATA_UINT32, 0 },
 479                 { "inAckBytes",         KSTAT_DATA_UINT32, 0 },
 480                 { "inDupAck",           KSTAT_DATA_UINT32, 0 },
 481                 { "inAckUnsent",        KSTAT_DATA_UINT32, 0 },
 482                 { "inDataInorderSegs",  KSTAT_DATA_UINT32, 0 },
 483                 { "inDataInorderBytes", KSTAT_DATA_UINT32, 0 },
 484                 { "inDataUnorderSegs",  KSTAT_DATA_UINT32, 0 },
 485                 { "inDataUnorderBytes", KSTAT_DATA_UINT32, 0 },
 486                 { "inDataDupSegs",      KSTAT_DATA_UINT32, 0 },
 487                 { "inDataDupBytes",     KSTAT_DATA_UINT32, 0 },
 488                 { "inDataPartDupSegs",  KSTAT_DATA_UINT32, 0 },
 489                 { "inDataPartDupBytes", KSTAT_DATA_UINT32, 0 },
 490                 { "inDataPastWinSegs",  KSTAT_DATA_UINT32, 0 },
 491                 { "inDataPastWinBytes", KSTAT_DATA_UINT32, 0 },
 492                 { "inWinProbe",         KSTAT_DATA_UINT32, 0 },
 493                 { "inWinUpdate",        KSTAT_DATA_UINT32, 0 },
 494                 { "inClosed",           KSTAT_DATA_UINT32, 0 },
 495                 { "rttUpdate",          KSTAT_DATA_UINT32, 0 },
 496                 { "rttNoUpdate",        KSTAT_DATA_UINT32, 0 },
 497                 { "timRetrans",         KSTAT_DATA_UINT32, 0 },
 498                 { "timRetransDrop",     KSTAT_DATA_UINT32, 0 },
 499                 { "timKeepalive",       KSTAT_DATA_UINT32, 0 },
 500                 { "timKeepaliveProbe",  KSTAT_DATA_UINT32, 0 },
 501                 { "timKeepaliveDrop",   KSTAT_DATA_UINT32, 0 },
 502                 { "listenDrop",         KSTAT_DATA_UINT32, 0 },
 503                 { "listenDropQ0",       KSTAT_DATA_UINT32, 0 },
 504                 { "halfOpenDrop",       KSTAT_DATA_UINT32, 0 },
 505                 { "outSackRetransSegs", KSTAT_DATA_UINT32, 0 },
 506                 { "connTableSize6",     KSTAT_DATA_INT32, 0 }
 507         };
 508 
 509         ksp = kstat_create_netstack(TCP_MOD_NAME, 0, TCP_MOD_NAME, "mib2",
 510             KSTAT_TYPE_NAMED, NUM_OF_FIELDS(tcp_named_kstat_t), 0, stackid);
 511 
 512         if (ksp == NULL)
 513                 return (NULL);
 514 
 515         template.rtoAlgorithm.value.ui32 = 4;
 516         template.maxConn.value.i32 = -1;
 517 
 518         bcopy(&template, ksp->ks_data, sizeof (template));
 519         ksp->ks_update = tcp_kstat_update;
 520         ksp->ks_private = (void *)(uintptr_t)stackid;
 521 
 522         kstat_install(ksp);
 523         return (ksp);
 524 }
 525 
 526 void
 527 tcp_kstat_fini(netstackid_t stackid, kstat_t *ksp)
 528 {
 529         if (ksp != NULL) {
 530                 ASSERT(stackid == (netstackid_t)(uintptr_t)ksp->ks_private);
 531                 kstat_delete_netstack(ksp, stackid);
 532         }
 533 }
 534 
 535 static int
 536 tcp_kstat_update(kstat_t *kp, int rw)
 537 {
 538         tcp_named_kstat_t *tcpkp;
 539         tcp_t           *tcp;
 540         connf_t         *connfp;
 541         conn_t          *connp;
 542         int             i;
 543         netstackid_t    stackid = (netstackid_t)(uintptr_t)kp->ks_private;
 544         netstack_t      *ns;
 545         tcp_stack_t     *tcps;
 546         ip_stack_t      *ipst;
 547         mib2_tcp_t      tcp_mib;
 548 
 549         if (rw == KSTAT_WRITE)
 550                 return (EACCES);
 551 
 552         ns = netstack_find_by_stackid(stackid);
 553         if (ns == NULL)
 554                 return (-1);
 555         tcps = ns->netstack_tcp;
 556         if (tcps == NULL) {
 557                 netstack_rele(ns);
 558                 return (-1);
 559         }
 560 
 561         tcpkp = (tcp_named_kstat_t *)kp->ks_data;
 562 
 563         tcpkp->currEstab.value.ui32 = 0;
 564         tcpkp->rtoMin.value.ui32 = tcps->tcps_rexmit_interval_min;
 565         tcpkp->rtoMax.value.ui32 = tcps->tcps_rexmit_interval_max;
 566 
 567         ipst = ns->netstack_ip;
 568 
 569         for (i = 0; i < CONN_G_HASH_SIZE; i++) {
 570                 connfp = &ipst->ips_ipcl_globalhash_fanout[i];
 571                 connp = NULL;
 572                 while ((connp =
 573                     ipcl_get_next_conn(connfp, connp, IPCL_TCPCONN)) != NULL) {
 574                         tcp = connp->conn_tcp;
 575                         switch (tcp_snmp_state(tcp)) {
 576                         case MIB2_TCP_established:
 577                         case MIB2_TCP_closeWait:
 578                                 tcpkp->currEstab.value.ui32++;
 579                                 break;
 580                         }
 581                 }
 582         }
 583         bzero(&tcp_mib, sizeof (tcp_mib));
 584         tcp_sum_mib(tcps, &tcp_mib);
 585 
 586         /* Fixed length structure for IPv4 and IPv6 counters */
 587         SET_MIB(tcp_mib.tcpConnTableSize, sizeof (mib2_tcpConnEntry_t));
 588         SET_MIB(tcp_mib.tcp6ConnTableSize, sizeof (mib2_tcp6ConnEntry_t));
 589 
 590         tcpkp->activeOpens.value.ui32 = tcp_mib.tcpActiveOpens;
 591         tcpkp->passiveOpens.value.ui32 = tcp_mib.tcpPassiveOpens;
 592         tcpkp->attemptFails.value.ui32 = tcp_mib.tcpAttemptFails;
 593         tcpkp->estabResets.value.ui32 = tcp_mib.tcpEstabResets;
 594         tcpkp->inSegs.value.ui64 = tcp_mib.tcpHCInSegs;
 595         tcpkp->outSegs.value.ui64 = tcp_mib.tcpHCOutSegs;
 596         tcpkp->retransSegs.value.ui32 =      tcp_mib.tcpRetransSegs;
 597         tcpkp->connTableSize.value.i32 = tcp_mib.tcpConnTableSize;
 598         tcpkp->outRsts.value.ui32 = tcp_mib.tcpOutRsts;
 599         tcpkp->outDataSegs.value.ui32 = tcp_mib.tcpOutDataSegs;
 600         tcpkp->outDataBytes.value.ui32 = tcp_mib.tcpOutDataBytes;
 601         tcpkp->retransBytes.value.ui32 = tcp_mib.tcpRetransBytes;
 602         tcpkp->outAck.value.ui32 = tcp_mib.tcpOutAck;
 603         tcpkp->outAckDelayed.value.ui32 = tcp_mib.tcpOutAckDelayed;
 604         tcpkp->outUrg.value.ui32 = tcp_mib.tcpOutUrg;
 605         tcpkp->outWinUpdate.value.ui32 = tcp_mib.tcpOutWinUpdate;
 606         tcpkp->outWinProbe.value.ui32 = tcp_mib.tcpOutWinProbe;
 607         tcpkp->outControl.value.ui32 = tcp_mib.tcpOutControl;
 608         tcpkp->outFastRetrans.value.ui32 = tcp_mib.tcpOutFastRetrans;
 609         tcpkp->inAckSegs.value.ui32 = tcp_mib.tcpInAckSegs;
 610         tcpkp->inAckBytes.value.ui32 = tcp_mib.tcpInAckBytes;
 611         tcpkp->inDupAck.value.ui32 = tcp_mib.tcpInDupAck;
 612         tcpkp->inAckUnsent.value.ui32 = tcp_mib.tcpInAckUnsent;
 613         tcpkp->inDataInorderSegs.value.ui32 = tcp_mib.tcpInDataInorderSegs;
 614         tcpkp->inDataInorderBytes.value.ui32 = tcp_mib.tcpInDataInorderBytes;
 615         tcpkp->inDataUnorderSegs.value.ui32 = tcp_mib.tcpInDataUnorderSegs;
 616         tcpkp->inDataUnorderBytes.value.ui32 = tcp_mib.tcpInDataUnorderBytes;
 617         tcpkp->inDataDupSegs.value.ui32 = tcp_mib.tcpInDataDupSegs;
 618         tcpkp->inDataDupBytes.value.ui32 = tcp_mib.tcpInDataDupBytes;
 619         tcpkp->inDataPartDupSegs.value.ui32 = tcp_mib.tcpInDataPartDupSegs;
 620         tcpkp->inDataPartDupBytes.value.ui32 = tcp_mib.tcpInDataPartDupBytes;
 621         tcpkp->inDataPastWinSegs.value.ui32 = tcp_mib.tcpInDataPastWinSegs;
 622         tcpkp->inDataPastWinBytes.value.ui32 = tcp_mib.tcpInDataPastWinBytes;
 623         tcpkp->inWinProbe.value.ui32 = tcp_mib.tcpInWinProbe;
 624         tcpkp->inWinUpdate.value.ui32 = tcp_mib.tcpInWinUpdate;
 625         tcpkp->inClosed.value.ui32 = tcp_mib.tcpInClosed;
 626         tcpkp->rttNoUpdate.value.ui32 = tcp_mib.tcpRttNoUpdate;
 627         tcpkp->rttUpdate.value.ui32 = tcp_mib.tcpRttUpdate;
 628         tcpkp->timRetrans.value.ui32 = tcp_mib.tcpTimRetrans;
 629         tcpkp->timRetransDrop.value.ui32 = tcp_mib.tcpTimRetransDrop;
 630         tcpkp->timKeepalive.value.ui32 = tcp_mib.tcpTimKeepalive;
 631         tcpkp->timKeepaliveProbe.value.ui32 = tcp_mib.tcpTimKeepaliveProbe;
 632         tcpkp->timKeepaliveDrop.value.ui32 = tcp_mib.tcpTimKeepaliveDrop;
 633         tcpkp->listenDrop.value.ui32 = tcp_mib.tcpListenDrop;
 634         tcpkp->listenDropQ0.value.ui32 = tcp_mib.tcpListenDropQ0;
 635         tcpkp->halfOpenDrop.value.ui32 = tcp_mib.tcpHalfOpenDrop;
 636         tcpkp->outSackRetransSegs.value.ui32 = tcp_mib.tcpOutSackRetransSegs;
 637         tcpkp->connTableSize6.value.i32 = tcp_mib.tcp6ConnTableSize;
 638 
 639         netstack_rele(ns);
 640         return (0);
 641 }
 642 
 643 /*
 644  * kstats related to squeues i.e. not per IP instance
 645  */
 646 void *
 647 tcp_g_kstat_init(tcp_g_stat_t *tcp_g_statp)
 648 {
 649         kstat_t *ksp;
 650 
 651         tcp_g_stat_t template = {
 652                 { "tcp_timermp_alloced",        KSTAT_DATA_UINT64 },
 653                 { "tcp_timermp_allocfail",      KSTAT_DATA_UINT64 },
 654                 { "tcp_timermp_allocdblfail",   KSTAT_DATA_UINT64 },
 655                 { "tcp_freelist_cleanup",       KSTAT_DATA_UINT64 },
 656         };
 657 
 658         ksp = kstat_create(TCP_MOD_NAME, 0, "tcpstat_g", "net",
 659             KSTAT_TYPE_NAMED, sizeof (template) / sizeof (kstat_named_t),
 660             KSTAT_FLAG_VIRTUAL);
 661 
 662         if (ksp == NULL)
 663                 return (NULL);
 664 
 665         bcopy(&template, tcp_g_statp, sizeof (template));
 666         ksp->ks_data = (void *)tcp_g_statp;
 667 
 668         kstat_install(ksp);
 669         return (ksp);
 670 }
 671 
 672 void
 673 tcp_g_kstat_fini(kstat_t *ksp)
 674 {
 675         if (ksp != NULL) {
 676                 kstat_delete(ksp);
 677         }
 678 }
 679 
 680 void *
 681 tcp_kstat2_init(netstackid_t stackid)
 682 {
 683         kstat_t *ksp;
 684 
 685         tcp_stat_t template = {
 686                 { "tcp_time_wait_syn_success",  KSTAT_DATA_UINT64, 0 },
 687                 { "tcp_clean_death_nondetached",        KSTAT_DATA_UINT64, 0 },
 688                 { "tcp_eager_blowoff_q",        KSTAT_DATA_UINT64, 0 },
 689                 { "tcp_eager_blowoff_q0",       KSTAT_DATA_UINT64, 0 },
 690                 { "tcp_no_listener",            KSTAT_DATA_UINT64, 0 },
 691                 { "tcp_listendrop",             KSTAT_DATA_UINT64, 0 },
 692                 { "tcp_listendropq0",           KSTAT_DATA_UINT64, 0 },
 693                 { "tcp_wsrv_called",            KSTAT_DATA_UINT64, 0 },
 694                 { "tcp_flwctl_on",              KSTAT_DATA_UINT64, 0 },
 695                 { "tcp_timer_fire_early",       KSTAT_DATA_UINT64, 0 },
 696                 { "tcp_timer_fire_miss",        KSTAT_DATA_UINT64, 0 },
 697                 { "tcp_zcopy_on",               KSTAT_DATA_UINT64, 0 },
 698                 { "tcp_zcopy_off",              KSTAT_DATA_UINT64, 0 },
 699                 { "tcp_zcopy_backoff",          KSTAT_DATA_UINT64, 0 },
 700                 { "tcp_fusion_flowctl",         KSTAT_DATA_UINT64, 0 },
 701                 { "tcp_fusion_backenabled",     KSTAT_DATA_UINT64, 0 },
 702                 { "tcp_fusion_urg",             KSTAT_DATA_UINT64, 0 },
 703                 { "tcp_fusion_putnext",         KSTAT_DATA_UINT64, 0 },
 704                 { "tcp_fusion_unfusable",       KSTAT_DATA_UINT64, 0 },
 705                 { "tcp_fusion_aborted",         KSTAT_DATA_UINT64, 0 },
 706                 { "tcp_fusion_unqualified",     KSTAT_DATA_UINT64, 0 },
 707                 { "tcp_fusion_rrw_busy",        KSTAT_DATA_UINT64, 0 },
 708                 { "tcp_fusion_rrw_msgcnt",      KSTAT_DATA_UINT64, 0 },
 709                 { "tcp_fusion_rrw_plugged",     KSTAT_DATA_UINT64, 0 },
 710                 { "tcp_in_ack_unsent_drop",     KSTAT_DATA_UINT64, 0 },
 711                 { "tcp_sock_fallback",          KSTAT_DATA_UINT64, 0 },
 712                 { "tcp_lso_enabled",            KSTAT_DATA_UINT64, 0 },
 713                 { "tcp_lso_disabled",           KSTAT_DATA_UINT64, 0 },
 714                 { "tcp_lso_times",              KSTAT_DATA_UINT64, 0 },
 715                 { "tcp_lso_pkt_out",            KSTAT_DATA_UINT64, 0 },
 716                 { "tcp_listen_cnt_drop",        KSTAT_DATA_UINT64, 0 },
 717                 { "tcp_listen_mem_drop",        KSTAT_DATA_UINT64, 0 },
 718                 { "tcp_zwin_mem_drop",          KSTAT_DATA_UINT64, 0 },
 719                 { "tcp_zwin_ack_syn",           KSTAT_DATA_UINT64, 0 },
 720                 { "tcp_rst_unsent",             KSTAT_DATA_UINT64, 0 },
 721                 { "tcp_reclaim_cnt",            KSTAT_DATA_UINT64, 0 },
 722                 { "tcp_reass_timeout",          KSTAT_DATA_UINT64, 0 },
 723 #ifdef TCP_DEBUG_COUNTER
 724                 { "tcp_time_wait",              KSTAT_DATA_UINT64, 0 },
 725                 { "tcp_rput_time_wait",         KSTAT_DATA_UINT64, 0 },
 726                 { "tcp_detach_time_wait",       KSTAT_DATA_UINT64, 0 },
 727                 { "tcp_timeout_calls",          KSTAT_DATA_UINT64, 0 },
 728                 { "tcp_timeout_cached_alloc",   KSTAT_DATA_UINT64, 0 },
 729                 { "tcp_timeout_cancel_reqs",    KSTAT_DATA_UINT64, 0 },
 730                 { "tcp_timeout_canceled",       KSTAT_DATA_UINT64, 0 },
 731                 { "tcp_timermp_freed",          KSTAT_DATA_UINT64, 0 },
 732                 { "tcp_push_timer_cnt",         KSTAT_DATA_UINT64, 0 },
 733                 { "tcp_ack_timer_cnt",          KSTAT_DATA_UINT64, 0 },
 734 #endif
 735         };
 736 
 737         ksp = kstat_create_netstack(TCP_MOD_NAME, 0, "tcpstat", "net",
 738             KSTAT_TYPE_NAMED, sizeof (template) / sizeof (kstat_named_t), 0,
 739             stackid);
 740 
 741         if (ksp == NULL)
 742                 return (NULL);
 743 
 744         bcopy(&template, ksp->ks_data, sizeof (template));
 745         ksp->ks_private = (void *)(uintptr_t)stackid;
 746         ksp->ks_update = tcp_kstat2_update;
 747 
 748         kstat_install(ksp);
 749         return (ksp);
 750 }
 751 
 752 void
 753 tcp_kstat2_fini(netstackid_t stackid, kstat_t *ksp)
 754 {
 755         if (ksp != NULL) {
 756                 ASSERT(stackid == (netstackid_t)(uintptr_t)ksp->ks_private);
 757                 kstat_delete_netstack(ksp, stackid);
 758         }
 759 }
 760 
 761 /*
 762  * Sum up all per CPU tcp_stat_t kstat counters.
 763  */
 764 static int
 765 tcp_kstat2_update(kstat_t *kp, int rw)
 766 {
 767         netstackid_t    stackid = (netstackid_t)(uintptr_t)kp->ks_private;
 768         netstack_t      *ns;
 769         tcp_stack_t     *tcps;
 770         tcp_stat_t      *stats;
 771         int             i;
 772         int             cnt;
 773 
 774         if (rw == KSTAT_WRITE)
 775                 return (EACCES);
 776 
 777         ns = netstack_find_by_stackid(stackid);
 778         if (ns == NULL)
 779                 return (-1);
 780         tcps = ns->netstack_tcp;
 781         if (tcps == NULL) {
 782                 netstack_rele(ns);
 783                 return (-1);
 784         }
 785 
 786         stats = (tcp_stat_t *)kp->ks_data;
 787         tcp_clr_stats(stats);
 788 
 789         /*
 790          * tcps_sc_cnt may change in the middle of the loop.  It is better
 791          * to get its value first.
 792          */
 793         cnt = tcps->tcps_sc_cnt;
 794         for (i = 0; i < cnt; i++)
 795                 tcp_add_stats(&tcps->tcps_sc[i]->tcp_sc_stats, stats);
 796 
 797         netstack_rele(ns);
 798         return (0);
 799 }
 800 
 801 /*
 802  * To add stats from one mib2_tcp_t to another.  Static fields are not added.
 803  * The caller should set them up propertly.
 804  */
 805 void
 806 tcp_add_mib(mib2_tcp_t *from, mib2_tcp_t *to)
 807 {
 808         to->tcpActiveOpens += from->tcpActiveOpens;
 809         to->tcpPassiveOpens += from->tcpPassiveOpens;
 810         to->tcpAttemptFails += from->tcpAttemptFails;
 811         to->tcpEstabResets += from->tcpEstabResets;
 812         to->tcpInSegs += from->tcpInSegs;
 813         to->tcpOutSegs += from->tcpOutSegs;
 814         to->tcpRetransSegs += from->tcpRetransSegs;
 815         to->tcpOutRsts += from->tcpOutRsts;
 816 
 817         to->tcpOutDataSegs += from->tcpOutDataSegs;
 818         to->tcpOutDataBytes += from->tcpOutDataBytes;
 819         to->tcpRetransBytes += from->tcpRetransBytes;
 820         to->tcpOutAck += from->tcpOutAck;
 821         to->tcpOutAckDelayed += from->tcpOutAckDelayed;
 822         to->tcpOutUrg += from->tcpOutUrg;
 823         to->tcpOutWinUpdate += from->tcpOutWinUpdate;
 824         to->tcpOutWinProbe += from->tcpOutWinProbe;
 825         to->tcpOutControl += from->tcpOutControl;
 826         to->tcpOutFastRetrans += from->tcpOutFastRetrans;
 827 
 828         to->tcpInAckBytes += from->tcpInAckBytes;
 829         to->tcpInDupAck += from->tcpInDupAck;
 830         to->tcpInAckUnsent += from->tcpInAckUnsent;
 831         to->tcpInDataInorderSegs += from->tcpInDataInorderSegs;
 832         to->tcpInDataInorderBytes += from->tcpInDataInorderBytes;
 833         to->tcpInDataUnorderSegs += from->tcpInDataUnorderSegs;
 834         to->tcpInDataUnorderBytes += from->tcpInDataUnorderBytes;
 835         to->tcpInDataDupSegs += from->tcpInDataDupSegs;
 836         to->tcpInDataDupBytes += from->tcpInDataDupBytes;
 837         to->tcpInDataPartDupSegs += from->tcpInDataPartDupSegs;
 838         to->tcpInDataPartDupBytes += from->tcpInDataPartDupBytes;
 839         to->tcpInDataPastWinSegs += from->tcpInDataPastWinSegs;
 840         to->tcpInDataPastWinBytes += from->tcpInDataPastWinBytes;
 841         to->tcpInWinProbe += from->tcpInWinProbe;
 842         to->tcpInWinUpdate += from->tcpInWinUpdate;
 843         to->tcpInClosed += from->tcpInClosed;
 844 
 845         to->tcpRttNoUpdate += from->tcpRttNoUpdate;
 846         to->tcpRttUpdate += from->tcpRttUpdate;
 847         to->tcpTimRetrans += from->tcpTimRetrans;
 848         to->tcpTimRetransDrop += from->tcpTimRetransDrop;
 849         to->tcpTimKeepalive += from->tcpTimKeepalive;
 850         to->tcpTimKeepaliveProbe += from->tcpTimKeepaliveProbe;
 851         to->tcpTimKeepaliveDrop += from->tcpTimKeepaliveDrop;
 852         to->tcpListenDrop += from->tcpListenDrop;
 853         to->tcpListenDropQ0 += from->tcpListenDropQ0;
 854         to->tcpHalfOpenDrop += from->tcpHalfOpenDrop;
 855         to->tcpOutSackRetransSegs += from->tcpOutSackRetransSegs;
 856         to->tcpHCInSegs += from->tcpHCInSegs;
 857         to->tcpHCOutSegs += from->tcpHCOutSegs;
 858 }
 859 
 860 /*
 861  * To sum up all MIB2 stats for a tcp_stack_t from all per CPU stats.  The
 862  * caller should initialize the target mib2_tcp_t properly as this function
 863  * just adds up all the per CPU stats.
 864  */
 865 static void
 866 tcp_sum_mib(tcp_stack_t *tcps, mib2_tcp_t *tcp_mib)
 867 {
 868         int i;
 869         int cnt;
 870 
 871         /*
 872          * tcps_sc_cnt may change in the middle of the loop.  It is better
 873          * to get its value first.
 874          */
 875         cnt = tcps->tcps_sc_cnt;
 876         for (i = 0; i < cnt; i++)
 877                 tcp_add_mib(&tcps->tcps_sc[i]->tcp_sc_mib, tcp_mib);
 878 }
 879 
 880 /*
 881  * To set all tcp_stat_t counters to 0.
 882  */
 883 static void
 884 tcp_clr_stats(tcp_stat_t *stats)
 885 {
 886         stats->tcp_time_wait_syn_success.value.ui64 = 0;
 887         stats->tcp_clean_death_nondetached.value.ui64 = 0;
 888         stats->tcp_eager_blowoff_q.value.ui64 = 0;
 889         stats->tcp_eager_blowoff_q0.value.ui64 = 0;
 890         stats->tcp_no_listener.value.ui64 = 0;
 891         stats->tcp_listendrop.value.ui64 = 0;
 892         stats->tcp_listendropq0.value.ui64 = 0;
 893         stats->tcp_wsrv_called.value.ui64 = 0;
 894         stats->tcp_flwctl_on.value.ui64 = 0;
 895         stats->tcp_timer_fire_early.value.ui64 = 0;
 896         stats->tcp_timer_fire_miss.value.ui64 = 0;
 897         stats->tcp_zcopy_on.value.ui64 = 0;
 898         stats->tcp_zcopy_off.value.ui64 = 0;
 899         stats->tcp_zcopy_backoff.value.ui64 = 0;
 900         stats->tcp_fusion_flowctl.value.ui64 = 0;
 901         stats->tcp_fusion_backenabled.value.ui64 = 0;
 902         stats->tcp_fusion_urg.value.ui64 = 0;
 903         stats->tcp_fusion_putnext.value.ui64 = 0;
 904         stats->tcp_fusion_unfusable.value.ui64 = 0;
 905         stats->tcp_fusion_aborted.value.ui64 = 0;
 906         stats->tcp_fusion_unqualified.value.ui64 = 0;
 907         stats->tcp_fusion_rrw_busy.value.ui64 = 0;
 908         stats->tcp_fusion_rrw_msgcnt.value.ui64 = 0;
 909         stats->tcp_fusion_rrw_plugged.value.ui64 = 0;
 910         stats->tcp_in_ack_unsent_drop.value.ui64 = 0;
 911         stats->tcp_sock_fallback.value.ui64 = 0;
 912         stats->tcp_lso_enabled.value.ui64 = 0;
 913         stats->tcp_lso_disabled.value.ui64 = 0;
 914         stats->tcp_lso_times.value.ui64 = 0;
 915         stats->tcp_lso_pkt_out.value.ui64 = 0;
 916         stats->tcp_listen_cnt_drop.value.ui64 = 0;
 917         stats->tcp_listen_mem_drop.value.ui64 = 0;
 918         stats->tcp_zwin_mem_drop.value.ui64 = 0;
 919         stats->tcp_zwin_ack_syn.value.ui64 = 0;
 920         stats->tcp_rst_unsent.value.ui64 = 0;
 921         stats->tcp_reclaim_cnt.value.ui64 = 0;
 922         stats->tcp_reass_timeout.value.ui64 = 0;
 923 
 924 #ifdef TCP_DEBUG_COUNTER
 925         stats->tcp_time_wait.value.ui64 = 0;
 926         stats->tcp_rput_time_wait.value.ui64 = 0;
 927         stats->tcp_detach_time_wait.value.ui64 = 0;
 928         stats->tcp_timeout_calls.value.ui64 = 0;
 929         stats->tcp_timeout_cached_alloc.value.ui64 = 0;
 930         stats->tcp_timeout_cancel_reqs.value.ui64 = 0;
 931         stats->tcp_timeout_canceled.value.ui64 = 0;
 932         stats->tcp_timermp_freed.value.ui64 = 0;
 933         stats->tcp_push_timer_cnt.value.ui64 = 0;
 934         stats->tcp_ack_timer_cnt.value.ui64 = 0;
 935 #endif
 936 }
 937 
 938 /*
 939  * To add counters from the per CPU tcp_stat_counter_t to the stack
 940  * tcp_stat_t.
 941  */
 942 static void
 943 tcp_add_stats(tcp_stat_counter_t *from, tcp_stat_t *to)
 944 {
 945         to->tcp_time_wait_syn_success.value.ui64 +=
 946             from->tcp_time_wait_syn_success;
 947         to->tcp_clean_death_nondetached.value.ui64 +=
 948             from->tcp_clean_death_nondetached;
 949         to->tcp_eager_blowoff_q.value.ui64 +=
 950             from->tcp_eager_blowoff_q;
 951         to->tcp_eager_blowoff_q0.value.ui64 +=
 952             from->tcp_eager_blowoff_q0;
 953         to->tcp_no_listener.value.ui64 +=
 954             from->tcp_no_listener;
 955         to->tcp_listendrop.value.ui64 +=
 956             from->tcp_listendrop;
 957         to->tcp_listendropq0.value.ui64 +=
 958             from->tcp_listendropq0;
 959         to->tcp_wsrv_called.value.ui64 +=
 960             from->tcp_wsrv_called;
 961         to->tcp_flwctl_on.value.ui64 +=
 962             from->tcp_flwctl_on;
 963         to->tcp_timer_fire_early.value.ui64 +=
 964             from->tcp_timer_fire_early;
 965         to->tcp_timer_fire_miss.value.ui64 +=
 966             from->tcp_timer_fire_miss;
 967         to->tcp_zcopy_on.value.ui64 +=
 968             from->tcp_zcopy_on;
 969         to->tcp_zcopy_off.value.ui64 +=
 970             from->tcp_zcopy_off;
 971         to->tcp_zcopy_backoff.value.ui64 +=
 972             from->tcp_zcopy_backoff;
 973         to->tcp_fusion_flowctl.value.ui64 +=
 974             from->tcp_fusion_flowctl;
 975         to->tcp_fusion_backenabled.value.ui64 +=
 976             from->tcp_fusion_backenabled;
 977         to->tcp_fusion_urg.value.ui64 +=
 978             from->tcp_fusion_urg;
 979         to->tcp_fusion_putnext.value.ui64 +=
 980             from->tcp_fusion_putnext;
 981         to->tcp_fusion_unfusable.value.ui64 +=
 982             from->tcp_fusion_unfusable;
 983         to->tcp_fusion_aborted.value.ui64 +=
 984             from->tcp_fusion_aborted;
 985         to->tcp_fusion_unqualified.value.ui64 +=
 986             from->tcp_fusion_unqualified;
 987         to->tcp_fusion_rrw_busy.value.ui64 +=
 988             from->tcp_fusion_rrw_busy;
 989         to->tcp_fusion_rrw_msgcnt.value.ui64 +=
 990             from->tcp_fusion_rrw_msgcnt;
 991         to->tcp_fusion_rrw_plugged.value.ui64 +=
 992             from->tcp_fusion_rrw_plugged;
 993         to->tcp_in_ack_unsent_drop.value.ui64 +=
 994             from->tcp_in_ack_unsent_drop;
 995         to->tcp_sock_fallback.value.ui64 +=
 996             from->tcp_sock_fallback;
 997         to->tcp_lso_enabled.value.ui64 +=
 998             from->tcp_lso_enabled;
 999         to->tcp_lso_disabled.value.ui64 +=
1000             from->tcp_lso_disabled;
1001         to->tcp_lso_times.value.ui64 +=
1002             from->tcp_lso_times;
1003         to->tcp_lso_pkt_out.value.ui64 +=
1004             from->tcp_lso_pkt_out;
1005         to->tcp_listen_cnt_drop.value.ui64 +=
1006             from->tcp_listen_cnt_drop;
1007         to->tcp_listen_mem_drop.value.ui64 +=
1008             from->tcp_listen_mem_drop;
1009         to->tcp_zwin_mem_drop.value.ui64 +=
1010             from->tcp_zwin_mem_drop;
1011         to->tcp_zwin_ack_syn.value.ui64 +=
1012             from->tcp_zwin_ack_syn;
1013         to->tcp_rst_unsent.value.ui64 +=
1014             from->tcp_rst_unsent;
1015         to->tcp_reclaim_cnt.value.ui64 +=
1016             from->tcp_reclaim_cnt;
1017         to->tcp_reass_timeout.value.ui64 +=
1018             from->tcp_reass_timeout;
1019 
1020 #ifdef TCP_DEBUG_COUNTER
1021         to->tcp_time_wait.value.ui64 +=
1022             from->tcp_time_wait;
1023         to->tcp_rput_time_wait.value.ui64 +=
1024             from->tcp_rput_time_wait;
1025         to->tcp_detach_time_wait.value.ui64 +=
1026             from->tcp_detach_time_wait;
1027         to->tcp_timeout_calls.value.ui64 +=
1028             from->tcp_timeout_calls;
1029         to->tcp_timeout_cached_alloc.value.ui64 +=
1030             from->tcp_timeout_cached_alloc;
1031         to->tcp_timeout_cancel_reqs.value.ui64 +=
1032             from->tcp_timeout_cancel_reqs;
1033         to->tcp_timeout_canceled.value.ui64 +=
1034             from->tcp_timeout_canceled;
1035         to->tcp_timermp_freed.value.ui64 +=
1036             from->tcp_timermp_freed;
1037         to->tcp_push_timer_cnt.value.ui64 +=
1038             from->tcp_push_timer_cnt;
1039         to->tcp_ack_timer_cnt.value.ui64 +=
1040             from->tcp_ack_timer_cnt;
1041 #endif
1042 }