1 /* $NetBSD: vtw.c,v 1.13 2022/09/01 10:10:20 msaitoh Exp $ */
2
3 /*
4 * Copyright (c) 2011 The NetBSD Foundation, Inc.
5 * All rights reserved.
6 *
7 * This code is derived from software contributed to The NetBSD Foundation
8 * by Coyote Point Systems, Inc.
9 *
10 * Redistribution and use in source and binary forms, with or without
11 * modification, are permitted provided that the following conditions
12 * are met:
13 * 1. Redistributions of source code must retain the above copyright
14 * notice, this list of conditions and the following disclaimer.
15 * 2. Redistributions in binary form must reproduce the above copyright
16 * notice, this list of conditions and the following disclaimer in the
17 * documentation and/or other materials provided with the distribution.
18 *
19 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
20 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
21 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
22 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
23 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
24 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
25 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
26 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
27 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
28 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29 * POSSIBILITY OF SUCH DAMAGE.
30 */
31 /*
32 * Copyright (c) 1983, 1988, 1993
33 * The Regents of the University of California. All rights reserved.
34 *
35 * Redistribution and use in source and binary forms, with or without
36 * modification, are permitted provided that the following conditions
37 * are met:
38 * 1. Redistributions of source code must retain the above copyright
39 * notice, this list of conditions and the following disclaimer.
40 * 2. Redistributions in binary form must reproduce the above copyright
41 * notice, this list of conditions and the following disclaimer in the
42 * documentation and/or other materials provided with the distribution.
43 * 3. Neither the name of the University nor the names of its contributors
44 * may be used to endorse or promote products derived from this software
45 * without specific prior written permission.
46 *
47 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
48 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
49 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
50 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
51 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
52 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
53 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
54 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
55 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
56 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
57 * SUCH DAMAGE.
58 */
59
60 #include <sys/cdefs.h>
61 #ifndef lint
62 #if 0
63 static char sccsid[] = "from: @(#)inet.c 8.4 (Berkeley) 4/20/94";
64 #else
65 __RCSID("$NetBSD: vtw.c,v 1.13 2022/09/01 10:10:20 msaitoh Exp $");
66 #endif
67 #endif /* not lint */
68
69 #define _CALLOUT_PRIVATE /* for defs in sys/callout.h */
70
71 #include <sys/param.h>
72 #include <sys/queue.h>
73 #include <sys/socket.h>
74 #include <sys/socketvar.h>
75 #include <sys/mbuf.h>
76 #include <sys/protosw.h>
77 #include <sys/sysctl.h>
78
79 #include <net/if_arp.h>
80 #include <net/route.h>
81 #include <netinet/in.h>
82 #include <netinet/in_systm.h>
83 #include <netinet/ip.h>
84 #include <netinet/in_pcb.h>
85 #include <netinet/ip_icmp.h>
86
87 #ifdef INET6
88 #include <netinet/ip6.h>
89 #endif
90
91 #include <netinet/icmp_var.h>
92 #include <netinet/igmp_var.h>
93 #include <netinet/ip_var.h>
94 #include <netinet/pim_var.h>
95 #include <netinet/tcp.h>
96 #include <netinet/tcp_seq.h>
97 #include <netinet/tcp_fsm.h>
98 #include <netinet/tcp_timer.h>
99 #include <netinet/tcp_var.h>
100 #include <netinet/tcp_debug.h>
101 #include <netinet/udp.h>
102 #include <netinet/ip_carp.h>
103 #include <netinet/udp_var.h>
104 #include <netinet/tcp_vtw.h>
105
106 #include <arpa/inet.h>
107 #include <kvm.h>
108 #include <netdb.h>
109 #include <stdio.h>
110 #include <string.h>
111 #include <unistd.h>
112 #include <stdlib.h>
113 #include <err.h>
114 #include "netstat.h"
115 #include "vtw.h"
116 #include "prog_ops.h"
117
118 static bool vtw_enabled(void);
119 static void snarf(const void *, void *, size_t);
120 static void *lookup(const char *);
121 static void process_vtw(const vtw_ctl_t *, void (*)(const vtw_t *));
122
123 static bool
vtw_enabled(void)124 vtw_enabled(void)
125 {
126
127 if (use_sysctl) {
128 int enabled;
129 size_t size = sizeof(enabled);
130
131 if (prog_sysctlbyname("net.inet.tcp.vtw.enable",
132 &enabled, &size, NULL, 0) == -1)
133 return true;
134 return enabled ? true : false;
135 } else
136 return true;
137 }
138
139 static void
snarf(const void * addr,void * buf,size_t len)140 snarf(const void *addr, void *buf, size_t len)
141 {
142 size_t cc;
143
144 memset(buf, 0, len);
145
146 cc = kvm_read(get_kvmd(), (unsigned long) addr, buf, len);
147
148 if (cc != len) {
149 warnx("%s: short read at %p, len %zx cc %zx", __func__, addr,
150 len, cc);
151 }
152 }
153
154 static void *
lookup(const char * name)155 lookup(const char *name)
156 {
157 kvm_t *k;
158 struct nlist nl[2];
159
160 nl[0].n_name = name;
161 nl[0].n_value = 0;
162 nl[1].n_name = NULL;
163
164 if ((k = get_kvmd()) == NULL) {
165 if (Vflag)
166 errx(EXIT_FAILURE, "kvm not available");
167 return NULL;
168 }
169 switch (kvm_nlist(k, &nl[0])) {
170 case -1:
171 err(EXIT_FAILURE, "kvm_nlist");
172 break;
173
174 case 0:
175 return (void *)nl[0].n_value;
176
177 default:
178 if (Vflag)
179 errx(EXIT_FAILURE, "%s missing in symbol table", name);
180 break;
181 }
182
183 return NULL;
184 }
185
186 void
timebase(struct timeval * tv)187 timebase(struct timeval *tv)
188 {
189 void *p;
190 struct bintime timebasebin;
191
192 if (!vtw_enabled()) {
193 memset(tv, 0, sizeof(*tv));
194 return;
195 }
196
197 p = lookup("timebasebin");
198 if (!p)
199 return;
200 snarf(p, &timebasebin, sizeof(timebasebin));
201 bintime2timeval(&timebasebin, tv);
202 }
203
204 static void
process_vtw(const vtw_ctl_t * ctl,void (* print)(const vtw_t *))205 process_vtw(const vtw_ctl_t * ctl, void (*print)(const vtw_t *))
206 {
207 vtw_t *vp;
208
209 for (vp = ctl->base.v; vp && vp <= ctl->lim.v;) {
210
211 (*print)(vp);
212
213 if (ctl->is_v4) {
214 vtw_v4_t *v4 = (vtw_v4_t *)vp;
215
216 vp = &(++v4)->common;
217 } else if (ctl->is_v6) {
218 vtw_v6_t *v6 = (vtw_v6_t *)vp;
219
220 vp = &(++v6)->common;
221 }
222 }
223 }
224
225 void
show_vtw_stats(void)226 show_vtw_stats(void)
227 {
228 vtw_stats_t stats;
229 void *p;
230
231 if (!Vflag)
232 return;
233
234 if (!vtw_enabled())
235 return;
236
237 if ((p = lookup("vtw_stats")) == NULL)
238 return;
239 snarf(p, &stats, sizeof(stats));
240
241 printf("\t\t%" PRIu64 " inserts\n", stats.ins);
242 printf("\t\t%" PRIu64 " deletes\n", stats.del);
243 printf("\t\t%" PRIu64 " assassinations\n", stats.kill);
244 printf("\tvestigial time-wait lookup_connect\n");
245 printf("\t\t%" PRIu64 " look\n", stats.look[0]);
246 printf("\t\t%" PRIu64 " hit\n", stats.hit[0]);
247 printf("\t\t%" PRIu64 " miss\n", stats.miss[0]);
248 printf("\t\t%" PRIu64 " probe\n", stats.probe[0]);
249 printf("\t\t%" PRIu64 " losing\n", stats.losing[0]);
250 printf("\t\t%" PRIu64 " max_chain\n", stats.max_chain[0]);
251 printf("\t\t%" PRIu64 " max_probe\n", stats.max_probe[0]);
252 printf("\t\t%" PRIu64 " max_loss\n", stats.max_loss[0]);
253 printf("\tvestigial time-wait lookup_port\n");
254 printf("\t\t%" PRIu64 " look\n", stats.look[1]);
255 printf("\t\t%" PRIu64 " hit\n", stats.hit[1]);
256 printf("\t\t%" PRIu64 " miss\n", stats.miss[1]);
257 printf("\t\t%" PRIu64 " probe\n", stats.probe[1]);
258 printf("\t\t%" PRIu64 " losing\n", stats.losing[1]);
259 printf("\t\t%" PRIu64 " max_chain\n", stats.max_chain[1]);
260 printf("\t\t%" PRIu64 " max_probe\n", stats.max_probe[1]);
261 printf("\t\t%" PRIu64 " max_loss\n", stats.max_loss[1]);
262 }
263
264 void
show_vtw_v4(void (* print)(const vtw_t *))265 show_vtw_v4(void (*print)(const vtw_t *))
266 {
267 fatp_t *base, *lim;
268 fatp_t **hash, **port;
269 size_t n;
270 fatp_ctl_t fat_tcpv4;
271 vtw_ctl_t vtw_tcpv4[VTW_NCLASS];
272 int i;
273 int mem = 0;
274 void *p;
275
276 if (!vtw_enabled())
277 return;
278
279 if ((p = lookup("fat_tcpv4")) == NULL)
280 return;
281 snarf(p, &fat_tcpv4, sizeof(fat_tcpv4));
282
283 if ((p = lookup("vtw_tcpv4")) == NULL)
284 return;
285 snarf(p, &vtw_tcpv4[0], sizeof(vtw_tcpv4));
286
287 mem += sizeof(fat_tcpv4);
288 mem += sizeof(vtw_tcpv4);
289
290 /* snarf/adjust vtw_ctl */
291 for (i = 0; i < VTW_NCLASS; ++i) {
292 vtw_v4_t *kbase, *klim;
293 vtw_v4_t *ubase;
294 ptrdiff_t delta;
295
296 kbase = vtw_tcpv4[i].base.v4;
297 klim = vtw_tcpv4[i].lim.v4;
298
299 if (!kbase || !klim)
300 continue;
301
302 n = (klim - kbase + 1);
303
304 if (!i) {
305 ubase = NULL;
306 if (reallocarr(&ubase, n, sizeof(*kbase)) != 0)
307 err(EXIT_FAILURE, "reallocarr");
308 snarf(kbase, ubase, n * sizeof(*ubase));
309
310 mem += n * sizeof(*ubase);
311 } else
312 ubase = vtw_tcpv4[0].base.v4;
313
314 delta = ubase - kbase;
315
316 vtw_tcpv4[i].base.v4 += delta;
317 vtw_tcpv4[i].lim.v4 += delta;
318 vtw_tcpv4[i].alloc.v4 += delta;
319 vtw_tcpv4[i].fat = &fat_tcpv4;
320
321 if (vtw_tcpv4[i].oldest.v4)
322 vtw_tcpv4[i].oldest.v4 += delta;
323 }
324
325 /* snarf/adjust fat_ctl */
326
327 base = fat_tcpv4.base;
328 lim = fat_tcpv4.lim;
329
330 if (!base || !lim)
331 goto end;
332
333 mem += (lim - base + 1) * sizeof(*base);
334
335 fat_tcpv4.base = NULL;
336 if (reallocarr(&fat_tcpv4.base, lim - base + 1, sizeof(*base)) != 0)
337 err(EXIT_FAILURE, "reallocarr");
338 fat_tcpv4.lim = fat_tcpv4.base + (lim - base);
339
340 snarf(base, fat_tcpv4.base, sizeof(*base) * (lim - base + 1));
341
342 fat_tcpv4.vtw = &vtw_tcpv4[0];
343 fat_tcpv4.free = fat_tcpv4.base + (fat_tcpv4.free - base);
344
345 n = fat_tcpv4.mask + 1;
346 hash = fat_tcpv4.hash;
347 port = fat_tcpv4.port;
348
349 fat_tcpv4.hash = NULL;
350 if (reallocarr(&fat_tcpv4.hash, n, sizeof(*hash)) != 0)
351 err(EXIT_FAILURE, "reallocarr");
352
353 fat_tcpv4.port = NULL;
354 if (reallocarr(&fat_tcpv4.port, n, sizeof(*port)) != 0)
355 err(EXIT_FAILURE, "reallocarr");
356
357 snarf(hash, fat_tcpv4.hash, n * sizeof(*hash));
358 snarf(port, fat_tcpv4.port, n * sizeof(*port));
359
360 end:
361 process_vtw(&vtw_tcpv4[0], print);
362
363 #if 0
364 if (Vflag && vflag) {
365 printf("total memory for VTW in current config: "
366 "%d bytes %f MB\n",
367 mem, mem / (1024.0 * 1024));
368 }
369 #endif
370 }
371
372 void
show_vtw_v6(void (* print)(const vtw_t *))373 show_vtw_v6(void (*print)(const vtw_t *))
374 {
375 fatp_t *base, *lim;
376 fatp_t **hash, **port;
377 size_t n;
378 fatp_ctl_t fat_tcpv6;
379 vtw_ctl_t vtw_tcpv6[VTW_NCLASS];
380 int i;
381 int mem = 0;
382 void *p;
383
384 if (!vtw_enabled())
385 return;
386
387 if ((p = lookup("fat_tcpv6")) == NULL)
388 return;
389 snarf(p, &fat_tcpv6, sizeof(fat_tcpv6));
390 if ((p = lookup("vtw_tcpv6")) == NULL)
391 return;
392 snarf(p, &vtw_tcpv6[0], sizeof(vtw_tcpv6));
393
394 mem += sizeof(fat_tcpv6);
395 mem += sizeof(vtw_tcpv6);
396
397 for (i = 0; i < VTW_NCLASS; ++i) {
398 vtw_v6_t *kbase, *klim;
399 vtw_v6_t *ubase;
400 ptrdiff_t delta;
401
402 kbase = vtw_tcpv6[i].base.v6;
403 klim = vtw_tcpv6[i].lim.v6;
404
405 if (!kbase || !klim)
406 continue;
407
408 n = (klim - kbase + 1);
409
410 if (!i) {
411 ubase = NULL;
412 if (reallocarr(&ubase, n, sizeof(*kbase)) != 0)
413 err(EXIT_FAILURE, "reallocarr");
414
415 snarf(kbase, ubase, n * sizeof(*ubase));
416
417 mem += n * sizeof(*ubase);
418 } else
419 ubase = vtw_tcpv6[0].base.v6;
420
421 delta = ubase - kbase;
422
423 vtw_tcpv6[i].base.v6 += delta;
424 vtw_tcpv6[i].lim.v6 += delta;
425 vtw_tcpv6[i].alloc.v6 += delta;
426 vtw_tcpv6[i].fat = &fat_tcpv6;
427
428 if (vtw_tcpv6[i].oldest.v6)
429 vtw_tcpv6[i].oldest.v6 += delta;
430 }
431
432 base = fat_tcpv6.base;
433 lim = fat_tcpv6.lim;
434
435 if (!base || !lim)
436 goto end;
437
438 mem += (lim - base + 1) * sizeof(*base);
439
440 fat_tcpv6.base = NULL;
441 if (reallocarr(&fat_tcpv6.base, lim - base + 1, sizeof(*base)) != 0)
442 err(EXIT_FAILURE, "reallocarr");
443
444 fat_tcpv6.lim = fat_tcpv6.base + (lim - base);
445
446 snarf(base, fat_tcpv6.base, sizeof(*base) * (lim - base + 1));
447
448 fat_tcpv6.vtw = &vtw_tcpv6[0];
449 fat_tcpv6.free = fat_tcpv6.base + (fat_tcpv6.free - base);
450
451 n = fat_tcpv6.mask + 1;
452 hash = fat_tcpv6.hash;
453 port = fat_tcpv6.port;
454
455 fat_tcpv6.hash = NULL;
456 if (reallocarr(&fat_tcpv6.hash, n, sizeof(*hash)) != 0)
457 err(EXIT_FAILURE, "reallocarr");
458
459 fat_tcpv6.port = NULL;
460 if (reallocarr(&fat_tcpv6.port, n, sizeof(*port)) != 0)
461 err(EXIT_FAILURE, "reallocarr");
462
463 snarf(hash, fat_tcpv6.hash, n * sizeof(*hash));
464 snarf(port, fat_tcpv6.port, n * sizeof(*port));
465
466 end:
467
468 process_vtw(&vtw_tcpv6[0], print);
469 #if 0
470 if (Vflag && vflag) {
471 printf("total memory for VTW in current config: "
472 "%d bytes %f MB\n",
473 mem, mem / (1024.0 * 1024));
474 }
475 #endif
476 }
477