xref: /freebsd/sys/netinet/tcp_var.h (revision e1c4c8dd8d2d10b6104f06856a77bd5b4813a801)
1 /*-
2  * SPDX-License-Identifier: BSD-3-Clause
3  *
4  * Copyright (c) 1982, 1986, 1993, 1994, 1995
5  *	The Regents of the University of California.  All rights reserved.
6  *
7  * Redistribution and use in source and binary forms, with or without
8  * modification, are permitted provided that the following conditions
9  * are met:
10  * 1. Redistributions of source code must retain the above copyright
11  *    notice, this list of conditions and the following disclaimer.
12  * 2. Redistributions in binary form must reproduce the above copyright
13  *    notice, this list of conditions and the following disclaimer in the
14  *    documentation and/or other materials provided with the distribution.
15  * 3. Neither the name of the University nor the names of its contributors
16  *    may be used to endorse or promote products derived from this software
17  *    without specific prior written permission.
18  *
19  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
20  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
21  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
22  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
23  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
24  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
25  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
26  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
28  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
29  * SUCH DAMAGE.
30  */
31 
32 #ifndef _NETINET_TCP_VAR_H_
33 #define _NETINET_TCP_VAR_H_
34 
35 #include <netinet/tcp.h>
36 #include <netinet/tcp_fsm.h>
37 
38 #ifdef _KERNEL
39 #include <net/vnet.h>
40 #include <sys/mbuf.h>
41 #include <sys/ktls.h>
42 #endif
43 
44 #define TCP_END_BYTE_INFO 8	/* Bytes that makeup the "end information array" */
45 /* Types of ending byte info */
46 #define TCP_EI_EMPTY_SLOT	0
47 #define TCP_EI_STATUS_CLIENT_FIN	0x1
48 #define TCP_EI_STATUS_CLIENT_RST	0x2
49 #define TCP_EI_STATUS_SERVER_FIN	0x3
50 #define TCP_EI_STATUS_SERVER_RST	0x4
51 #define TCP_EI_STATUS_RETRAN		0x5
52 #define TCP_EI_STATUS_PROGRESS		0x6
53 #define TCP_EI_STATUS_PERSIST_MAX	0x7
54 #define TCP_EI_STATUS_KEEP_MAX		0x8
55 #define TCP_EI_STATUS_DATA_A_CLOSE	0x9
56 #define TCP_EI_STATUS_RST_IN_FRONT	0xa
57 #define TCP_EI_STATUS_2MSL		0xb
58 #define TCP_EI_STATUS_MAX_VALUE		0xb
59 
60 #define TCP_TRK_REQ_LOG_NEW		0x01
61 #define TCP_TRK_REQ_LOG_COMPLETE	0x02
62 #define TCP_TRK_REQ_LOG_FREED		0x03
63 #define TCP_TRK_REQ_LOG_ALLOCFAIL	0x04
64 #define TCP_TRK_REQ_LOG_MOREYET	0x05
65 #define TCP_TRK_REQ_LOG_FORCEFREE	0x06
66 #define TCP_TRK_REQ_LOG_STALE		0x07
67 #define TCP_TRK_REQ_LOG_SEARCH		0x08
68 
69 /************************************************/
70 /* Status bits we track to assure no duplicates,
71  * the bits here are not used by the code but
72  * for human representation. To check a bit we
73  * take and shift over by 1 minus the value (1-8).
74  */
75 /************************************************/
76 #define TCP_EI_BITS_CLIENT_FIN	0x001
77 #define TCP_EI_BITS_CLIENT_RST	0x002
78 #define TCP_EI_BITS_SERVER_FIN	0x004
79 #define TCP_EI_BITS_SERVER_RST	0x008
80 #define TCP_EI_BITS_RETRAN	0x010
81 #define TCP_EI_BITS_PROGRESS	0x020
82 #define TCP_EI_BITS_PRESIST_MAX	0x040
83 #define TCP_EI_BITS_KEEP_MAX	0x080
84 #define TCP_EI_BITS_DATA_A_CLO  0x100
85 #define TCP_EI_BITS_RST_IN_FR	0x200	/* a front state reset */
86 #define TCP_EI_BITS_2MS_TIMER	0x400	/* 2 MSL timer expired */
87 
88 #if defined(_KERNEL) || defined(_WANT_TCPCB)
89 #include <sys/_callout.h>
90 #include <sys/osd.h>
91 
92 #include <netinet/cc/cc.h>
93 
94 /* TCP segment queue entry */
95 struct tseg_qent {
96 	TAILQ_ENTRY(tseg_qent) tqe_q;
97 	struct	mbuf   *tqe_m;		/* mbuf contains packet */
98 	struct  mbuf   *tqe_last;	/* last mbuf in chain */
99 	tcp_seq tqe_start;		/* TCP Sequence number start */
100 	int	tqe_len;		/* TCP segment data length */
101 	uint32_t tqe_flags;		/* The flags from tcp_get_flags() */
102 	uint32_t tqe_mbuf_cnt;		/* Count of mbuf overhead */
103 };
104 TAILQ_HEAD(tsegqe_head, tseg_qent);
105 
106 struct sackblk {
107 	tcp_seq start;		/* start seq no. of sack block */
108 	tcp_seq end;		/* end seq no. */
109 };
110 
111 struct sackhole {
112 	tcp_seq start;		/* start seq no. of hole */
113 	tcp_seq end;		/* end seq no. */
114 	tcp_seq rxmit;		/* next seq. no in hole to be retransmitted */
115 	TAILQ_ENTRY(sackhole) scblink;	/* scoreboard linkage */
116 };
117 
118 struct sackhint {
119 	struct sackhole	*nexthole;
120 	int32_t		sack_bytes_rexmit;
121 	tcp_seq		last_sack_ack;	/* Most recent/largest sacked ack */
122 
123 	int32_t		delivered_data; /* Newly acked data from last SACK */
124 
125 	int32_t		sacked_bytes;	/* Total sacked bytes reported by the
126 					 * receiver via sack option
127 					 */
128 	uint32_t	recover_fs;	/* Flight Size at the start of Loss recovery */
129 	uint32_t	prr_delivered;	/* Total bytes delivered using PRR */
130 	uint32_t	prr_out;	/* Bytes sent during IN_RECOVERY */
131 	int32_t		hole_bytes;	/* current number of bytes in scoreboard holes */
132 	int32_t		lost_bytes;	/* number of rfc6675 IsLost() bytes */
133 };
134 
135 #define SEGQ_EMPTY(tp) TAILQ_EMPTY(&(tp)->t_segq)
136 
137 STAILQ_HEAD(tcp_log_stailq, tcp_log_mem);
138 
139 #define TCP_TRK_TRACK_FLG_EMPTY 0x00	/* Available */
140 #define TCP_TRK_TRACK_FLG_USED  0x01	/* In use */
141 #define TCP_TRK_TRACK_FLG_OPEN  0x02	/* End is not valid (open range request) */
142 #define TCP_TRK_TRACK_FLG_SEQV  0x04	/* We had a sendfile that touched it  */
143 #define TCP_TRK_TRACK_FLG_COMP  0x08	/* Sendfile as placed the last bits (range req only) */
144 #define TCP_TRK_TRACK_FLG_FSND	0x10	/* First send has been done into the seq space */
145 #define TCP_TRK_TRACK_FLG_LSND	0x20	/* We were able to set the Last Sent */
146 #define MAX_TCP_TRK_REQ 5		/* Max we will have at once */
147 
148 struct tcp_sendfile_track {
149 	uint64_t timestamp;	/* User sent timestamp */
150 	uint64_t start;		/* Start of sendfile offset */
151 	uint64_t end;		/* End if not open-range req */
152 	uint64_t localtime;	/* Time we actually got the req */
153 	uint64_t deadline;	/* If in CU mode, deadline to delivery */
154 	uint64_t first_send;	/* Time of first send in the range */
155 	uint64_t cspr;		/* Client suggested pace rate */
156 	uint64_t sent_at_fs;	/* What was t_sndbytes as we begun sending */
157 	uint64_t rxt_at_fs;	/* What was t_snd_rxt_bytes as we begun sending */
158 	uint64_t sent_at_ls;	/* Sent value at the last send */
159 	uint64_t rxt_at_ls;	/* Retransmit value at the last send */
160 	tcp_seq start_seq;	/* First TCP Seq assigned */
161 	tcp_seq end_seq;	/* If range req last seq */
162 	uint32_t flags;		/* Type of request open etc */
163 	uint32_t sbcc_at_s;	/* When we allocate what is the sb_cc */
164 	uint32_t hint_maxseg;	/* Client hinted maxseg */
165 	uint32_t playout_ms;	/* Client playout ms */
166 	uint32_t hybrid_flags;	/* Hybrid flags on this request */
167 };
168 
169 
170 /*
171  * Change Query responses for a stack switch we create a structure
172  * that allows query response from the new stack to the old, if
173  * supported.
174  *
175  * There are three queries currently defined.
176  *  - sendmap
177  *  - timers
178  *  - rack_times
179  *
180  * For the sendmap query the caller fills in the
181  * req and the req_param as the first seq (usually
182  * snd_una). When the response comes back indicating
183  * that there was data (return value 1), then the caller
184  * can build a sendmap entry based on the range and the
185  * times. The next query would then be done at the
186  * newly created sendmap_end. Repeated until sendmap_end == snd_max.
187  *
188  * Flags in sendmap_flags are defined below as well.
189  *
190  * For timers the standard PACE_TMR_XXXX flags are returned indicating
191  * a pacing timer (possibly) and one other timer. If pacing timer then
192  * the expiration timeout time in microseconds is in timer_pacing_to.
193  * And the value used with whatever timer (if a flag is set) is in
194  * timer_rxt. If no timers are running a 0 is returned and of
195  * course no flags are set in timer_hpts_flags.
196  *
197  * The rack_times are a misc collection of information that
198  * the old stack might possibly fill in. Of course its possible
199  * that an old stack may not have a piece of information. If so
200  * then setting that value to zero is advised. Setting any
201  * timestamp passed should only place a zero in it when it
202  * is unfilled. This may mean that a time is off by a micro-second
203  * but this is ok in the grand scheme of things.
204  *
205  * When switching stacks it is desireable to get as much information
206  * from the old stack to the new stack as possible. Though not always
207  * will the stack be compatible in the types of information. The
208  * init() function needs to take care when it begins changing
209  * things such as inp_flags2 and the timer units to position these
210  * changes at a point where it is unlikely they will fail after
211  * making such changes. A stack optionally can have an "undo"
212  * function
213  *
214  * To transfer information to the old stack from the new in
215  * respect to LRO and the inp_flags2, the new stack should set
216  * the inp_flags2 to what it supports. The old stack in its
217  * fini() function should call the tcp_handle_orphaned_packets()
218  * to clean up any packets. Note that a new stack should attempt
219  */
220 
221 /* Query types */
222 #define TCP_QUERY_SENDMAP	1
223 #define TCP_QUERY_TIMERS_UP	2
224 #define TCP_QUERY_RACK_TIMES	3
225 
226 /* Flags returned in sendmap_flags */
227 #define SNDMAP_ACKED		0x000001/* The remote endpoint acked this */
228 #define SNDMAP_OVERMAX		0x000008/* We have more retran's then we can fit */
229 #define SNDMAP_SACK_PASSED	0x000010/* A sack was done above this block */
230 #define SNDMAP_HAS_FIN		0x000040/* segment is sent with fin */
231 #define SNDMAP_TLP		0x000080/* segment sent as tail-loss-probe */
232 #define SNDMAP_HAS_SYN		0x000800/* SYN is on this guy */
233 #define SNDMAP_HAD_PUSH		0x008000/* Push was sent on original send */
234 #define SNDMAP_MASK  (SNDMAP_ACKED|SNDMAP_OVERMAX|SNDMAP_SACK_PASSED|SNDMAP_HAS_FIN\
235 		      |SNDMAP_TLP|SNDMAP_HAS_SYN|SNDMAP_HAD_PUSH)
236 #define SNDMAP_NRTX 3
237 
238 struct tcp_query_resp {
239 	int req;
240 	uint32_t req_param;
241 	union {
242 		struct {
243 			tcp_seq sendmap_start;
244 			tcp_seq sendmap_end;
245 			int sendmap_send_cnt;
246 			uint64_t sendmap_time[SNDMAP_NRTX];
247 			uint64_t sendmap_ack_arrival;
248 			int sendmap_flags;
249 			uint32_t sendmap_r_rtr_bytes;
250 			/* If FAS is available if not 0 */
251 			uint32_t sendmap_fas;
252 			uint8_t sendmap_dupacks;
253 		};
254 		struct {
255 			uint32_t timer_hpts_flags;
256 			uint32_t timer_pacing_to;
257 			uint32_t timer_timer_exp;
258 		};
259 		struct {
260 			/* Timestamps and rtt's */
261 			uint32_t rack_reorder_ts;	/* Last uscts that reordering was seen */
262 			uint32_t rack_num_dsacks;	/* Num of dsacks seen */
263 			uint32_t rack_rxt_last_time; 	/* Last time a RXT/TLP or rack tmr  went off */
264 			uint32_t rack_min_rtt;		/* never 0 smallest rtt seen */
265 			uint32_t rack_rtt;		/* Last rtt used by rack */
266 			uint32_t rack_tmit_time;	/* The time the rtt seg was tmited */
267 			uint32_t rack_time_went_idle;	/* If in persist the time we went idle */
268 			/* Prr data  */
269 			uint32_t rack_sacked;
270 			uint32_t rack_holes_rxt;
271 			uint32_t rack_prr_delivered;
272 			uint32_t rack_prr_recovery_fs;
273 			uint32_t rack_prr_out;
274 			uint32_t rack_prr_sndcnt;
275 			/* TLP data */
276 			uint16_t rack_tlp_cnt_out;	/* How many tlp's have been sent */
277 			/* Various bits */
278 			uint8_t  rack_tlp_out;		/* Is a TLP outstanding */
279 			uint8_t  rack_srtt_measured;	/* The previous stack has measured srtt */
280 			uint8_t  rack_in_persist;	/* Is the old stack in persists? */
281 			uint8_t	 rack_wanted_output;	/* Did the prevous stack have a want output set */
282 		};
283 	};
284 };
285 
286 #define TCP_TMR_GRANULARITY_TICKS	1	/* TCP timers are in ticks (msec if hz=1000)  */
287 #define TCP_TMR_GRANULARITY_USEC	2	/* TCP timers are in microseconds */
288 
289 typedef enum {
290 	TT_REXMT = 0,
291 	TT_PERSIST,
292 	TT_KEEP,
293 	TT_2MSL,
294 	TT_DELACK,
295 	TT_N,
296 } tt_which;
297 
298 typedef enum {
299 	TT_PROCESSING = 0,
300 	TT_PROCESSED,
301 	TT_STARTING,
302 	TT_STOPPING,
303 } tt_what;
304 
305 /*
306  * Tcp control block, one per tcp connection.
307  */
308 struct tcpcb {
309 	struct inpcb t_inpcb;		/* embedded protocol independent cb */
310 #define	t_start_zero	t_fb
311 #define	t_zero_size	(sizeof(struct tcpcb) - \
312 			    offsetof(struct tcpcb, t_start_zero))
313 	struct tcp_function_block *t_fb;/* TCP function call block */
314 	void	*t_fb_ptr;		/* Pointer to t_fb specific data */
315 
316 	struct callout t_callout;
317 	sbintime_t t_timers[TT_N];
318 	sbintime_t t_precisions[TT_N];
319 
320 	/* HPTS. Used by BBR and Rack stacks. See tcp_hpts.c for more info. */
321 	TAILQ_ENTRY(tcpcb)	t_hpts;		/* linkage to HPTS ring */
322 	STAILQ_HEAD(, mbuf)	t_inqueue;	/* HPTS input packets queue */
323 	uint32_t t_hpts_request;	/* Current hpts request, zero if
324 					 * fits in the pacing window. */
325 	uint32_t t_hpts_slot;		/* HPTS wheel slot this tcb is. */
326 	uint32_t t_hpts_drop_reas;	/* Reason we are dropping the pcb. */
327 	uint32_t t_hpts_gencnt;
328 	uint16_t t_hpts_cpu;		/* CPU chosen by hpts_cpuid(). */
329 	uint16_t t_lro_cpu;		/* CPU derived from LRO. */
330 #define	HPTS_CPU_NONE	((uint16_t)-1)
331 	enum {
332 		IHPTS_NONE = 0,
333 		IHPTS_ONQUEUE,
334 		IHPTS_MOVING,
335 	} t_in_hpts;			/* Is it linked into HPTS? */
336 
337 	uint32_t t_maxseg:24,		/* maximum segment size */
338 		_t_logstate:8;		/* State of "black box" logging */
339 	uint32_t t_port:16,		/* Tunneling (over udp) port */
340 		t_state:4,		/* state of this connection */
341 		t_idle_reduce : 1,
342 		t_delayed_ack: 7,	/* Delayed ack variable */
343 		t_fin_is_rst: 1,	/* Are fin's treated as resets */
344 		t_log_state_set: 1,
345 		bits_spare : 2;
346 	u_int	t_flags;
347 	tcp_seq	snd_una;		/* sent but unacknowledged */
348 	tcp_seq	snd_max;		/* highest sequence number sent;
349 					 * used to recognize retransmits
350 					 */
351 	tcp_seq snd_nxt;		/* send next */
352 	tcp_seq snd_up;			/* send urgent pointer */
353 	uint32_t snd_wnd;		/* send window */
354 	uint32_t snd_cwnd;		/* congestion-controlled window */
355 	uint32_t ts_offset;		/* our timestamp offset */
356 	uint32_t rfbuf_ts;		/* recv buffer autoscaling timestamp */
357 	int	rcv_numsacks;		/* # distinct sack blks present */
358 	u_int	t_tsomax;		/* TSO total burst length limit */
359 	u_int	t_tsomaxsegcount;	/* TSO maximum segment count */
360 	u_int	t_tsomaxsegsize;	/* TSO maximum segment size in bytes */
361 	tcp_seq	rcv_nxt;		/* receive next */
362 	tcp_seq	rcv_adv;		/* advertised window */
363 	uint32_t rcv_wnd;		/* receive window */
364 	u_int	t_flags2;		/* More tcpcb flags storage */
365 	int	t_srtt;			/* smoothed round-trip time */
366 	int	t_rttvar;		/* variance in round-trip time */
367 	uint32_t ts_recent;		/* timestamp echo data */
368 	u_char	snd_scale;		/* window scaling for send window */
369 	u_char	rcv_scale;		/* window scaling for recv window */
370 	u_char	snd_limited;		/* segments limited transmitted */
371 	u_char	request_r_scale;	/* pending window scaling */
372 	tcp_seq	last_ack_sent;
373 	u_int	t_rcvtime;		/* inactivity time */
374 	tcp_seq	rcv_up;			/* receive urgent pointer */
375 	int	t_segqlen;		/* segment reassembly queue length */
376 	uint32_t t_segqmbuflen;		/* total reassembly queue byte length */
377 	struct	tsegqe_head t_segq;	/* segment reassembly queue */
378 	uint32_t snd_ssthresh;		/* snd_cwnd size threshold for
379 					 * for slow start exponential to
380 					 * linear switch
381 					 */
382 	tcp_seq	snd_wl1;		/* window update seg seq number */
383 	tcp_seq	snd_wl2;		/* window update seg ack number */
384 
385 	tcp_seq	irs;			/* initial receive sequence number */
386 	tcp_seq	iss;			/* initial send sequence number */
387 	u_int	t_acktime;		/* RACK and BBR incoming new data was acked */
388 	u_int	t_sndtime;		/* time last data was sent */
389 	u_int	ts_recent_age;		/* when last updated */
390 	tcp_seq	snd_recover;		/* for use in NewReno Fast Recovery */
391 	char	t_oobflags;		/* have some */
392 	char	t_iobc;			/* input character */
393 	uint8_t t_nic_ktls_xmit:1,	/* active nic ktls xmit sessions */
394 		t_nic_ktls_xmit_dis:1,	/* disabled nic xmit ktls? */
395 		t_nic_ktls_spare:6;	/* spare nic ktls */
396 	int	t_rxtcur;		/* current retransmit value (ticks) */
397 
398 	int	t_rxtshift;		/* log(2) of rexmt exp. backoff */
399 	u_int	t_rtttime;		/* RTT measurement start time */
400 
401 	tcp_seq	t_rtseq;		/* sequence number being timed */
402 	u_int	t_starttime;		/* time connection was established */
403 	u_int	t_fbyte_in;		/* ticks time first byte queued in */
404 	u_int	t_fbyte_out;		/* ticks time first byte queued out */
405 
406 	u_int	t_pmtud_saved_maxseg;	/* pre-blackhole MSS */
407 	int	t_blackhole_enter;	/* when to enter blackhole detection */
408 	int	t_blackhole_exit;	/* when to exit blackhole detection */
409 	u_int	t_rttmin;		/* minimum rtt allowed */
410 
411 	int	t_softerror;		/* possible error not yet reported */
412 	uint32_t max_sndwnd;		/* largest window peer has offered */
413 	uint32_t snd_cwnd_prev;		/* cwnd prior to retransmit */
414 	uint32_t snd_ssthresh_prev;	/* ssthresh prior to retransmit */
415 	tcp_seq	snd_recover_prev;	/* snd_recover prior to retransmit */
416 	int	t_sndzerowin;		/* zero-window updates sent */
417 	int	snd_numholes;		/* number of holes seen by sender */
418 	u_int	t_badrxtwin;		/* window for retransmit recovery */
419 	TAILQ_HEAD(sackhole_head, sackhole) snd_holes;
420 					/* SACK scoreboard (sorted) */
421 	tcp_seq	snd_fack;		/* last seq number(+1) sack'd by rcv'r*/
422 	struct sackblk sackblks[MAX_SACK_BLKS]; /* seq nos. of sack blocks */
423 	struct sackhint	sackhint;	/* SACK scoreboard hint */
424 	int	t_rttlow;		/* smallest observerved RTT */
425 	int	rfbuf_cnt;		/* recv buffer autoscaling byte count */
426 	struct toedev	*tod;		/* toedev handling this connection */
427 	int	t_sndrexmitpack;	/* retransmit packets sent */
428 	int	t_rcvoopack;		/* out-of-order packets received */
429 	void	*t_toe;			/* TOE pcb pointer */
430 	struct cc_algo	*t_cc;		/* congestion control algorithm */
431 	struct cc_var	t_ccv;		/* congestion control specific vars */
432 	int	t_bytes_acked;		/* # bytes acked during current RTT */
433 	u_int	t_maxunacktime;
434 	u_int	t_keepinit;		/* time to establish connection */
435 	u_int	t_keepidle;		/* time before keepalive probes begin */
436 	u_int	t_keepintvl;		/* interval between keepalives */
437 	u_int	t_keepcnt;		/* number of keepalives before close */
438 	int	t_dupacks;		/* consecutive dup acks recd */
439 	int	t_lognum;		/* Number of log entries */
440 	int	t_loglimit;		/* Maximum number of log entries */
441 	uint32_t t_rcep;		/* Number of received CE marked pkts */
442 	uint32_t t_scep;		/* Synced number of delivered CE pkts */
443 	int64_t	t_pacing_rate;		/* bytes / sec, -1 => unlimited */
444 	struct tcp_log_stailq t_logs;	/* Log buffer */
445 	struct tcp_log_id_node *t_lin;
446 	struct tcp_log_id_bucket *t_lib;
447 	const char *t_output_caller;	/* Function that called tcp_output */
448 	struct statsblob *t_stats;	/* Per-connection stats */
449 	/* Should these be a pointer to the arrays or an array? */
450 	uint32_t t_logsn;		/* Log "serial number" */
451 	uint32_t gput_ts;		/* Time goodput measurement started */
452 	tcp_seq gput_seq;		/* Outbound measurement seq */
453 	tcp_seq gput_ack;		/* Inbound measurement ack */
454 	int32_t t_stats_gput_prev;	/* XXXLAS: Prev gput measurement */
455 	uint32_t t_maxpeakrate;		/* max peak rate set by user, bytes/s */
456 	uint32_t t_sndtlppack;		/* tail loss probe packets sent */
457 	uint64_t t_sndtlpbyte;		/* total tail loss probe bytes sent */
458 	uint64_t t_sndbytes;		/* total bytes sent */
459 	uint64_t t_snd_rxt_bytes;	/* total bytes retransmitted */
460 	uint32_t t_dsack_bytes;		/* dsack bytes received */
461 	uint32_t t_dsack_tlp_bytes;	/* dsack bytes received for TLPs sent */
462 	uint32_t t_dsack_pack;		/* dsack packets we have eceived */
463 	uint8_t t_tmr_granularity;	/* Granularity of all timers srtt etc */
464 	uint8_t t_rttupdated;		/* number of times rtt sampled */
465 	/* TCP Fast Open */
466 	uint8_t t_tfo_client_cookie_len; /* TFO client cookie length */
467 	uint32_t t_end_info_status;	/* Status flag of end info */
468 	unsigned int *t_tfo_pending;	/* TFO server pending counter */
469 	union {
470 		uint8_t client[TCP_FASTOPEN_MAX_COOKIE_LEN];
471 		uint64_t server;
472 	} t_tfo_cookie;			/* TCP Fast Open cookie to send */
473 	union {
474 		uint8_t t_end_info_bytes[TCP_END_BYTE_INFO];
475 		uint64_t t_end_info;
476 	};
477 	struct osd	t_osd;		/* storage for Khelp module data */
478 	uint8_t _t_logpoint;	/* Used when a BB log points is enabled */
479 	/*
480 	 * Keep all #ifdef'ed components at the end of the structure!
481 	 * This is important to minimize problems when compiling modules
482 	 * using this structure from within the modules' directory.
483 	 */
484 #ifdef TCP_REQUEST_TRK
485 	/* Response tracking addons. */
486 	uint8_t t_tcpreq_req;	/* Request count */
487 	uint8_t t_tcpreq_open;	/* Number of open range requests */
488 	uint8_t t_tcpreq_closed;	/* Number of closed range requests */
489 	uint32_t tcp_hybrid_start;	/* Num of times we started hybrid pacing */
490 	uint32_t tcp_hybrid_stop;	/* Num of times we stopped hybrid pacing */
491 	uint32_t tcp_hybrid_error;	/* Num of times we failed to start hybrid pacing */
492 	struct tcp_sendfile_track t_tcpreq_info[MAX_TCP_TRK_REQ];
493 #endif
494 #ifdef TCP_ACCOUNTING
495 	uint64_t tcp_cnt_counters[TCP_NUM_CNT_COUNTERS];
496 	uint64_t tcp_proc_time[TCP_NUM_CNT_COUNTERS];
497 #endif
498 #ifdef TCPPCAP
499 	struct mbufq t_inpkts;		/* List of saved input packets. */
500 	struct mbufq t_outpkts;		/* List of saved output packets. */
501 #endif
502 };
503 #endif	/* _KERNEL || _WANT_TCPCB */
504 
505 #ifdef _KERNEL
506 struct tcptemp {
507 	u_char	tt_ipgen[40]; /* the size must be of max ip header, now IPv6 */
508 	struct	tcphdr tt_t;
509 };
510 
511 /* SACK scoreboard update status */
512 typedef enum {
513 	SACK_NOCHANGE = 0,
514 	SACK_CHANGE,
515 	SACK_NEWLOSS
516 } sackstatus_t;
517 
518 /* Enable TCP/UDP tunneling port */
519 #define TCP_TUNNELING_PORT_MIN		0
520 #define TCP_TUNNELING_PORT_MAX		65535
521 #define TCP_TUNNELING_PORT_DEFAULT	0
522 
523 /* Enable TCP/UDP tunneling port */
524 #define TCP_TUNNELING_OVERHEAD_MIN	sizeof(struct udphdr)
525 #define TCP_TUNNELING_OVERHEAD_MAX	1024
526 #define TCP_TUNNELING_OVERHEAD_DEFAULT	TCP_TUNNELING_OVERHEAD_MIN
527 
528 /* Minimum map entries limit value, if set */
529 #define TCP_MIN_MAP_ENTRIES_LIMIT	128
530 
531 /*
532  * TODO: We yet need to brave plowing in
533  * to tcp_input() and the pru_usrreq() block.
534  * Right now these go to the old standards which
535  * are somewhat ok, but in the long term may
536  * need to be changed. If we do tackle tcp_input()
537  * then we need to get rid of the tcp_do_segment()
538  * function below.
539  */
540 /* Flags for tcp functions */
541 #define	TCP_FUNC_BEING_REMOVED	0x01   	/* Can no longer be referenced */
542 #define	TCP_FUNC_OUTPUT_CANDROP	0x02   	/* tfb_tcp_output may ask tcp_drop */
543 
544 /**
545  * Adding a tfb_tcp_handoff_ok function allows the socket
546  * option to change stacks to query you even if the
547  * connection is in a later stage. You return 0 to
548  * say you can take over and run your stack, you return
549  * non-zero (an error number) to say no you can't.
550  * If the function is undefined you can only change
551  * in the early states (before connect or listen).
552  *
553  * tfb_tcp_fb_init is used to allow the new stack to
554  * setup its control block. Among the things it must
555  * do is:
556  * a) Make sure that the inp_flags2 is setup correctly
557  *    for LRO. There are two flags that the previous
558  *    stack may have set INP_MBUF_ACKCMP and
559  *    INP_SUPPORTS_MBUFQ. If the new stack does not
560  *    support these it *should* clear the flags.
561  * b) Make sure that the timers are in the proper
562  *    granularity that the stack wants. The stack
563  *    should check the t_tmr_granularity field. Currently
564  *    there are two values that it may hold
565  *    TCP_TMR_GRANULARITY_TICKS and TCP_TMR_GRANULARITY_USEC.
566  *    Use the functions tcp_timer_convert(tp, granularity);
567  *    to move the timers to the correct format for your stack.
568  *
569  * The new stack may also optionally query the tfb_chg_query
570  * function if the old stack has one. The new stack may ask
571  * for one of three entries and can also state to the old
572  * stack its support for the INP_MBUF_ACKCMP and
573  * INP_SUPPORTS_MBUFQ. This is important since if there are
574  * queued ack's without that statement the old stack will
575  * be forced to discard the queued acks. The requests that
576  * can be made for information by the new stacks are:
577  *
578  * Note also that the tfb_tcp_fb_init() when called can
579  * determine if a query is needed by looking at the
580  * value passed in the ptr. The ptr is designed to be
581  * set in with any allocated memory, but the address
582  * of the condtion (ptr == &tp->t_fb_ptr) will be
583  * true if this is not a stack switch but the initial
584  * setup of a tcb (which means no query would be needed).
585  * If, however, the value is not t_fb_ptr, then the caller
586  * is in the middle of a stack switch and is the new stack.
587  * A query would be appropriate (if the new stack support
588  * the query mechanism).
589  *
590  * TCP_QUERY_SENDMAP - Query of outstanding data.
591  * TCP_QUERY_TIMERS_UP	- Query about running timers.
592  * TCP_SUPPORTED_LRO - Declaration in req_param of
593  *                     the inp_flags2 supported by
594  *                     the new stack.
595  * TCP_QUERY_RACK_TIMES	- Enquire about various timestamps
596  *                        and states the old stack may be in.
597  *
598  * tfb_tcp_fb_fini is changed to add a flag to tell
599  * the old stack if the tcb is being destroyed or
600  * not. A one in the flag means the TCB is being
601  * destroyed, a zero indicates its transitioning to
602  * another stack (via socket option). The
603  * tfb_tcp_fb_fini() function itself should not change timers
604  * or inp_flags2 (the tfb_tcp_fb_init() must do that). However
605  * if the old stack supports the LRO mbuf queuing, and the new
606  * stack does not communicate via chg messages that it too does,
607  * it must assume it does not and free any queued mbufs.
608  *
609  */
610 struct tcp_function_block {
611 	char tfb_tcp_block_name[TCP_FUNCTION_NAME_LEN_MAX];
612 	int	(*tfb_tcp_output)(struct tcpcb *);
613 	void	(*tfb_tcp_do_segment)(struct tcpcb *, struct mbuf *,
614 		    struct tcphdr *, int, int, uint8_t);
615 	int      (*tfb_do_segment_nounlock)(struct tcpcb *, struct mbuf *,
616 		    struct tcphdr *, int, int, uint8_t, int, struct timeval *);
617 	int     (*tfb_do_queued_segments)(struct tcpcb *, int);
618 	int     (*tfb_tcp_ctloutput)(struct tcpcb *, struct sockopt *);
619 	/* Optional memory allocation/free routine */
620 	int	(*tfb_tcp_fb_init)(struct tcpcb *, void **);
621 	void	(*tfb_tcp_fb_fini)(struct tcpcb *, int);
622 	/* Optional timers, must define all if you define one */
623 	int	(*tfb_tcp_timer_stop_all)(struct tcpcb *);
624 	void	(*tfb_tcp_rexmit_tmr)(struct tcpcb *);
625 	int	(*tfb_tcp_handoff_ok)(struct tcpcb *);
626 	void	(*tfb_tcp_mtu_chg)(struct tcpcb *tp);
627 	int	(*tfb_pru_options)(struct tcpcb *, int);
628 	void	(*tfb_hwtls_change)(struct tcpcb *, int);
629 	int	(*tfb_chg_query)(struct tcpcb *, struct tcp_query_resp *);
630 	void	(*tfb_switch_failed)(struct tcpcb *);
631 	bool	(*tfb_early_wake_check)(struct tcpcb *);
632 	int     (*tfb_compute_pipe)(struct tcpcb *tp);
633 	int     (*tfb_stack_info)(struct tcpcb *tp, struct stack_specific_info *);
634 	void	(*tfb_inherit)(struct tcpcb *tp, struct inpcb *h_inp);
635 	volatile uint32_t tfb_refcnt;
636 	uint32_t  tfb_flags;
637 	uint8_t	tfb_id;
638 };
639 
640 struct tcp_function {
641 	TAILQ_ENTRY(tcp_function)	tf_next;
642 	char				tf_name[TCP_FUNCTION_NAME_LEN_MAX];
643 	struct tcp_function_block	*tf_fb;
644 };
645 
646 TAILQ_HEAD(tcp_funchead, tcp_function);
647 
648 struct tcpcb * tcp_drop(struct tcpcb *, int);
649 
650 #ifdef _NETINET_IN_PCB_H_
651 #define	intotcpcb(inp)	__containerof((inp), struct tcpcb, t_inpcb)
652 #define	sototcpcb(so)	intotcpcb(sotoinpcb(so))
653 #define	tptoinpcb(tp)	(&(tp)->t_inpcb)
654 #define	tptosocket(tp)	(tp)->t_inpcb.inp_socket
655 
656 /*
657  * tcp_output()
658  * Handles tcp_drop request from advanced stacks and reports that inpcb is
659  * gone with negative return code.
660  * Drop in replacement for the default stack.
661  */
662 static inline int
663 tcp_output(struct tcpcb *tp)
664 {
665 	struct inpcb *inp = tptoinpcb(tp);
666 	int rv;
667 
668 	INP_WLOCK_ASSERT(inp);
669 
670 	rv = tp->t_fb->tfb_tcp_output(tp);
671 	if (rv < 0) {
672 		KASSERT(tp->t_fb->tfb_flags & TCP_FUNC_OUTPUT_CANDROP,
673 		    ("TCP stack %s requested tcp_drop(%p)",
674 		    tp->t_fb->tfb_tcp_block_name, tp));
675 		tp = tcp_drop(tp, -rv);
676 		if (tp)
677 			INP_WUNLOCK(inp);
678 	}
679 
680 	return (rv);
681 }
682 
683 /*
684  * tcp_output_unlock()
685  * Always returns unlocked, handles drop request from advanced stacks.
686  * Always returns positive error code.
687  */
688 static inline int
689 tcp_output_unlock(struct tcpcb *tp)
690 {
691 	struct inpcb *inp = tptoinpcb(tp);
692 	int rv;
693 
694 	INP_WLOCK_ASSERT(inp);
695 
696 	rv = tp->t_fb->tfb_tcp_output(tp);
697 	if (rv < 0) {
698 		KASSERT(tp->t_fb->tfb_flags & TCP_FUNC_OUTPUT_CANDROP,
699 		    ("TCP stack %s requested tcp_drop(%p)",
700 		    tp->t_fb->tfb_tcp_block_name, tp));
701 		rv = -rv;
702 		tp = tcp_drop(tp, rv);
703 		if (tp)
704 			INP_WUNLOCK(inp);
705 	} else
706 		INP_WUNLOCK(inp);
707 
708 	return (rv);
709 }
710 
711 /*
712  * tcp_output_nodrop()
713  * Always returns locked.  It is caller's responsibility to run tcp_drop()!
714  * Useful in syscall implementations, when we want to perform some logging
715  * and/or tracing with tcpcb before calling tcp_drop().  To be used with
716  * tcp_unlock_or_drop() later.
717  *
718  * XXXGL: maybe don't allow stacks to return a drop request at certain
719  * TCP states? Why would it do in connect(2)? In recv(2)?
720  */
721 static inline int
722 tcp_output_nodrop(struct tcpcb *tp)
723 {
724 	int rv;
725 
726 	INP_WLOCK_ASSERT(tptoinpcb(tp));
727 
728 	rv = tp->t_fb->tfb_tcp_output(tp);
729 	KASSERT(rv >= 0 || tp->t_fb->tfb_flags & TCP_FUNC_OUTPUT_CANDROP,
730 	    ("TCP stack %s requested tcp_drop(%p)",
731 	    tp->t_fb->tfb_tcp_block_name, tp));
732 	return (rv);
733 }
734 
735 /*
736  * tcp_unlock_or_drop()
737  * Handle return code from tfb_tcp_output() after we have logged/traced,
738  * to be used with tcp_output_nodrop().
739  */
740 static inline int
741 tcp_unlock_or_drop(struct tcpcb *tp, int tcp_output_retval)
742 {
743 	struct inpcb *inp = tptoinpcb(tp);
744 
745 	INP_WLOCK_ASSERT(inp);
746 
747         if (tcp_output_retval < 0) {
748                 tcp_output_retval = -tcp_output_retval;
749                 if (tcp_drop(tp, tcp_output_retval) != NULL)
750                         INP_WUNLOCK(inp);
751         } else
752 		INP_WUNLOCK(inp);
753 
754 	return (tcp_output_retval);
755 }
756 #endif	/* _NETINET_IN_PCB_H_ */
757 
758 static int inline
759 tcp_packets_this_ack(struct tcpcb *tp, tcp_seq ack)
760 {
761 	return ((ack - tp->snd_una) / tp->t_maxseg +
762 		((((ack - tp->snd_una) % tp->t_maxseg) != 0) ? 1 : 0));
763 }
764 #endif	/* _KERNEL */
765 
766 /*
767  * Flags and utility macros for the t_flags field.
768  */
769 #define	TF_ACKNOW	0x00000001	/* ack peer immediately */
770 #define	TF_DELACK	0x00000002	/* ack, but try to delay it */
771 #define	TF_NODELAY	0x00000004	/* don't delay packets to coalesce */
772 #define	TF_NOOPT	0x00000008	/* don't use tcp options */
773 #define	TF_SENTFIN	0x00000010	/* have sent FIN */
774 #define	TF_REQ_SCALE	0x00000020	/* have/will request window scaling */
775 #define	TF_RCVD_SCALE	0x00000040	/* other side has requested scaling */
776 #define	TF_REQ_TSTMP	0x00000080	/* have/will request timestamps */
777 #define	TF_RCVD_TSTMP	0x00000100	/* a timestamp was received in SYN */
778 #define	TF_SACK_PERMIT	0x00000200	/* other side said I could SACK */
779 #define	TF_NEEDSYN	0x00000400	/* send SYN (implicit state) */
780 #define	TF_NEEDFIN	0x00000800	/* send FIN (implicit state) */
781 #define	TF_NOPUSH	0x00001000	/* don't push */
782 #define	TF_PREVVALID	0x00002000	/* saved values for bad rxmit valid
783 					 * Note: accessing and restoring from
784 					 * these may only be done in the 1st
785 					 * RTO recovery round (t_rxtshift == 1)
786 					 */
787 #define	TF_WAKESOR	0x00004000	/* wake up receive socket */
788 #define	TF_GPUTINPROG	0x00008000	/* Goodput measurement in progress */
789 #define	TF_MORETOCOME	0x00010000	/* More data to be appended to sock */
790 #define	TF_SONOTCONN	0x00020000	/* needs soisconnected() on ESTAB */
791 #define	TF_LASTIDLE	0x00040000	/* connection was previously idle */
792 #define	TF_RXWIN0SENT	0x00080000	/* sent a receiver win 0 in response */
793 #define	TF_FASTRECOVERY	0x00100000	/* in NewReno Fast Recovery */
794 #define	TF_WASFRECOVERY	0x00200000	/* was in NewReno Fast Recovery */
795 #define	TF_SIGNATURE	0x00400000	/* require MD5 digests (RFC2385) */
796 #define	TF_FORCEDATA	0x00800000	/* force out a byte */
797 #define	TF_TSO		0x01000000	/* TSO enabled on this connection */
798 #define	TF_TOE		0x02000000	/* this connection is offloaded */
799 #define	TF_CLOSED	0x04000000	/* close(2) called on socket */
800 #define TF_SENTSYN      0x08000000      /* At least one syn has been sent */
801 #define	TF_LRD		0x10000000	/* Lost Retransmission Detection */
802 #define	TF_CONGRECOVERY	0x20000000	/* congestion recovery mode */
803 #define	TF_WASCRECOVERY	0x40000000	/* was in congestion recovery */
804 #define	TF_FASTOPEN	0x80000000	/* TCP Fast Open indication */
805 
806 #define	IN_FASTRECOVERY(t_flags)	(t_flags & TF_FASTRECOVERY)
807 #define	ENTER_FASTRECOVERY(t_flags)	t_flags |= TF_FASTRECOVERY
808 #define	EXIT_FASTRECOVERY(t_flags)	t_flags &= ~TF_FASTRECOVERY
809 
810 #define	IN_CONGRECOVERY(t_flags)	(t_flags & TF_CONGRECOVERY)
811 #define	ENTER_CONGRECOVERY(t_flags)	t_flags |= TF_CONGRECOVERY
812 #define	EXIT_CONGRECOVERY(t_flags)	t_flags &= ~TF_CONGRECOVERY
813 
814 #define	IN_RECOVERY(t_flags) (t_flags & (TF_CONGRECOVERY | TF_FASTRECOVERY))
815 #define	ENTER_RECOVERY(t_flags) t_flags |= (TF_CONGRECOVERY | TF_FASTRECOVERY)
816 #define	EXIT_RECOVERY(t_flags) t_flags &= ~(TF_CONGRECOVERY | TF_FASTRECOVERY)
817 
818 #define	BYTES_THIS_ACK(tp, th)	(th->th_ack - tp->snd_una)
819 
820 /*
821  * Flags for the t_oobflags field.
822  */
823 #define	TCPOOB_HAVEDATA	0x01
824 #define	TCPOOB_HADDATA	0x02
825 
826 /*
827  * Flags for the extended TCP flags field, t_flags2
828  */
829 #define	TF2_PLPMTU_BLACKHOLE	0x00000001 /* Possible PLPMTUD Black Hole. */
830 #define	TF2_PLPMTU_PMTUD	0x00000002 /* Allowed to attempt PLPMTUD. */
831 #define	TF2_PLPMTU_MAXSEGSNT	0x00000004 /* Last seg sent was full seg. */
832 #define	TF2_LOG_AUTO		0x00000008 /* Session is auto-logging. */
833 #define	TF2_DROP_AF_DATA	0x00000010 /* Drop after all data ack'd */
834 #define	TF2_ECN_PERMIT		0x00000020 /* connection ECN-ready */
835 #define	TF2_ECN_SND_CWR		0x00000040 /* ECN CWR in queue */
836 #define	TF2_ECN_SND_ECE		0x00000080 /* ECN ECE in queue */
837 #define	TF2_ACE_PERMIT		0x00000100 /* Accurate ECN mode */
838 #define	TF2_HPTS_CPU_SET	0x00000200 /* t_hpts_cpu is not random */
839 #define	TF2_FBYTES_COMPLETE	0x00000400 /* We have first bytes in and out */
840 #define	TF2_ECN_USE_ECT1	0x00000800 /* Use ECT(1) marking on session */
841 #define TF2_TCP_ACCOUNTING	0x00001000 /* Do TCP accounting */
842 #define	TF2_HPTS_CALLS		0x00002000 /* tcp_output() called via HPTS */
843 #define	TF2_MBUF_L_ACKS		0x00004000 /* large mbufs for ack compression */
844 #define	TF2_MBUF_ACKCMP		0x00008000 /* mbuf ack compression ok */
845 #define	TF2_SUPPORTS_MBUFQ	0x00010000 /* Supports the mbuf queue method */
846 #define	TF2_MBUF_QUEUE_READY	0x00020000 /* Inputs can be queued */
847 #define	TF2_DONT_SACK_QUEUE	0x00040000 /* Don't wake on sack */
848 #define	TF2_CANNOT_DO_ECN	0x00080000 /* The stack does not do ECN */
849 
850 /*
851  * Structure to hold TCP options that are only used during segment
852  * processing (in tcp_input), but not held in the tcpcb.
853  * It's basically used to reduce the number of parameters
854  * to tcp_dooptions and tcp_addoptions.
855  * The binary order of the to_flags is relevant for packing of the
856  * options in tcp_addoptions.
857  */
858 struct tcpopt {
859 	u_int32_t	to_flags;	/* which options are present */
860 #define	TOF_MSS		0x0001		/* maximum segment size */
861 #define	TOF_SCALE	0x0002		/* window scaling */
862 #define	TOF_SACKPERM	0x0004		/* SACK permitted */
863 #define	TOF_TS		0x0010		/* timestamp */
864 #define	TOF_SIGNATURE	0x0040		/* TCP-MD5 signature option (RFC2385) */
865 #define	TOF_SACK	0x0080		/* Peer sent SACK option */
866 #define	TOF_FASTOPEN	0x0100		/* TCP Fast Open (TFO) cookie */
867 #define	TOF_MAXOPT	0x0200
868 	u_int32_t	to_tsval;	/* new timestamp */
869 	u_int32_t	to_tsecr;	/* reflected timestamp */
870 	u_char		*to_sacks;	/* pointer to the first SACK blocks */
871 	u_char		*to_signature;	/* pointer to the TCP-MD5 signature */
872 	u_int8_t	*to_tfo_cookie; /* pointer to the TFO cookie */
873 	u_int16_t	to_mss;		/* maximum segment size */
874 	u_int8_t	to_wscale;	/* window scaling */
875 	u_int8_t	to_nsacks;	/* number of SACK blocks */
876 	u_int8_t	to_tfo_len;	/* TFO cookie length */
877 	u_int32_t	to_spare;	/* UTO */
878 };
879 
880 /*
881  * Flags for tcp_dooptions.
882  */
883 #define	TO_SYN		0x01		/* parse SYN-only options */
884 
885 struct hc_metrics_lite {	/* must stay in sync with hc_metrics */
886 	uint32_t	rmx_mtu;	/* MTU for this path */
887 	uint32_t	rmx_ssthresh;	/* outbound gateway buffer limit */
888 	uint32_t	rmx_rtt;	/* estimated round trip time */
889 	uint32_t	rmx_rttvar;	/* estimated rtt variance */
890 	uint32_t	rmx_cwnd;	/* congestion window */
891 	uint32_t	rmx_sendpipe;   /* outbound delay-bandwidth product */
892 	uint32_t	rmx_recvpipe;   /* inbound delay-bandwidth product */
893 };
894 
895 #ifndef _NETINET_IN_PCB_H_
896 struct in_conninfo;
897 #endif /* _NETINET_IN_PCB_H_ */
898 
899 /*
900  * The smoothed round-trip time and estimated variance
901  * are stored as fixed point numbers scaled by the values below.
902  * For convenience, these scales are also used in smoothing the average
903  * (smoothed = (1/scale)sample + ((scale-1)/scale)smoothed).
904  * With these scales, srtt has 3 bits to the right of the binary point,
905  * and thus an "ALPHA" of 0.875.  rttvar has 2 bits to the right of the
906  * binary point, and is smoothed with an ALPHA of 0.75.
907  */
908 #define	TCP_RTT_SCALE		32	/* multiplier for srtt; 5 bits frac. */
909 #define	TCP_RTT_SHIFT		5	/* shift for srtt; 5 bits frac. */
910 #define	TCP_RTTVAR_SCALE	16	/* multiplier for rttvar; 4 bits */
911 #define	TCP_RTTVAR_SHIFT	4	/* shift for rttvar; 4 bits */
912 #define	TCP_DELTA_SHIFT		2	/* see tcp_input.c */
913 
914 /*
915  * The initial retransmission should happen at rtt + 4 * rttvar.
916  * Because of the way we do the smoothing, srtt and rttvar
917  * will each average +1/2 tick of bias.  When we compute
918  * the retransmit timer, we want 1/2 tick of rounding and
919  * 1 extra tick because of +-1/2 tick uncertainty in the
920  * firing of the timer.  The bias will give us exactly the
921  * 1.5 tick we need.  But, because the bias is
922  * statistical, we have to test that we don't drop below
923  * the minimum feasible timer (which is 2 ticks).
924  * This version of the macro adapted from a paper by Lawrence
925  * Brakmo and Larry Peterson which outlines a problem caused
926  * by insufficient precision in the original implementation,
927  * which results in inappropriately large RTO values for very
928  * fast networks.
929  */
930 #define	TCP_REXMTVAL(tp) \
931 	max((tp)->t_rttmin, (((tp)->t_srtt >> (TCP_RTT_SHIFT - TCP_DELTA_SHIFT))  \
932 	  + (tp)->t_rttvar) >> TCP_DELTA_SHIFT)
933 
934 /*
935  * TCP statistics.
936  * Many of these should be kept per connection,
937  * but that's inconvenient at the moment.
938  */
939 struct	tcpstat {
940 	uint64_t tcps_connattempt;	/* connections initiated */
941 	uint64_t tcps_accepts;		/* connections accepted */
942 	uint64_t tcps_connects;		/* connections established */
943 	uint64_t tcps_drops;		/* connections dropped */
944 	uint64_t tcps_conndrops;	/* embryonic connections dropped */
945 	uint64_t tcps_minmssdrops;	/* average minmss too low drops */
946 	uint64_t tcps_closed;		/* conn. closed (includes drops) */
947 	uint64_t tcps_segstimed;	/* segs where we tried to get rtt */
948 	uint64_t tcps_rttupdated;	/* times we succeeded */
949 	uint64_t tcps_delack;		/* delayed acks sent */
950 	uint64_t tcps_timeoutdrop;	/* conn. dropped in rxmt timeout */
951 	uint64_t tcps_rexmttimeo;	/* retransmit timeouts */
952 	uint64_t tcps_persisttimeo;	/* persist timeouts */
953 	uint64_t tcps_keeptimeo;	/* keepalive timeouts */
954 	uint64_t tcps_keepprobe;	/* keepalive probes sent */
955 	uint64_t tcps_keepdrops;	/* connections dropped in keepalive */
956 	uint64_t tcps_progdrops;	/* drops due to no progress */
957 
958 	uint64_t tcps_sndtotal;		/* total packets sent */
959 	uint64_t tcps_sndpack;		/* data packets sent */
960 	uint64_t tcps_sndbyte;		/* data bytes sent */
961 	uint64_t tcps_sndrexmitpack;	/* data packets retransmitted */
962 	uint64_t tcps_sndrexmitbyte;	/* data bytes retransmitted */
963 	uint64_t tcps_sndrexmitbad;	/* unnecessary packet retransmissions */
964 	uint64_t tcps_sndacks;		/* ack-only packets sent */
965 	uint64_t tcps_sndprobe;		/* window probes sent */
966 	uint64_t tcps_sndurg;		/* packets sent with URG only */
967 	uint64_t tcps_sndwinup;		/* window update-only packets sent */
968 	uint64_t tcps_sndctrl;		/* control (SYN|FIN|RST) packets sent */
969 
970 	uint64_t tcps_rcvtotal;		/* total packets received */
971 	uint64_t tcps_rcvpack;		/* packets received in sequence */
972 	uint64_t tcps_rcvbyte;		/* bytes received in sequence */
973 	uint64_t tcps_rcvbadsum;	/* packets received with ccksum errs */
974 	uint64_t tcps_rcvbadoff;	/* packets received with bad offset */
975 	uint64_t tcps_rcvreassfull;	/* packets dropped for no reass space */
976 	uint64_t tcps_rcvshort;		/* packets received too short */
977 	uint64_t tcps_rcvduppack;	/* duplicate-only packets received */
978 	uint64_t tcps_rcvdupbyte;	/* duplicate-only bytes received */
979 	uint64_t tcps_rcvpartduppack;	/* packets with some duplicate data */
980 	uint64_t tcps_rcvpartdupbyte;	/* dup. bytes in part-dup. packets */
981 	uint64_t tcps_rcvoopack;	/* out-of-order packets received */
982 	uint64_t tcps_rcvoobyte;	/* out-of-order bytes received */
983 	uint64_t tcps_rcvpackafterwin;	/* packets with data after window */
984 	uint64_t tcps_rcvbyteafterwin;	/* bytes rcvd after window */
985 	uint64_t tcps_rcvafterclose;	/* packets rcvd after "close" */
986 	uint64_t tcps_rcvwinprobe;	/* rcvd window probe packets */
987 	uint64_t tcps_rcvdupack;	/* rcvd duplicate acks */
988 	uint64_t tcps_rcvacktoomuch;	/* rcvd acks for unsent data */
989 	uint64_t tcps_rcvackpack;	/* rcvd ack packets */
990 	uint64_t tcps_rcvackbyte;	/* bytes acked by rcvd acks */
991 	uint64_t tcps_rcvwinupd;	/* rcvd window update packets */
992 	uint64_t tcps_pawsdrop;		/* segments dropped due to PAWS */
993 	uint64_t tcps_predack;		/* times hdr predict ok for acks */
994 	uint64_t tcps_preddat;		/* times hdr predict ok for data pkts */
995 	uint64_t tcps_pcbcachemiss;
996 	uint64_t tcps_cachedrtt;	/* times cached RTT in route updated */
997 	uint64_t tcps_cachedrttvar;	/* times cached rttvar updated */
998 	uint64_t tcps_cachedssthresh;	/* times cached ssthresh updated */
999 	uint64_t tcps_usedrtt;		/* times RTT initialized from route */
1000 	uint64_t tcps_usedrttvar;	/* times RTTVAR initialized from rt */
1001 	uint64_t tcps_usedssthresh;	/* times ssthresh initialized from rt*/
1002 	uint64_t tcps_persistdrop;	/* timeout in persist state */
1003 	uint64_t tcps_badsyn;		/* bogus SYN, e.g. premature ACK */
1004 	uint64_t tcps_mturesent;	/* resends due to MTU discovery */
1005 	uint64_t tcps_listendrop;	/* listen queue overflows */
1006 	uint64_t tcps_badrst;		/* ignored RSTs in the window */
1007 
1008 	uint64_t tcps_sc_added;		/* entry added to syncache */
1009 	uint64_t tcps_sc_retransmitted;	/* syncache entry was retransmitted */
1010 	uint64_t tcps_sc_dupsyn;	/* duplicate SYN packet */
1011 	uint64_t tcps_sc_dropped;	/* could not reply to packet */
1012 	uint64_t tcps_sc_completed;	/* successful extraction of entry */
1013 	uint64_t tcps_sc_bucketoverflow;/* syncache per-bucket limit hit */
1014 	uint64_t tcps_sc_cacheoverflow;	/* syncache cache limit hit */
1015 	uint64_t tcps_sc_reset;		/* RST removed entry from syncache */
1016 	uint64_t tcps_sc_stale;		/* timed out or listen socket gone */
1017 	uint64_t tcps_sc_aborted;	/* syncache entry aborted */
1018 	uint64_t tcps_sc_badack;	/* removed due to bad ACK */
1019 	uint64_t tcps_sc_unreach;	/* ICMP unreachable received */
1020 	uint64_t tcps_sc_zonefail;	/* zalloc() failed */
1021 	uint64_t tcps_sc_sendcookie;	/* SYN cookie sent */
1022 	uint64_t tcps_sc_recvcookie;	/* SYN cookie received */
1023 
1024 	uint64_t tcps_hc_added;		/* entry added to hostcache */
1025 	uint64_t tcps_hc_bucketoverflow;/* hostcache per bucket limit hit */
1026 
1027 	uint64_t tcps_finwait2_drops;    /* Drop FIN_WAIT_2 connection after time limit */
1028 
1029 	/* SACK related stats */
1030 	uint64_t tcps_sack_recovery_episode; /* SACK recovery episodes */
1031 	uint64_t tcps_sack_rexmits;	    /* SACK rexmit segments   */
1032 	uint64_t tcps_sack_rexmit_bytes;    /* SACK rexmit bytes      */
1033 	uint64_t tcps_sack_rcv_blocks;	    /* SACK blocks (options) received */
1034 	uint64_t tcps_sack_send_blocks;	    /* SACK blocks (options) sent     */
1035 	uint64_t tcps_sack_lostrexmt;	    /* SACK lost retransmission recovered */
1036 	uint64_t tcps_sack_sboverflow;	    /* times scoreboard overflowed */
1037 
1038 	/* ECN related stats */
1039 	uint64_t tcps_ecn_rcvce;		/* ECN Congestion Experienced */
1040 	uint64_t tcps_ecn_rcvect0;		/* ECN Capable Transport */
1041 	uint64_t tcps_ecn_rcvect1;		/* ECN Capable Transport */
1042 	uint64_t tcps_ecn_shs;		/* ECN successful handshakes */
1043 	uint64_t tcps_ecn_rcwnd;	/* # times ECN reduced the cwnd */
1044 
1045 	/* TCP_SIGNATURE related stats */
1046 	uint64_t tcps_sig_rcvgoodsig;	/* Total matching signature received */
1047 	uint64_t tcps_sig_rcvbadsig;	/* Total bad signature received */
1048 	uint64_t tcps_sig_err_buildsig;	/* Failed to make signature */
1049 	uint64_t tcps_sig_err_sigopt;	/* No signature expected by socket */
1050 	uint64_t tcps_sig_err_nosigopt;	/* No signature provided by segment */
1051 
1052 	/* Path MTU Discovery Black Hole Detection related stats */
1053 	uint64_t tcps_pmtud_blackhole_activated;	 /* Black Hole Count */
1054 	uint64_t tcps_pmtud_blackhole_activated_min_mss; /* BH at min MSS Count */
1055 	uint64_t tcps_pmtud_blackhole_failed;		 /* Black Hole Failure Count */
1056 
1057 	uint64_t tcps_tunneled_pkts;	/* Packets encap's in UDP received */
1058 	uint64_t tcps_tunneled_errs;	/* Packets that had errors that were UDP encaped */
1059 
1060 	/* Dsack related stats */
1061 	uint64_t tcps_dsack_count;	/* Number of ACKs arriving with DSACKs */
1062 	uint64_t tcps_dsack_bytes;	/* Number of bytes DSACK'ed no TLP */
1063 	uint64_t tcps_dsack_tlp_bytes;	/* Number of bytes DSACK'ed due to TLPs */
1064 
1065 	/* TCPS_TIME_WAIT usage stats */
1066 	uint64_t tcps_tw_recycles;	/* Times time-wait was recycled. */
1067 	uint64_t tcps_tw_resets;	/* Times time-wait sent a reset. */
1068 	uint64_t tcps_tw_responds;	/* Times time-wait sent a valid ack. */
1069 
1070 	/* Accurate ECN Handshake stats */
1071 	uint64_t tcps_ace_nect;		/* ACE SYN packet with Non-ECT */
1072 	uint64_t tcps_ace_ect1;		/* ACE SYN packet with ECT1 */
1073 	uint64_t tcps_ace_ect0;		/* ACE SYN packet with ECT0 */
1074 	uint64_t tcps_ace_ce;		/* ACE SYN packet with CE */
1075 
1076 	/* ECN related stats */
1077 	uint64_t tcps_ecn_sndect0;		/* ECN Capable Transport */
1078 	uint64_t tcps_ecn_sndect1;		/* ECN Capable Transport */
1079 
1080 	/*
1081 	 * BBR and Rack implement TLP's these values count TLP bytes in
1082 	 * two catagories, bytes that were retransmitted and bytes that
1083 	 * were newly transmited. Both types can serve as TLP's but they
1084 	 * are accounted differently.
1085 	 */
1086 	uint64_t tcps_tlpresends;	/* number of tlp resends */
1087 	uint64_t tcps_tlpresend_bytes;	/* number of bytes resent by tlp */
1088 
1089 
1090 	uint64_t _pad[4];		/* 4 TBD placeholder for STABLE */
1091 };
1092 
1093 #define	tcps_rcvmemdrop	tcps_rcvreassfull	/* compat */
1094 
1095 #ifdef _KERNEL
1096 #define	TI_UNLOCKED	1
1097 #define	TI_RLOCKED	2
1098 #include <sys/counter.h>
1099 #include <netinet/in_kdtrace.h>
1100 
1101 VNET_PCPUSTAT_DECLARE(struct tcpstat, tcpstat);	/* tcp statistics */
1102 /*
1103  * In-kernel consumers can use these accessor macros directly to update
1104  * stats.
1105  */
1106 #define TCPSTAT_ADD(name, val)                                           \
1107 	do {                                                             \
1108 		MIB_SDT_PROBE1(tcp, count, name, (val));                 \
1109 		VNET_PCPUSTAT_ADD(struct tcpstat, tcpstat, name, (val)); \
1110 	} while (0)
1111 #define	TCPSTAT_INC(name)	TCPSTAT_ADD(name, 1)
1112 
1113 /*
1114  * Kernel module consumers must use this accessor macro.
1115  */
1116 void	kmod_tcpstat_add(int statnum, int val);
1117 #define KMOD_TCPSTAT_ADD(name, val)                               \
1118 	do {                                                      \
1119 		MIB_SDT_PROBE1(tcp, count, name, (val));          \
1120 		kmod_tcpstat_add(offsetof(struct tcpstat, name) / \
1121 			sizeof(uint64_t),                         \
1122 		    val);                                         \
1123 	} while (0)
1124 #define	KMOD_TCPSTAT_INC(name)	KMOD_TCPSTAT_ADD(name, 1)
1125 
1126 /*
1127  * Running TCP connection count by state.
1128  */
1129 VNET_DECLARE(counter_u64_t, tcps_states[TCP_NSTATES]);
1130 #define	V_tcps_states	VNET(tcps_states)
1131 #define	TCPSTATES_INC(state)	counter_u64_add(V_tcps_states[state], 1)
1132 #define	TCPSTATES_DEC(state)	counter_u64_add(V_tcps_states[state], -1)
1133 
1134 /*
1135  * TCP specific helper hook point identifiers.
1136  */
1137 #define	HHOOK_TCP_EST_IN		0
1138 #define	HHOOK_TCP_EST_OUT		1
1139 #define	HHOOK_TCP_LAST			HHOOK_TCP_EST_OUT
1140 
1141 struct tcp_hhook_data {
1142 	struct tcpcb	*tp;
1143 	struct tcphdr	*th;
1144 	struct tcpopt	*to;
1145 	uint32_t	len;
1146 	int		tso;
1147 	tcp_seq		curack;
1148 };
1149 #ifdef TCP_HHOOK
1150 void hhook_run_tcp_est_out(struct tcpcb *tp,
1151 	struct tcphdr *th, struct tcpopt *to,
1152 	uint32_t len, int tso);
1153 #endif
1154 #endif
1155 
1156 /*
1157  * TCB structure exported to user-land via sysctl(3).
1158  *
1159  * Fields prefixed with "xt_" are unique to the export structure, and fields
1160  * with "t_" or other prefixes match corresponding fields of 'struct tcpcb'.
1161  *
1162  * Legend:
1163  * (s) - used by userland utilities in src
1164  * (p) - used by utilities in ports
1165  * (3) - is known to be used by third party software not in ports
1166  * (n) - no known usage
1167  *
1168  * Evil hack: declare only if in_pcb.h and sys/socketvar.h have been
1169  * included.  Not all of our clients do.
1170  */
1171 #if defined(_NETINET_IN_PCB_H_) && defined(_SYS_SOCKETVAR_H_)
1172 struct xtcpcb {
1173 	ksize_t	xt_len;		/* length of this structure */
1174 	struct xinpcb	xt_inp;
1175 	char		xt_stack[TCP_FUNCTION_NAME_LEN_MAX];	/* (s) */
1176 	char		xt_logid[TCP_LOG_ID_LEN];	/* (s) */
1177 	char		xt_cc[TCP_CA_NAME_MAX];	/* (s) */
1178 	int64_t		spare64[6];
1179 	int32_t		t_state;		/* (s,p) */
1180 	uint32_t	t_flags;		/* (s,p) */
1181 	int32_t		t_sndzerowin;		/* (s) */
1182 	int32_t		t_sndrexmitpack;	/* (s) */
1183 	int32_t		t_rcvoopack;		/* (s) */
1184 	int32_t		t_rcvtime;		/* (s) */
1185 	int32_t		tt_rexmt;		/* (s) */
1186 	int32_t		tt_persist;		/* (s) */
1187 	int32_t		tt_keep;		/* (s) */
1188 	int32_t		tt_2msl;		/* (s) */
1189 	int32_t		tt_delack;		/* (s) */
1190 	int32_t		t_logstate;		/* (3) */
1191 	uint32_t	t_snd_cwnd;		/* (s) */
1192 	uint32_t	t_snd_ssthresh;		/* (s) */
1193 	uint32_t	t_maxseg;		/* (s) */
1194 	uint32_t	t_rcv_wnd;		/* (s) */
1195 	uint32_t	t_snd_wnd;		/* (s) */
1196 	uint32_t	xt_ecn;			/* (s) */
1197 	uint32_t	t_dsack_bytes;		/* (n) */
1198 	uint32_t	t_dsack_tlp_bytes;	/* (n) */
1199 	uint32_t	t_dsack_pack;		/* (n) */
1200 	uint16_t	xt_encaps_port;		/* (s) */
1201 	int16_t		spare16;
1202 	int32_t		spare32[22];
1203 } __aligned(8);
1204 
1205 #ifdef _KERNEL
1206 void	tcp_inptoxtp(const struct inpcb *, struct xtcpcb *);
1207 #endif
1208 #endif
1209 
1210 /*
1211  * TCP function information (name-to-id mapping, aliases, and refcnt)
1212  * exported to user-land via sysctl(3).
1213  */
1214 struct tcp_function_info {
1215 	uint32_t	tfi_refcnt;
1216 	uint8_t		tfi_id;
1217 	char		tfi_name[TCP_FUNCTION_NAME_LEN_MAX];
1218 	char		tfi_alias[TCP_FUNCTION_NAME_LEN_MAX];
1219 };
1220 
1221 /*
1222  * Identifiers for TCP sysctl nodes
1223  */
1224 #define	TCPCTL_DO_RFC1323	1	/* use RFC-1323 extensions */
1225 #define	TCPCTL_MSSDFLT		3	/* MSS default */
1226 #define TCPCTL_STATS		4	/* statistics */
1227 #define	TCPCTL_RTTDFLT		5	/* default RTT estimate */
1228 #define	TCPCTL_KEEPIDLE		6	/* keepalive idle timer */
1229 #define	TCPCTL_KEEPINTVL	7	/* interval to send keepalives */
1230 #define	TCPCTL_SENDSPACE	8	/* send buffer space */
1231 #define	TCPCTL_RECVSPACE	9	/* receive buffer space */
1232 #define	TCPCTL_KEEPINIT		10	/* timeout for establishing syn */
1233 #define	TCPCTL_PCBLIST		11	/* list of all outstanding PCBs */
1234 #define	TCPCTL_DELACKTIME	12	/* time before sending delayed ACK */
1235 #define	TCPCTL_V6MSSDFLT	13	/* MSS default for IPv6 */
1236 #define	TCPCTL_SACK		14	/* Selective Acknowledgement,rfc 2018 */
1237 #define	TCPCTL_DROP		15	/* drop tcp connection */
1238 #define	TCPCTL_STATES		16	/* connection counts by TCP state */
1239 
1240 #ifdef _KERNEL
1241 #ifdef SYSCTL_DECL
1242 SYSCTL_DECL(_net_inet_tcp);
1243 SYSCTL_DECL(_net_inet_tcp_sack);
1244 MALLOC_DECLARE(M_TCPLOG);
1245 #endif
1246 
1247 VNET_DECLARE(int, tcp_log_in_vain);
1248 #define	V_tcp_log_in_vain		VNET(tcp_log_in_vain)
1249 
1250 /*
1251  * Global TCP tunables shared between different stacks.
1252  * Please keep the list sorted.
1253  */
1254 VNET_DECLARE(int, drop_synfin);
1255 VNET_DECLARE(int, path_mtu_discovery);
1256 VNET_DECLARE(int, tcp_abc_l_var);
1257 VNET_DECLARE(int, tcp_autorcvbuf_max);
1258 VNET_DECLARE(int, tcp_autosndbuf_inc);
1259 VNET_DECLARE(int, tcp_autosndbuf_max);
1260 VNET_DECLARE(int, tcp_delack_enabled);
1261 VNET_DECLARE(int, tcp_do_autorcvbuf);
1262 VNET_DECLARE(int, tcp_do_autosndbuf);
1263 VNET_DECLARE(int, tcp_do_ecn);
1264 VNET_DECLARE(int, tcp_do_lrd);
1265 VNET_DECLARE(int, tcp_do_prr);
1266 VNET_DECLARE(int, tcp_do_prr_conservative);
1267 VNET_DECLARE(int, tcp_do_newcwv);
1268 VNET_DECLARE(int, tcp_do_rfc1323);
1269 VNET_DECLARE(int, tcp_tolerate_missing_ts);
1270 VNET_DECLARE(int, tcp_do_rfc3042);
1271 VNET_DECLARE(int, tcp_do_rfc3390);
1272 VNET_DECLARE(int, tcp_do_rfc3465);
1273 VNET_DECLARE(int, tcp_do_newsack);
1274 VNET_DECLARE(int, tcp_do_sack);
1275 VNET_DECLARE(int, tcp_do_tso);
1276 VNET_DECLARE(int, tcp_ecn_maxretries);
1277 VNET_DECLARE(int, tcp_initcwnd_segments);
1278 VNET_DECLARE(int, tcp_insecure_rst);
1279 VNET_DECLARE(int, tcp_insecure_syn);
1280 VNET_DECLARE(uint32_t, tcp_map_entries_limit);
1281 VNET_DECLARE(uint32_t, tcp_map_split_limit);
1282 VNET_DECLARE(int, tcp_minmss);
1283 VNET_DECLARE(int, tcp_mssdflt);
1284 #ifdef STATS
1285 VNET_DECLARE(int, tcp_perconn_stats_dflt_tpl);
1286 VNET_DECLARE(int, tcp_perconn_stats_enable);
1287 #endif /* STATS */
1288 VNET_DECLARE(int, tcp_recvspace);
1289 VNET_DECLARE(int, tcp_retries);
1290 VNET_DECLARE(int, tcp_sack_globalholes);
1291 VNET_DECLARE(int, tcp_sack_globalmaxholes);
1292 VNET_DECLARE(int, tcp_sack_maxholes);
1293 VNET_DECLARE(int, tcp_sc_rst_sock_fail);
1294 VNET_DECLARE(int, tcp_sendspace);
1295 VNET_DECLARE(int, tcp_udp_tunneling_overhead);
1296 VNET_DECLARE(int, tcp_udp_tunneling_port);
1297 VNET_DECLARE(struct inpcbinfo, tcbinfo);
1298 
1299 #define	V_tcp_do_lrd			VNET(tcp_do_lrd)
1300 #define	V_tcp_do_prr			VNET(tcp_do_prr)
1301 #define	V_tcp_do_newcwv			VNET(tcp_do_newcwv)
1302 #define	V_drop_synfin			VNET(drop_synfin)
1303 #define	V_path_mtu_discovery		VNET(path_mtu_discovery)
1304 #define	V_tcbinfo			VNET(tcbinfo)
1305 #define	V_tcp_abc_l_var			VNET(tcp_abc_l_var)
1306 #define	V_tcp_autorcvbuf_max		VNET(tcp_autorcvbuf_max)
1307 #define	V_tcp_autosndbuf_inc		VNET(tcp_autosndbuf_inc)
1308 #define	V_tcp_autosndbuf_max		VNET(tcp_autosndbuf_max)
1309 #define	V_tcp_delack_enabled		VNET(tcp_delack_enabled)
1310 #define	V_tcp_do_autorcvbuf		VNET(tcp_do_autorcvbuf)
1311 #define	V_tcp_do_autosndbuf		VNET(tcp_do_autosndbuf)
1312 #define	V_tcp_do_ecn			VNET(tcp_do_ecn)
1313 #define	V_tcp_do_rfc1323		VNET(tcp_do_rfc1323)
1314 #define	V_tcp_tolerate_missing_ts	VNET(tcp_tolerate_missing_ts)
1315 #define V_tcp_ts_offset_per_conn	VNET(tcp_ts_offset_per_conn)
1316 #define	V_tcp_do_rfc3042		VNET(tcp_do_rfc3042)
1317 #define	V_tcp_do_rfc3390		VNET(tcp_do_rfc3390)
1318 #define	V_tcp_do_rfc3465		VNET(tcp_do_rfc3465)
1319 #define	V_tcp_do_newsack		VNET(tcp_do_newsack)
1320 #define	V_tcp_do_sack			VNET(tcp_do_sack)
1321 #define	V_tcp_do_tso			VNET(tcp_do_tso)
1322 #define	V_tcp_ecn_maxretries		VNET(tcp_ecn_maxretries)
1323 #define	V_tcp_initcwnd_segments		VNET(tcp_initcwnd_segments)
1324 #define	V_tcp_insecure_rst		VNET(tcp_insecure_rst)
1325 #define	V_tcp_insecure_syn		VNET(tcp_insecure_syn)
1326 #define	V_tcp_map_entries_limit		VNET(tcp_map_entries_limit)
1327 #define	V_tcp_map_split_limit		VNET(tcp_map_split_limit)
1328 #define	V_tcp_minmss			VNET(tcp_minmss)
1329 #define	V_tcp_mssdflt			VNET(tcp_mssdflt)
1330 #ifdef STATS
1331 #define	V_tcp_perconn_stats_dflt_tpl	VNET(tcp_perconn_stats_dflt_tpl)
1332 #define	V_tcp_perconn_stats_enable	VNET(tcp_perconn_stats_enable)
1333 #endif /* STATS */
1334 #define	V_tcp_recvspace			VNET(tcp_recvspace)
1335 #define	V_tcp_retries			VNET(tcp_retries)
1336 #define	V_tcp_sack_globalholes		VNET(tcp_sack_globalholes)
1337 #define	V_tcp_sack_globalmaxholes	VNET(tcp_sack_globalmaxholes)
1338 #define	V_tcp_sack_maxholes		VNET(tcp_sack_maxholes)
1339 #define	V_tcp_sc_rst_sock_fail		VNET(tcp_sc_rst_sock_fail)
1340 #define	V_tcp_sendspace			VNET(tcp_sendspace)
1341 #define	V_tcp_udp_tunneling_overhead	VNET(tcp_udp_tunneling_overhead)
1342 #define	V_tcp_udp_tunneling_port	VNET(tcp_udp_tunneling_port)
1343 
1344 #ifdef TCP_HHOOK
1345 VNET_DECLARE(struct hhook_head *, tcp_hhh[HHOOK_TCP_LAST + 1]);
1346 #define	V_tcp_hhh		VNET(tcp_hhh)
1347 #endif
1348 
1349 void	tcp_account_for_send(struct tcpcb *, uint32_t, uint8_t, uint8_t, bool);
1350 int	 tcp_addoptions(struct tcpopt *, u_char *);
1351 struct tcpcb *
1352 	 tcp_close(struct tcpcb *);
1353 void	 tcp_discardcb(struct tcpcb *);
1354 void	 tcp_twstart(struct tcpcb *);
1355 int	 tcp_ctloutput(struct socket *, struct sockopt *);
1356 void	 tcp_fini(void *);
1357 char	*tcp_log_addrs(struct in_conninfo *, struct tcphdr *, const void *,
1358 	    const void *);
1359 char	*tcp_log_vain(struct in_conninfo *, struct tcphdr *, const void *,
1360 	    const void *);
1361 int	 tcp_reass(struct tcpcb *, struct tcphdr *, tcp_seq *, int *,
1362 	    struct mbuf *);
1363 void	 tcp_reass_global_init(void);
1364 void	 tcp_reass_flush(struct tcpcb *);
1365 void	 tcp_dooptions(struct tcpopt *, u_char *, int, int);
1366 void	tcp_dropwithreset(struct mbuf *, struct tcphdr *,
1367 		     struct tcpcb *, int, int);
1368 void	tcp_pulloutofband(struct socket *,
1369 		     struct tcphdr *, struct mbuf *, int);
1370 void	tcp_xmit_timer(struct tcpcb *, int);
1371 void	tcp_newreno_partial_ack(struct tcpcb *, struct tcphdr *);
1372 void	cc_ack_received(struct tcpcb *tp, struct tcphdr *th,
1373 			    uint16_t nsegs, uint16_t type);
1374 void 	cc_conn_init(struct tcpcb *tp);
1375 void 	cc_post_recovery(struct tcpcb *tp, struct tcphdr *th);
1376 void    cc_ecnpkt_handler(struct tcpcb *tp, struct tcphdr *th, uint8_t iptos);
1377 void	cc_ecnpkt_handler_flags(struct tcpcb *tp, uint16_t flags, uint8_t iptos);
1378 void	cc_cong_signal(struct tcpcb *tp, struct tcphdr *th, uint32_t type);
1379 #ifdef TCP_HHOOK
1380 void	hhook_run_tcp_est_in(struct tcpcb *tp,
1381 			    struct tcphdr *th, struct tcpopt *to);
1382 #endif
1383 
1384 int	 tcp_input(struct mbuf **, int *, int);
1385 int	 tcp_autorcvbuf(struct mbuf *, struct tcphdr *, struct socket *,
1386 	    struct tcpcb *, int);
1387 int	 tcp_input_with_port(struct mbuf **, int *, int, uint16_t);
1388 void	tcp_do_segment(struct tcpcb *, struct mbuf *, struct tcphdr *, int,
1389     int, uint8_t);
1390 
1391 int register_tcp_functions(struct tcp_function_block *blk, int wait);
1392 int register_tcp_functions_as_names(struct tcp_function_block *blk,
1393     int wait, const char *names[], int *num_names);
1394 int register_tcp_functions_as_name(struct tcp_function_block *blk,
1395     const char *name, int wait);
1396 int deregister_tcp_functions(struct tcp_function_block *blk, bool quiesce,
1397     bool force);
1398 struct tcp_function_block *find_and_ref_tcp_functions(struct tcp_function_set *fs);
1399 int find_tcp_function_alias(struct tcp_function_block *blk, struct tcp_function_set *fs);
1400 uint32_t tcp_get_srtt(struct tcpcb *tp, int granularity);
1401 void tcp_switch_back_to_default(struct tcpcb *tp);
1402 struct tcp_function_block *
1403 find_and_ref_tcp_fb(struct tcp_function_block *fs);
1404 int tcp_default_ctloutput(struct tcpcb *tp, struct sockopt *sopt);
1405 int tcp_ctloutput_set(struct inpcb *inp, struct sockopt *sopt);
1406 void tcp_log_socket_option(struct tcpcb *tp, uint32_t option_num,
1407     uint32_t option_val, int err);
1408 
1409 
1410 extern counter_u64_t tcp_inp_lro_direct_queue;
1411 extern counter_u64_t tcp_inp_lro_wokeup_queue;
1412 extern counter_u64_t tcp_inp_lro_compressed;
1413 extern counter_u64_t tcp_inp_lro_locks_taken;
1414 extern counter_u64_t tcp_extra_mbuf;
1415 extern counter_u64_t tcp_would_have_but;
1416 extern counter_u64_t tcp_comp_total;
1417 extern counter_u64_t tcp_uncomp_total;
1418 extern counter_u64_t tcp_bad_csums;
1419 
1420 #ifdef TCP_SAD_DETECTION
1421 /* Various SACK attack thresholds */
1422 extern int32_t tcp_force_detection;
1423 extern int32_t tcp_sad_limit;
1424 extern int32_t tcp_sack_to_ack_thresh;
1425 extern int32_t tcp_sack_to_move_thresh;
1426 extern int32_t tcp_restoral_thresh;
1427 extern int32_t tcp_sad_decay_val;
1428 extern int32_t tcp_sad_pacing_interval;
1429 extern int32_t tcp_sad_low_pps;
1430 extern int32_t tcp_map_minimum;
1431 extern int32_t tcp_attack_on_turns_on_logging;
1432 #endif
1433 extern uint32_t tcp_ack_war_time_window;
1434 extern uint32_t tcp_ack_war_cnt;
1435 
1436 /*
1437  * Used by tcp_maxmtu() to communicate interface specific features
1438  * and limits at the time of connection setup.
1439  */
1440 struct tcp_ifcap {
1441 	int	ifcap;
1442 	u_int	tsomax;
1443 	u_int	tsomaxsegcount;
1444 	u_int	tsomaxsegsize;
1445 };
1446 uint32_t tcp_maxmtu(struct in_conninfo *, struct tcp_ifcap *);
1447 uint32_t tcp_maxmtu6(struct in_conninfo *, struct tcp_ifcap *);
1448 
1449 void	 tcp6_use_min_mtu(struct tcpcb *);
1450 u_int	 tcp_maxseg(const struct tcpcb *);
1451 u_int	 tcp_fixed_maxseg(const struct tcpcb *);
1452 void	 tcp_mss_update(struct tcpcb *, int, int, struct hc_metrics_lite *,
1453 	    struct tcp_ifcap *);
1454 void	 tcp_mss(struct tcpcb *, int);
1455 int	 tcp_mssopt(struct in_conninfo *);
1456 struct tcpcb *
1457 	 tcp_newtcpcb(struct inpcb *);
1458 int	 tcp_default_output(struct tcpcb *);
1459 void	 tcp_state_change(struct tcpcb *, int);
1460 void	 tcp_respond(struct tcpcb *, void *,
1461 	    struct tcphdr *, struct mbuf *, tcp_seq, tcp_seq, uint16_t);
1462 bool	 tcp_twcheck(struct inpcb *, struct tcpopt *, struct tcphdr *,
1463 	    struct mbuf *, int);
1464 void	 tcp_setpersist(struct tcpcb *);
1465 void	 tcp_record_dsack(struct tcpcb *tp, tcp_seq start, tcp_seq end, int tlp);
1466 struct tcptemp *
1467 	 tcpip_maketemplate(struct inpcb *);
1468 void	 tcpip_fillheaders(struct inpcb *, uint16_t, void *, void *);
1469 void	 tcp_timer_activate(struct tcpcb *, tt_which, u_int);
1470 bool	 tcp_timer_active(struct tcpcb *, tt_which);
1471 void	 tcp_timer_stop(struct tcpcb *);
1472 int	 inp_to_cpuid(struct inpcb *inp);
1473 /*
1474  * All tcp_hc_* functions are IPv4 and IPv6 (via in_conninfo)
1475  */
1476 void	 tcp_hc_init(void);
1477 #ifdef VIMAGE
1478 void	 tcp_hc_destroy(void);
1479 #endif
1480 void	 tcp_hc_get(struct in_conninfo *, struct hc_metrics_lite *);
1481 uint32_t tcp_hc_getmtu(struct in_conninfo *);
1482 void	 tcp_hc_updatemtu(struct in_conninfo *, uint32_t);
1483 void	 tcp_hc_update(struct in_conninfo *, struct hc_metrics_lite *);
1484 void 	 cc_after_idle(struct tcpcb *tp);
1485 
1486 extern	struct protosw tcp_protosw;		/* shared for TOE */
1487 extern	struct protosw tcp6_protosw;		/* shared for TOE */
1488 
1489 uint32_t tcp_new_ts_offset(struct in_conninfo *);
1490 tcp_seq	 tcp_new_isn(struct in_conninfo *);
1491 
1492 sackstatus_t
1493 	 tcp_sack_doack(struct tcpcb *, struct tcpopt *, tcp_seq);
1494 int	 tcp_dsack_block_exists(struct tcpcb *);
1495 void	 tcp_update_dsack_list(struct tcpcb *, tcp_seq, tcp_seq);
1496 void	 tcp_update_sack_list(struct tcpcb *tp, tcp_seq rcv_laststart,
1497 	    tcp_seq rcv_lastend);
1498 void	 tcp_clean_dsack_blocks(struct tcpcb *tp);
1499 void	 tcp_clean_sackreport(struct tcpcb *tp);
1500 void	 tcp_sack_adjust(struct tcpcb *tp);
1501 struct sackhole *tcp_sack_output(struct tcpcb *tp, int *sack_bytes_rexmt);
1502 void	 tcp_do_prr_ack(struct tcpcb *, struct tcphdr *, struct tcpopt *,
1503 	    sackstatus_t, u_int *);
1504 void	 tcp_lost_retransmission(struct tcpcb *, struct tcphdr *);
1505 void	 tcp_sack_partialack(struct tcpcb *, struct tcphdr *, u_int *);
1506 void	 tcp_resend_sackholes(struct tcpcb *tp);
1507 void	 tcp_free_sackholes(struct tcpcb *tp);
1508 void	 tcp_sack_lost_retransmission(struct tcpcb *, struct tcphdr *);
1509 int	 tcp_newreno(struct tcpcb *, struct tcphdr *);
1510 int	 tcp_compute_pipe(struct tcpcb *);
1511 uint32_t tcp_compute_initwnd(uint32_t);
1512 void	 tcp_sndbuf_autoscale(struct tcpcb *, struct socket *, uint32_t);
1513 int	 tcp_stats_sample_rollthedice(struct tcpcb *tp, void *seed_bytes,
1514     size_t seed_len);
1515 int tcp_can_enable_pacing(void);
1516 int tcp_incr_dgp_pacing_cnt(void);
1517 void tcp_dec_dgp_pacing_cnt(void);
1518 void tcp_decrement_paced_conn(void);
1519 void tcp_change_time_units(struct tcpcb *, int);
1520 void tcp_handle_orphaned_packets(struct tcpcb *);
1521 
1522 struct mbuf *
1523 	 tcp_m_copym(struct mbuf *m, int32_t off0, int32_t *plen,
1524 	   int32_t seglimit, int32_t segsize, struct sockbuf *sb, bool hw_tls);
1525 
1526 int	tcp_stats_init(void);
1527 void tcp_log_end_status(struct tcpcb *tp, uint8_t status);
1528 #ifdef TCP_REQUEST_TRK
1529 void tcp_req_free_a_slot(struct tcpcb *tp, struct tcp_sendfile_track *ent);
1530 struct tcp_sendfile_track *
1531 tcp_req_find_a_req_that_is_completed_by(struct tcpcb *tp, tcp_seq th_ack, int *ip);
1532 int tcp_req_check_for_comp(struct tcpcb *tp, tcp_seq ack_point);
1533 int
1534 tcp_req_is_entry_comp(struct tcpcb *tp, struct tcp_sendfile_track *ent, tcp_seq ack_point);
1535 struct tcp_sendfile_track *
1536 tcp_req_find_req_for_seq(struct tcpcb *tp, tcp_seq seq);
1537 void
1538 tcp_req_log_req_info(struct tcpcb *tp,
1539     struct tcp_sendfile_track *req, uint16_t slot,
1540     uint8_t val, uint64_t offset, uint64_t nbytes);
1541 
1542 uint32_t
1543 tcp_estimate_tls_overhead(struct socket *so, uint64_t tls_usr_bytes);
1544 void
1545 tcp_req_alloc_req(struct tcpcb *tp, union tcp_log_userdata *user,
1546     uint64_t ts);
1547 
1548 struct tcp_sendfile_track *
1549 tcp_req_alloc_req_full(struct tcpcb *tp, struct tcp_snd_req *req, uint64_t ts, int rec_dups);
1550 
1551 
1552 #endif
1553 #ifdef TCP_ACCOUNTING
1554 int tcp_do_ack_accounting(struct tcpcb *tp, struct tcphdr *th, struct tcpopt *to, uint32_t tiwin, int mss);
1555 #endif
1556 
1557 static inline void
1558 tcp_lro_features_off(struct tcpcb *tp)
1559 {
1560 	tp->t_flags2 &= ~(TF2_SUPPORTS_MBUFQ|
1561 	    TF2_MBUF_QUEUE_READY|
1562 	    TF2_DONT_SACK_QUEUE|
1563 	    TF2_MBUF_ACKCMP|
1564 	    TF2_MBUF_L_ACKS);
1565 }
1566 
1567 static inline void
1568 tcp_fields_to_host(struct tcphdr *th)
1569 {
1570 
1571 	th->th_seq = ntohl(th->th_seq);
1572 	th->th_ack = ntohl(th->th_ack);
1573 	th->th_win = ntohs(th->th_win);
1574 	th->th_urp = ntohs(th->th_urp);
1575 }
1576 
1577 static inline void
1578 tcp_fields_to_net(struct tcphdr *th)
1579 {
1580 
1581 	th->th_seq = htonl(th->th_seq);
1582 	th->th_ack = htonl(th->th_ack);
1583 	th->th_win = htons(th->th_win);
1584 	th->th_urp = htons(th->th_urp);
1585 }
1586 #endif /* _KERNEL */
1587 
1588 #endif /* _NETINET_TCP_VAR_H_ */
1589