usr.bin/systat/tcp.c

   1 /*-
   2  * Copyright (c) 1980, 1992, 1993
   3  *      The Regents of the University of California.  All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  * 3. Neither the name of the University nor the names of its contributors
  14  *    may be used to endorse or promote products derived from this software
  15  *    without specific prior written permission.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  20  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  27  * SUCH DAMAGE.
  28  *
  29  * @(#)mbufs.c  8.1 (Berkeley) 6/6/93
  30  * $FreeBSD: src/usr.bin/systat/tcp.c,v 1.3 1999/08/28 01:06:06 peter Exp $
  31  * $DragonFly: src/usr.bin/systat/tcp.c,v 1.5 2004/04/07 21:40:19 dillon Exp $
  32  */
  33
  34 #include <sys/param.h>
  35 #include <sys/types.h>
  36 #include <sys/socket.h>
  37 #include <sys/sysctl.h>
  38
  39 #include <netinet/in.h>
  40 #include <netinet/in_systm.h>
  41 #include <netinet/ip.h>
  42 #include <netinet/tcp.h>
  43 #include <netinet/tcp_seq.h>
  44 #include <netinet/tcp_fsm.h>
  45 #include <netinet/tcp_timer.h>
  46 #include <netinet/tcp_var.h>
  47
  48 #include <stdlib.h>
  49 #include <string.h>
  50 #include <paths.h>
  51 #include "systat.h"
  52 #include "extern.h"
  53 #include "mode.h"
  54
  55 static struct tcp_stats curstat, initstat, oldstat;
  56
  57 /*-
  58 --0         1         2         3         4         5         6         7
  59 --0123456789012345678901234567890123456789012345678901234567890123456789012345
  60 01          TCP Connections                    TCP Packets
  61 02999999999 connections initiated    999999999 total packets sent
  62 03999999999 connections accepted     999999999 - data
  63 04999999999 connections established  999999999 - data (retransmit)
  64 05999999999 connections dropped      999999999 - ack-only
  65 06999999999 - in embryonic state     999999999 - window probes
  66 07999999999 - on retransmit timeout  999999999 - window updates
  67 08999999999 - by keepalive           999999999 - urgent data only
  68 09999999999 - from listen queue      999999999 - control
  69 10                                   999999999 - resends by PMTU discovery
  70 11          TCP Timers               999999999 total packets received
  71 12999999999 potential rtt updates    999999999 - in sequence
  72 13999999999 - successful             999999999 - completely duplicate
  73 14999999999 delayed acks sent        999999999 - with some duplicate data
  74 15999999999 retransmit timeouts      999999999 - out-of-order
  75 16999999999 persist timeouts         999999999 - duplicate acks
  76 17999999999 keepalive probes         999999999 - acks
  77 18999999999 - timeouts               999999999 - window probes
  78 19                                   999999999 - window updates
  79 --0123456789012345678901234567890123456789012345678901234567890123456789012345
  80 --0         1         2         3         4         5         6         7
  81 */
  82
  83 WINDOW *
  84 opentcp(void)
  85 {
  86         return (subwin(stdscr, LINES-5-1, 0, 5, 0));
  87 }
  88
  89 void
  90 closetcp(WINDOW *w)
  91 {
  92         if (w == NULL)
  93                 return;
  94         wclear(w);
  95         wrefresh(w);
  96         delwin(w);
  97 }
  98
  99 void
 100 labeltcp(void)
 101 {
 102         wmove(wnd, 0, 0); wclrtoeol(wnd);
 103 #define L(row, str) mvwprintw(wnd, row, 10, str)
 104 #define R(row, str) mvwprintw(wnd, row, 45, str);
 105         L(1, "TCP Connections");                R(1, "TCP Packets");
 106         L(2, "connections initiated");          R(2, "total packets sent");
 107         L(3, "connections accepted");           R(3, "- data");
 108         L(4, "connections established");        R(4, "- data (retransmit)");
 109         L(5, "connections dropped");            R(5, "- ack-only");
 110         L(6, "- in embryonic state");           R(6, "- window probes");
 111         L(7, "- on retransmit timeout");        R(7, "- window updates");
 112         L(8, "- by keepalive");                 R(8, "- urgent data only");
 113         L(9, "- from listen queue");            R(9, "- control");
 114         R(10, "- resends by PMTU discovery");
 115         L(11, "TCP Timers");            R(11, "total packets received");
 116         L(12, "potential rtt updates");         R(12, "- in sequence");
 117         L(13, "- successful");          R(13, "- completely duplicate");
 118         L(14, "delayed acks sent");     R(14, "- with some duplicate data");
 119         L(15, "retransmit timeouts");   R(15, "- out-of-order");
 120         L(16, "persist timeouts");      R(16, "- duplicate acks");
 121         L(17, "keepalive probes");      R(17, "- acks");
 122         L(18, "- timeouts");            R(18, "- window probes");
 123         R(19, "- window updates");
 124 #undef L
 125 #undef R
 126 }
 127
 128 static void
 129 domode(struct tcp_stats *ret)
 130 {
 131         const struct tcp_stats *sub;
 132         double divisor = 1.0;
 133
 134         switch(currentmode) {
 135         case display_RATE:
 136                 sub = &oldstat;
 137                 divisor = naptime;
 138                 break;
 139         case display_DELTA:
 140                 sub = &oldstat;
 141                 break;
 142         case display_SINCE:
 143                 sub = &initstat;
 144                 break;
 145         default:
 146                 *ret = curstat;
 147                 return;
 148         }
 149 #define DO(stat) ret->stat = (double)(curstat.stat - sub->stat) / divisor
 150         DO(tcps_connattempt);
 151         DO(tcps_accepts);
 152         DO(tcps_connects);
 153         DO(tcps_drops);
 154         DO(tcps_conndrops);
 155         DO(tcps_closed);
 156         DO(tcps_segstimed);
 157         DO(tcps_rttupdated);
 158         DO(tcps_delack);
 159         DO(tcps_timeoutdrop);
 160         DO(tcps_rexmttimeo);
 161         DO(tcps_persisttimeo);
 162         DO(tcps_keeptimeo);
 163         DO(tcps_keepprobe);
 164         DO(tcps_keepdrops);
 165
 166         DO(tcps_sndtotal);
 167         DO(tcps_sndpack);
 168         DO(tcps_sndbyte);
 169         DO(tcps_sndrexmitpack);
 170         DO(tcps_sndrexmitbyte);
 171         DO(tcps_sndacks);
 172         DO(tcps_sndprobe);
 173         DO(tcps_sndurg);
 174         DO(tcps_sndwinup);
 175         DO(tcps_sndctrl);
 176
 177         DO(tcps_rcvtotal);
 178         DO(tcps_rcvpack);
 179         DO(tcps_rcvbyte);
 180         DO(tcps_rcvbadsum);
 181         DO(tcps_rcvbadoff);
 182         DO(tcps_rcvshort);
 183         DO(tcps_rcvduppack);
 184         DO(tcps_rcvdupbyte);
 185         DO(tcps_rcvpartduppack);
 186         DO(tcps_rcvpartdupbyte);
 187         DO(tcps_rcvoopack);
 188         DO(tcps_rcvoobyte);
 189         DO(tcps_rcvpackafterwin);
 190         DO(tcps_rcvbyteafterwin);
 191         DO(tcps_rcvafterclose);
 192         DO(tcps_rcvwinprobe);
 193         DO(tcps_rcvdupack);
 194         DO(tcps_rcvacktoomuch);
 195         DO(tcps_rcvackpack);
 196         DO(tcps_rcvackbyte);
 197         DO(tcps_rcvwinupd);
 198         DO(tcps_pawsdrop);
 199         DO(tcps_predack);
 200         DO(tcps_preddat);
 201         DO(tcps_pcbcachemiss);
 202         DO(tcps_cachedrtt);
 203         DO(tcps_cachedrttvar);
 204         DO(tcps_cachedssthresh);
 205         DO(tcps_usedrtt);
 206         DO(tcps_usedrttvar);
 207         DO(tcps_usedssthresh);
 208         DO(tcps_persistdrop);
 209         DO(tcps_badsyn);
 210         DO(tcps_mturesent);
 211         DO(tcps_listendrop);
 212 #undef DO
 213 }
 214
 215 void
 216 showtcp(void)
 217 {
 218         struct tcp_stats stats;
 219
 220         memset(&stats, 0, sizeof stats);
 221         domode(&stats);
 222
 223 #define DO(stat, row, col) \
 224         mvwprintw(wnd, row, col, "%9lu", stats.stat)
 225 #define L(row, stat) DO(stat, row, 0)
 226 #define R(row, stat) DO(stat, row, 35)
 227         L(2, tcps_connattempt);         R(2, tcps_sndtotal);
 228         L(3, tcps_accepts);             R(3, tcps_sndpack);
 229         L(4, tcps_connects);            R(4, tcps_sndrexmitpack);
 230         L(5, tcps_drops);               R(5, tcps_sndacks);
 231         L(6, tcps_conndrops);           R(6, tcps_sndprobe);
 232         L(7, tcps_timeoutdrop);         R(7, tcps_sndwinup);
 233         L(8, tcps_keepdrops);           R(8, tcps_sndurg);
 234         L(9, tcps_listendrop);          R(9, tcps_sndctrl);
 235         R(10, tcps_mturesent);
 236         R(11, tcps_rcvtotal);
 237         L(12, tcps_segstimed);          R(12, tcps_rcvpack);
 238         L(13, tcps_rttupdated);         R(13, tcps_rcvduppack);
 239         L(14, tcps_delack);             R(14, tcps_rcvpartduppack);
 240         L(15, tcps_rexmttimeo);         R(15, tcps_rcvoopack);
 241         L(16, tcps_persisttimeo);       R(16, tcps_rcvdupack);
 242         L(17, tcps_keepprobe);          R(17, tcps_rcvackpack);
 243         L(18, tcps_keeptimeo);          R(18, tcps_rcvwinprobe);
 244         R(19, tcps_rcvwinupd);
 245 #undef DO
 246 #undef L
 247 #undef R
 248 }
 249
 250 #define CPU_STATS_FUNC(proto,type)                            \
 251 static void                                                   \
 252 proto ##_stats_agg(type *ary, type *ttl, int cpucnt)          \
 253 {                                                             \
 254     int i, off, siz;                                          \
 255     siz = sizeof(type);                                       \
 256                                                               \
 257     if (!ary && !ttl)                                         \
 258         return;                                               \
 259                                                               \
 260     bzero(ttl, siz);                                          \
 261     if (cpucnt == 1) {                                        \
 262         *ttl = ary[0];                                        \
 263     } else {                                                  \
 264         for (i = 0; i < cpucnt; ++i) {                        \
 265             for (off = 0; off < siz; off += sizeof(u_long)) { \
 266                 *(u_long *)((char *)(*(&ttl)) + off) +=       \
 267                 *(u_long *)((char *)&ary[i] + off);           \
 268             }                                                 \
 269         }                                                     \
 270     }                                                         \
 271 }
 272 CPU_STATS_FUNC(tcp, struct tcp_stats);
 273
 274 static int
 275 fetch_tcpstats(struct tcp_stats *st)
 276 {
 277         struct tcp_stats stattmp[SMP_MAXCPU];
 278         size_t len;
 279         int name[4], cpucnt;
 280
 281         name[0] = CTL_NET;
 282         name[1] = PF_INET;
 283         name[2] = IPPROTO_TCP;
 284         name[3] = TCPCTL_STATS;
 285
 286         len = sizeof(struct tcp_stats) * SMP_MAXCPU;
 287         if (sysctl(name, 4, stattmp, &len, NULL, 0) < 0) {
 288                 error("sysctl getting tcp_stats failed");
 289                 return -1;
 290         }
 291         cpucnt = len / sizeof(struct tcp_stats);
 292         tcp_stats_agg(stattmp, st, cpucnt);
 293
 294         return 0;
 295 }
 296
 297 int
 298 inittcp(void)
 299 {
 300         fetch_tcpstats(&initstat);
 301         oldstat = initstat;
 302         curstat = initstat;
 303         return 1;
 304 }
 305
 306 void
 307 resettcp(void)
 308 {
 309         fetch_tcpstats(&initstat);
 310         oldstat = initstat;
 311 }
 312
 313 void
 314 fetchtcp(void)
 315 {
 316         oldstat = curstat;
 317         fetch_tcpstats(&curstat);
 318 }