1 /*
2 * Copyright (c) 2000-2024 Apple Inc. All rights reserved.
3 *
4 * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
5 *
6 * This file contains Original Code and/or Modifications of Original Code
7 * as defined in and that are subject to the Apple Public Source License
8 * Version 2.0 (the 'License'). You may not use this file except in
9 * compliance with the License. The rights granted to you under the License
10 * may not be used to create, or enable the creation or redistribution of,
11 * unlawful or unlicensed copies of an Apple operating system, or to
12 * circumvent, violate, or enable the circumvention or violation of, any
13 * terms of an Apple operating system software license agreement.
14 *
15 * Please obtain a copy of the License at
16 * http://www.opensource.apple.com/apsl/ and read it before using this file.
17 *
18 * The Original Code and all software distributed under the License are
19 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
20 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
21 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
22 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
23 * Please see the License for the specific language governing rights and
24 * limitations under the License.
25 *
26 * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
27 */
28 /*
29 * Copyright (c) 1982, 1986, 1993, 1994, 1995
30 * The Regents of the University of California. All rights reserved.
31 *
32 * Redistribution and use in source and binary forms, with or without
33 * modification, are permitted provided that the following conditions
34 * are met:
35 * 1. Redistributions of source code must retain the above copyright
36 * notice, this list of conditions and the following disclaimer.
37 * 2. Redistributions in binary form must reproduce the above copyright
38 * notice, this list of conditions and the following disclaimer in the
39 * documentation and/or other materials provided with the distribution.
40 * 3. All advertising materials mentioning features or use of this software
41 * must display the following acknowledgement:
42 * This product includes software developed by the University of
43 * California, Berkeley and its contributors.
44 * 4. Neither the name of the University nor the names of its contributors
45 * may be used to endorse or promote products derived from this software
46 * without specific prior written permission.
47 *
48 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
49 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
50 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
51 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
52 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
53 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
54 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
55 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
56 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
57 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
58 * SUCH DAMAGE.
59 *
60 * @(#)tcp_var.h 8.4 (Berkeley) 5/24/95
61 * $FreeBSD: src/sys/netinet/tcp_var.h,v 1.56.2.8 2001/08/22 00:59:13 silby Exp $
62 */
63
64 #ifndef _NETINET_TCP_VAR_H_
65 #define _NETINET_TCP_VAR_H_
66 #include <stdint.h>
67 #include <sys/types.h>
68 #include <sys/appleapiopts.h>
69 #include <sys/queue.h>
70 #include <netinet/in_pcb.h>
71 #include <netinet/tcp.h>
72 #include <netinet/tcp_timer.h>
73 #if !KERNEL
74 #include <TargetConditionals.h>
75 #endif
76
77 #if defined(__LP64__)
78 #define _TCPCB_PTR(x) u_int32_t
79 #define _TCPCB_LIST_HEAD(name, type) \
80 struct name { \
81 u_int32_t lh_first; \
82 }
83 #else
84 #define _TCPCB_PTR(x) x
85 #define _TCPCB_LIST_HEAD(name, type) LIST_HEAD(name, type)
86 #endif
87
88 #ifdef KERNEL_PRIVATE
89 #include <sys/tree.h>
90
91 #define TCP_RETRANSHZ 1000 /* granularity of TCP timestamps, 1ms */
92 /* Minimum time quantum within which the timers are coalesced */
93 #define TCP_TIMER_10MS_QUANTUM (TCP_RETRANSHZ/100) /* every 10ms */
94 #define TCP_TIMER_100MS_QUANTUM (TCP_RETRANSHZ/10) /* every 100ms */
95 #define TCP_TIMER_500MS_QUANTUM (TCP_RETRANSHZ/2) /* every 500ms */
96
97 #define TCP_RETRANSHZ_TO_USEC 1000
98
99 #define N_TIME_WAIT_SLOTS 128 /* must be power of 2 */
100
101 /* Always allow at least 16 packets worth of recv window when adjusting
102 * recv window using inter-packet arrival jitter.
103 */
104 #define MIN_IAJ_WIN 16
105
106 /* A variation in delay of this many milliseconds is tolerable. This limit has to
107 * be low but greater than zero. We also use standard deviation on jitter to adjust
108 * this limit for different link and connection types.
109 */
110 #define ALLOWED_IAJ 5
111
112 /* Ignore the first few packets on a connection until the ACK clock gets going
113 */
114 #define IAJ_IGNORE_PKTCNT 40
115
116 /* Let the accumulated IAJ value increase by this threshold at most. This limit
117 * will control how many ALLOWED_IAJ measurements a receiver will have to see
118 * before opening the receive window
119 */
120 #define ACC_IAJ_HIGH_THRESH 100
121
122 /* When accumulated IAJ reaches this value, the receiver starts to react by
123 * closing the window
124 */
125 #define ACC_IAJ_REACT_LIMIT 200
126
127 /* If the number of small packets (smaller than IAJ packet size) seen on a
128 * connection is more than this threshold, reset the size and learn it again.
129 * This is needed because the sender might send smaller segments after PMTU
130 * discovery and the receiver has to learn the new size.
131 */
132 #define RESET_IAJ_SIZE_THRESH 20
133
134 /*
135 * Adaptive timeout is a read/write timeout specified by the application to
136 * get a socket event when the transport layer detects a stall in data
137 * transfer. The value specified is the number of probes that can be sent
138 * to the peer before generating an event. Since it is not specified as
139 * a time value, the timeout will adjust based on the RTT seen on the link.
140 * The timeout will start only when there is an indication that the read/write
141 * operation is not making progress.
142 *
143 * If a write operation stalls, the probe will be retransmission of data.
144 * If a read operation stalls, the probe will be a keep-alive packet.
145 *
146 * The maximum value of adaptive timeout is set to 10 which will allow
147 * transmission of enough number of probes to the peer.
148 */
149 #define TCP_ADAPTIVE_TIMEOUT_MAX 10
150
151 #define TCP_CONNECTIVITY_PROBES_MAX 5
152
153 /* 3 bit mask used for Accurate ECN ACE field */
154 #define TCP_ACE_MASK (0x7)
155 /* Divisor used for Accurate ECN ACE field */
156 #define TCP_ACE_DIV (1 << 3)
157
158 /* 24 bit mask used for Accurate ECN option */
159 #define TCP_ACO_MASK (0xFFFFFF)
160 /* Divisor used for Accurate ECN options field */
161 #define TCP_ACO_DIV (1 << 24)
162
163 static __inline uint16_t
tcp_get_flags(const struct tcphdr * th)164 tcp_get_flags(const struct tcphdr *th)
165 {
166 return (uint16_t)((th->th_x2 << 8) | th->th_flags);
167 }
168
169 static __inline void
tcp_set_flags(struct tcphdr * th,uint16_t flags)170 tcp_set_flags(struct tcphdr *th, uint16_t flags)
171 {
172 th->th_x2 = (flags >> 8) & 0x0f;
173 th->th_flags = flags & 0xff;
174 }
175
176 /*
177 * Kernel variables for tcp.
178 */
179
180 /* TCP segment queue entry */
181 struct tseg_qent {
182 LIST_ENTRY(tseg_qent) tqe_q;
183 int tqe_len; /* TCP segment data length */
184 struct tcphdr *tqe_th; /* a pointer to tcp header */
185 struct mbuf *tqe_m; /* mbuf contains packet */
186 };
187 LIST_HEAD(tsegqe_head, tseg_qent);
188
189 struct sackblk {
190 tcp_seq start; /* start seq no. of sack block */
191 tcp_seq end; /* end seq no. */
192 };
193
194 struct sackhole {
195 tcp_seq start; /* start seq no. of hole */
196 tcp_seq end; /* end seq no. */
197 tcp_seq rxmit; /* next seq. no in hole to be retransmitted */
198 u_int32_t rxmit_start; /* timestamp of first retransmission */
199 TAILQ_ENTRY(sackhole) scblink; /* scoreboard linkage */
200 };
201
202 struct sackhint {
203 struct sackhole *nexthole;
204 int sack_bytes_rexmit;
205 int sack_bytes_acked;
206 };
207
208 struct tcp_rxt_seg {
209 tcp_seq rx_start;
210 tcp_seq rx_end;
211 u_int16_t rx_count;
212 u_int16_t rx_flags;
213 #define TCP_RXT_SPURIOUS 0x1 /* received DSACK notification */
214 SLIST_ENTRY(tcp_rxt_seg) rx_link;
215 };
216
217 /* TCP state of a segment that was sent */
218 struct tcp_seg_sent {
219 tcp_seq start_seq;
220 tcp_seq end_seq; /* last seq sent + 1 */
221 uint32_t xmit_ts;
222 uint8_t flags;
223 uint8_t pad[3];
224 #define TCP_SEGMENT_SACKED 0x1
225 #define TCP_SEGMENT_LOST 0x2
226 #define TCP_RACK_RETRANSMITTED 0x4
227 #define TCP_SEGMENT_RETRANSMITTED_ATLEAST_ONCE 0x8 /* If a segment was retransmitted at least once; used for reordering detection and to avoid spurious inferences for RACK.rtt */
228 #define TCP_SEGMENT_RETRANSMITTED (TCP_RACK_RETRANSMITTED | TCP_SEGMENT_RETRANSMITTED_ATLEAST_ONCE)
229
230 TAILQ_ENTRY(tcp_seg_sent) tx_link; /* Time ordered list of segments */
231 RB_ENTRY(tcp_seg_sent) seg_link; /* RB tree to keep track of S/ACKed segments */
232 TAILQ_ENTRY(tcp_seg_sent) ack_link; /* List of ACKed segments to be deleted from time ordered list and RB tree */
233 TAILQ_ENTRY(tcp_seg_sent) free_link; /* List of free segments from the pool */
234 };
235
236 typedef struct tcp_seg_pool {
237 TAILQ_HEAD(, tcp_seg_sent) free_segs;
238 uint32_t free_segs_count;
239 char pad[4];
240 } *tcp_seg_pool_t;
241
242 #define TCP_SEG_POOL_MAX_ITEM_COUNT (64)
243
244 int tcp_seg_cmp(const struct tcp_seg_sent *, const struct tcp_seg_sent *);
245
246 RB_HEAD(tcp_seg_sent_tree_head, tcp_seg_sent);
247 RB_PROTOTYPE(tcp_seg_sent_tree_head, tcp_seg_sent, seg_link, tcp_seg_cmp)
248
249 struct tcp_notify_ack_marker {
250 tcp_seq notify_snd_una; /* Notify when snd_una crosses this seq */
251 tcp_notify_ack_id_t notify_id;
252 SLIST_ENTRY(tcp_notify_ack_marker) notify_next;
253 };
254
255 struct tcptemp {
256 u_char tt_ipgen[40]; /* the size must be of max ip header, now IPv6 */
257 struct tcphdr tt_t;
258 };
259
260 struct tcp_inp {
261 struct socket *so;
262 struct inpcb **inp;
263 struct tcpcb **tp;
264 struct mbuf *m;
265 struct tcphdr *th;
266 struct tcpopt *to;
267 u_char *optp __counted_by(optlen);
268 struct ip6_hdr *ip6;
269 struct ip *ip;
270 struct ifnet *ifp;
271 struct proc *kernel_proc;
272 tcp_seq iss;
273 tcp_seq irs;
274 uint32_t tiwin;
275 uint32_t ts_offset;
276 int optlen;
277 unsigned int ifscope;
278 uint16_t peer_mss;
279 uint8_t peer_wscale;
280 bool sackok;
281 bool ecnok;
282 uint8_t ip_ecn;
283 bool isipv6;
284 };
285
286 struct bwmeas {
287 tcp_seq bw_start; /* start of bw measurement */
288 uint32_t bw_ts; /* timestamp when bw measurement started */
289 uint32_t bw_size; /* burst size in bytes for this bw measurement */
290 uint32_t bw_minsizepkts; /* Min burst size as segments */
291 uint32_t bw_maxsizepkts; /* Max burst size as segments */
292 uint32_t bw_minsize; /* Min size in bytes */
293 uint32_t bw_maxsize; /* Max size in bytes */
294 uint32_t bw_sndbw; /* Measured send bandwidth */
295 uint32_t bw_sndbw_max; /* Max measured bandwidth */
296 uint32_t bw_rcvbw_max; /* Max receive bandwidth measured */
297 };
298
299 /* MPTCP Data sequence map entry */
300 struct mpt_dsn_map {
301 uint64_t mpt_dsn; /* data seq num recvd */
302 uint32_t mpt_sseq; /* relative subflow # */
303 uint16_t mpt_len; /* length of mapping */
304 uint16_t mpt_csum; /* checksum value if on */
305 uint8_t mpt_dfin; /* It's a DATA_FIN */
306 };
307 #define tcp6cb tcpcb /* for KAME src sync over BSD*'s */
308
309 struct tcp_ccstate {
310 union {
311 struct tcp_cubic_state {
312 u_int32_t tc_last_max; /* cwnd at last loss */
313 u_int32_t tc_epoch_start; /* TS of last loss */
314 u_int32_t tc_origin_point; /* window at the start of an epoch */
315 u_int32_t tc_tcp_win; /* computed tcp win */
316 u_int32_t tc_tcp_bytes_acked; /* bytes acked */
317 u_int32_t tc_avg_lastmax; /* Average of last max */
318 u_int32_t tc_mean_deviation; /* Mean absolute deviation */
319 float tc_epoch_period; /* K parameter */
320 } _cubic_state_;
321 #define cub_last_max __u__._cubic_state_.tc_last_max
322 #define cub_epoch_start __u__._cubic_state_.tc_epoch_start
323 #define cub_origin_point __u__._cubic_state_.tc_origin_point
324 #define cub_tcp_win __u__._cubic_state_.tc_tcp_win
325 #define cub_tcp_bytes_acked __u__._cubic_state_.tc_tcp_bytes_acked
326 #define cub_epoch_period __u__._cubic_state_.tc_epoch_period
327 #define cub_avg_lastmax __u__._cubic_state_.tc_avg_lastmax
328 #define cub_mean_dev __u__._cubic_state_.tc_mean_deviation
329 struct tcp_prague_state {
330 uint16_t num_cong_events_loss;
331 uint16_t num_cong_events_ce;
332 uint32_t packets_acked; /* cumulative packets ack'ed updated at round start for alpha */
333 uint32_t packets_marked; /* cumulative CE counts updated at round start for alpha */
334 uint32_t ce_counter; /* cumulative CE counts updated on every ACK,
335 * used for calculating non-CE acked and performing any CE related action */
336 uint32_t bytes_acked; /* bytes acked in this ACK that were not CE marked, used for cwnd increase */
337 uint32_t snd_nxt_alpha; /* snd_nxt at round start to track 1 RTT elapsed for alpha */
338 uint32_t snd_nxt_cwr; /* snd_nxt at round start to track 1 RTT elapsed for CWR */
339 uint8_t ever_saw_ce:1, /* To test if there is a AQM on path */
340 in_loss:1, /* Are we in loss recovery */
341 reduced_due_to_ce:1, /* Was the last reduction due to CE */
342 unused:5;
343 uint8_t pad[3];
344 uint64_t scaled_alpha; /* Scaled value of DCTCP.alpha */
345 uint64_t alpha_ai; /* AI.alpha used after CE for additive increase */
346 /* After reduction due to loss CUBIC window increase state */
347 struct tcp_cubic_state cubic_state;
348 } _prague_state_;
349 #define num_cong_events_loss __u__._prague_state_.num_cong_events_loss
350 #define num_cong_events_ce __u__._prague_state_.num_cong_events_ce
351 #define prague_packets_acked __u__._prague_state_.packets_acked
352 #define prague_packets_marked __u__._prague_state_.packets_marked
353 #define prague_ce_counter __u__._prague_state_.ce_counter
354 #define prague_bytes_acked __u__._prague_state_.bytes_acked
355 #define snd_nxt_alpha __u__._prague_state_.snd_nxt_alpha
356 #define snd_nxt_cwr __u__._prague_state_.snd_nxt_cwr
357 #define prague_scaled_alpha __u__._prague_state_.scaled_alpha
358 #define prague_alpha_ai __u__._prague_state_.alpha_ai
359 #define ever_saw_ce __u__._prague_state_.ever_saw_ce
360 #define in_loss __u__._prague_state_.in_loss
361 #define reduced_due_to_ce __u__._prague_state_.reduced_due_to_ce
362 #define cubic_K __u__._prague_state_.cubic_state.tc_epoch_period
363 #define cubic_epoch_start __u__._prague_state_.cubic_state.tc_epoch_start
364 #define cubic_origin_point __u__._prague_state_.cubic_state.tc_origin_point
365 #define cubic_W_max __u__._prague_state_.cubic_state.tc_last_max
366 #define reno_acked __u__._prague_state_.cubic_state.tc_tcp_bytes_acked
367 #define reno_cwnd __u__._prague_state_.cubic_state.tc_tcp_win
368 struct tcp_ledbat_state {
369 uint32_t num_slowdown_events;
370 uint32_t slowdown_ts;
371 uint32_t slowdown_begin;
372 uint32_t md_bytes_acked;
373 } _ledbat_state_;
374 #define ledbat_slowdown_events __u__._ledbat_state_.num_slowdown_events
375 #define ledbat_slowdown_ts __u__._ledbat_state_.slowdown_ts
376 #define ledbat_slowdown_begin __u__._ledbat_state_.slowdown_begin
377 #define ledbat_md_bytes_acked __u__._ledbat_state_.md_bytes_acked
378 } __u__;
379 };
380
381 struct tcp_rledbat_state {
382 uint32_t num_slowdown_events; /* Number of slowdown events until reset */
383 uint32_t slowdown_ts; /* Next slowdown timestamp */
384 uint32_t slowdown_begin; /* Slowdown begin time */
385 uint32_t reduction_end; /* Used to track rl_win reduction once per RTT */
386 uint32_t rcvd_bytes; /* bytes received used for byte counting */
387 uint32_t md_rcvd_bytes; /* bytes received during MD used for byte counting */
388 uint32_t win; /* receive Ledbat window size */
389 uint32_t ssthresh; /* receive Ledbat ssthresh */
390 uint32_t drained_bytes; /* bytes drained from the flight-size */
391 uint32_t win_ws; /* receive Ledbat window after avoiding window shrinking */
392 };
393
394 struct accecn {
395 /* ACE CE packet counters */
396 uint32_t t_rcv_ce_packets; /* Number of CE received packets at the receiver */
397 uint32_t t_snd_ce_packets; /* Synced number of CE received feedback at the sender */
398 uint32_t t_delta_ce_packets; /* Change in CE count between previous and current ACK */
399 uint8_t accecn_processed:1, /* Accurate ECN feedback has already been processed */
400 unused:7;
401
402 /* AccECN option byte counters */
403 uint64_t t_rcv_ect1_bytes; /* ECT1 byte counter at the receiver, used for AccECN option feedback */
404 uint64_t t_rcv_ect0_bytes; /* ECT0 byte counter at the receiver, used for AccECN option feedback */
405 uint64_t t_rcv_ce_bytes; /* CE byte counter at the receiver, used for AccECN option feedback */
406 uint64_t t_snd_ect1_bytes; /* Synced ECT1 byte counter at the sender */
407 uint64_t t_snd_ect0_bytes; /* Synced ECT0 byte counter at the sender */
408 uint64_t t_snd_ce_bytes; /* Synced CE byte counter at the sender */
409 };
410
411 struct pacer {
412 uint64_t rate;
413 uint32_t tso_burst_size; /* maximum allowed burst size, segments that fit in a burst have the same Tx timestamp */
414 uint32_t current_size; /* track how many bytes have been accumulated in a burst */
415 uint64_t packet_tx_time;
416 };
417
418 /*
419 * Tcp control block, one per tcp; fields:
420 * Organized for 16 byte cacheline efficiency.
421 */
422 struct tcpcb {
423 struct tsegqe_head t_segq;
424 uint32_t t_dupacks; /* consecutive dup acks recd */
425 int t_state; /* state of this connection */
426 uint32_t t_timer[TCPT_NTIMERS]; /* tcp timers */
427 struct tcptimerentry tentry; /* entry in timer list */
428
429 struct inpcb *t_inpcb; /* back pointer to internet pcb */
430 uint32_t t_flags;
431 #define TF_ACKNOW 0x00001 /* ack peer immediately */
432 #define TF_DELACK 0x00002 /* ack, but try to delay it */
433 #define TF_NODELAY 0x00004 /* don't delay packets to coalesce */
434 #define TF_NOOPT 0x00008 /* don't use tcp options */
435 #define TF_SENTFIN 0x00010 /* have sent FIN */
436 #define TF_REQ_SCALE 0x00020 /* have/will request window scaling */
437 #define TF_RCVD_SCALE 0x00040 /* other side has requested scaling */
438 #define TF_REQ_TSTMP 0x00080 /* have/will request timestamps */
439 #define TF_RCVD_TSTMP 0x00100 /* a timestamp was received in SYN */
440 #define TF_SACK_PERMIT 0x00200 /* other side said I could SACK */
441 #define TF_NEEDSYN 0x00400 /* send SYN (implicit state) - unused but needed for backwards compatibility */
442 #define TF_NEEDFIN 0x00800 /* send FIN (implicit state) */
443 #define TF_NOPUSH 0x01000 /* don't push */
444 #define TF_UNUSED1 0x02000 /* Unused */
445 #define TF_UNUSED2 0x04000 /* Unused */
446 #define TF_UNUSED3 0x08000 /* Unused */
447 #define TF_MORETOCOME 0x10000 /* More data to be appended to sock */
448 #define TF_LOCAL 0x20000 /* connection to a host on local link */
449 #define TF_RXWIN0SENT 0x40000 /* sent a receiver win 0 in response */
450 #define TF_SLOWLINK 0x80000 /* route is a on a modem speed link */
451 #define TF_LASTIDLE 0x100000 /* connection was previously idle */
452 #define TF_FASTRECOVERY 0x200000 /* in NewReno Fast Recovery */
453 #define TF_WASFRECOVERY 0x400000 /* was in NewReno Fast Recovery */
454 #define TF_SIGNATURE 0x800000 /* require MD5 digests (RFC2385) */
455 #define TF_MAXSEGSNT 0x1000000 /* last segment sent was a full segment */
456 /* Unused 0x2000000 */
457 #define TF_PMTUD 0x4000000 /* Perform Path MTU Discovery for this connection */
458 #define TF_CLOSING 0x8000000 /* pending tcp close */
459 #define TF_TSO 0x10000000 /* TCP Segment Offloading is enable on this connection */
460 #define TF_BLACKHOLE 0x20000000 /* Path MTU Discovery Black Hole detection */
461 #define TF_TIMER_ONLIST 0x40000000 /* pcb is on tcp_timer_list */
462 /* Unused 0x80000000 */
463
464 tcp_seq snd_una; /* send unacknowledged */
465 tcp_seq snd_max; /* highest sequence number sent;
466 * used to recognize retransmits
467 */
468 tcp_seq snd_nxt; /* send next */
469 tcp_seq snd_up; /* send urgent pointer */
470
471 tcp_seq snd_wl1; /* window update seg seq number */
472 tcp_seq snd_wl2; /* window update seg ack number */
473 tcp_seq iss; /* initial send sequence number */
474 tcp_seq irs; /* initial receive sequence number */
475
476 tcp_seq rcv_nxt; /* receive next */
477 tcp_seq rcv_adv; /* advertised window */
478 uint32_t rcv_wnd; /* receive window */
479 uint32_t t_last_recwin;
480 tcp_seq rcv_up; /* receive urgent pointer */
481 uint32_t t_latest_tx; /* Most recent transmit scheduled (including potential pacing) */
482
483 uint32_t snd_wnd; /* send window */
484 uint32_t snd_cwnd; /* congestion-controlled window */
485 uint32_t snd_ssthresh; /* snd_cwnd size threshold for
486 * for slow start exponential to
487 * linear switch
488 */
489 tcp_seq snd_recover; /* for use in NewReno Fast Recovery */
490
491 uint32_t t_maxopd; /* mss plus options */
492 uint32_t t_rcvtime; /* time at which a packet was received */
493 uint32_t t_sndtime; /* time at which we last sent new data */
494 uint32_t t_starttime; /* time connection was established */
495 int t_rtttime; /* tcp clock when rtt calculation was started */
496 tcp_seq t_rtseq; /* sequence number being timed */
497
498 uint32_t rfbuf_ts; /* recv buffer autoscaling timestamp */
499 uint32_t rfbuf_cnt; /* recv buffer autoscaling byte count */
500 uint32_t rfbuf_space; /* Current "ideal" estimate of the space */
501
502 int t_rxtcur; /* current retransmit value (ticks) */
503 unsigned int t_maxseg; /* maximum segment size */
504 int t_srtt; /* smoothed round-trip time */
505 int t_rttvar; /* variance in round-trip time */
506
507 uint64_t t_accsleep_ms; /* accumulated sleep time since last boot */
508 uint32_t t_reassqlen; /* length of reassembly queue */
509 uint32_t t_reassq_mbcnt; /* amount in bytes of mbuf space used */
510 uint16_t t_rxtshift; /* log(2) of rexmt exp. backoff */
511 uint32_t t_rttmin; /* minimum rtt allowed */
512 uint32_t t_rttbest; /* best rtt we've seen */
513 uint32_t t_rttcur; /* most recent value of rtt */
514 uint32_t t_rttupdated; /* number of times rtt sampled */
515 uint32_t t_rxt_conndroptime; /* retxmt conn gets dropped after this time, when set */
516 uint32_t t_rxtstart; /* time at which retransmission started */
517 uint32_t max_sndwnd; /* largest window peer has offered */
518
519 int t_softerror; /* possible error not yet reported */
520 /* out-of-band data */
521 char t_oobflags; /* have some */
522 char t_iobc; /* input character */
523 #define TCPOOB_HAVEDATA 0x01
524 #define TCPOOB_HADDATA 0x02
525 /* RFC 1323 variables */
526 uint8_t snd_scale; /* window scaling for send window */
527 uint8_t rcv_scale; /* window scaling for recv window */
528 uint8_t request_r_scale; /* pending window scaling */
529 uint8_t requested_s_scale;
530 uint8_t tcp_cc_index; /* index of congestion control algorithm */
531 uint8_t t_adaptive_rtimo; /* Read timeout used as a multiple of RTT */
532 uint8_t t_adaptive_wtimo; /* Write timeout used as a multiple of RTT */
533
534 /* State for limiting early retransmits when SACK is not enabled */
535 uint16_t t_early_rexmt_count; /* count of early rexmts */
536 uint32_t t_early_rexmt_win; /* window for limiting early rexmts */
537
538 uint32_t ts_recent; /* timestamp echo data */
539 uint32_t t_ts_offset; /* Randomized timestamp offset to hide on-the-wire timestamp */
540
541 uint32_t ts_recent_age; /* when last updated */
542 tcp_seq last_ack_sent;
543
544 uint32_t t_bytes_acked; /* RFC 3465 variable for ABC, used by CCA only */
545 uint32_t total_ect_packets_marked; /* Cumulative count of total ECT packets marked */
546 uint32_t total_ect_packets_acked; /* Cumulative count of total ECT packets acked */
547
548 int t_lastchain; /* amount of packets chained last time around */
549 uint16_t t_unacksegs; /* received but unacked segments for delaying acks */
550 uint16_t t_unacksegs_ce; /* received but unacked segments/pure ACKs that were CE marked */
551
552 /*
553 * Pretty arbitrary value ;-)
554 * Goal is to make sure that some ACKs are being sent more frequently
555 * to allow the other side to ramp-up.
556 */
557 #define TCP_FORCED_ACKS_COUNT 16
558 uint16_t t_forced_acks; /* count of pure ACKs that need to be forced out */
559 uint8_t t_rexmtthresh; /* duplicate ack threshold for entering fast recovery */
560 uint8_t t_rtimo_probes; /* number of adaptive rtimo probes sent */
561 uint32_t t_persist_timeout; /* ZWP persistence limit as set by PERSIST_TIMEOUT */
562 uint32_t t_persist_stop; /* persistence limit deadline if triggered by ZWP */
563 uint32_t t_notsent_lowat; /* Low water for not sent data */
564
565 /* ECN stats */
566 uint32_t ecn_flags;
567 #define TE_SETUPSENT 0x00000001 /* We have sent classic ECN-SETUP SYN or SYN-ACK */
568 #define TE_SETUPRECEIVED 0x00000002 /* We have received classic ECN-SETUP SYN or SYN-ACK */
569 #define TE_SENDIPECT 0x00000004 /* We haven't sent or received non-ECN-setup SYN or SYN-ACK, set IP ECT on outbound packet */
570 #define TE_SENDCWR 0x00000008 /* Next non-retransmit should have TCP CWR set, only used for classic ECN */
571 #define TE_SENDECE 0x00000010 /* Next packet should have TCP ECE set, only used for classic ECN */
572 #define TE_INRECOVERY 0x00000020 /* connection entered recovery after receiving ECE */
573 #define TE_RECV_ECN_CE 0x00000040 /* Received IPTOS_ECN_CE marking atleast once */
574 #define TE_RECV_ECN_ECE 0x00000080 /* Received ECE marking atleast once */
575 #define TE_LOST_SYN 0x00000100 /* Lost SYN with ECN setup */
576 #define TE_LOST_SYNACK 0x00000200 /* Lost SYN-ACK with ECN setup */
577 #define TE_ECN_MODE_ENABLE 0x00000400 /* Option ECN mode set to enable */
578 #define TE_ECN_MODE_DISABLE 0x00000800 /* Option ECN mode set to disable */
579 #define TE_ENABLE_ECN 0x00001000 /* Enable negotiation of ECN */
580 #define TE_ECN_ON (TE_SETUPSENT | TE_SETUPRECEIVED) /* ECN was successfully negotiated on a connection */
581 #define TE_ECEHEURI_SET 0x00002000 /* We did our E/CE-probing at the beginning */
582 #define TE_CLIENT_SETUP 0x00004000 /* setup from client side */
583 #define TE_RCVD_SYN_RST 0x00008000 /* Received RST to the first ECN enabled SYN */
584 #define TE_ACE_SETUP_NON_ECT 0x00010000 /* Encode received non-ECT either for SYN-ACK (server) or final ACK (client) */
585 #define TE_ACE_SETUP_ECT1 0x00020000 /* Encode received ECT1 either for SYN-ACK (server) or final ACK (client) */
586 #define TE_ACE_SETUP_ECT0 0x00040000 /* Encode received ECT0 either for SYN-ACK (server) or final ACK (client) */
587 #define TE_ACE_SETUP_CE 0x00080000 /* Encode received CE either for SYN-ACK (server) or final ACK (client) */
588 #define TE_ACE_SETUPSENT 0x00100000 /* We have sent Accurate ECN setup SYN or SYN-ACK */
589 #define TE_ACE_SETUPRECEIVED 0x00200000 /* We have received Accurate ECN setup SYN or SYN-ACK */
590 #define TE_ACC_ECN_ON (TE_ACE_SETUPSENT | TE_ACE_SETUPRECEIVED) /* Accurate ECN was negotiated */
591 #define TE_ACE_FINAL_ACK_3WHS 0x00400000 /* Client has received SYN-ACK and will now send final ACK of 3WHS, only used for AccECN */
592 #define TE_ACO_ECT1 0x00800000 /* ECT1 counter changed flag, used to decide ordering for AccECN option */
593 #define TE_ACO_ECT0 0x01000000 /* ECT0 counter changed flag, used to decide ordering for AccECN option */
594 #define TE_RETRY_WITHOUT_ACO 0x02000000 /* Data segment with AccECN option was not acknowledged, retry without AccECN option */
595 #define TE_FORCE_ECT1 0x40000000 /* Force setting ECT1 on outgoing packets for testing purpose */
596 #define TE_FORCE_ECT0 0x80000000 /* Force setting ECT0 on outgoing packets for testing purpose */
597
598 uint32_t t_ecn_recv_ce; /* Received CE from the network */
599 uint32_t t_ecn_recv_cwr; /* Packets received with CWR */
600 uint32_t t_client_accecn_state; /* Client's Accurate ECN state */
601 uint32_t t_server_accecn_state; /* Server's Accurate ECN state */
602 uint64_t t_ecn_capable_packets_sent; /* Packets sent with ECT */
603 uint64_t t_ecn_capable_packets_acked; /* Packets sent with ECT that were acked */
604 uint64_t t_ecn_capable_packets_marked; /* Packets sent with ECT that were marked */
605 uint64_t t_ecn_capable_packets_lost; /* Packets sent with ECT that were lost */
606
607 uint32_t t_last_ack_tsecr; /* TS Echo Reply for last ACK that acknowledged a data or control packet */
608 uint16_t t_prev_ace_flags; /* ACE flags that were sent in previous packet, used for retransmitting after timeout */
609 uint8_t t_prev_ip_ecn; /* IP ECN flag on the previous packet, used for change-triggered ACKs */
610
611 struct accecn t_aecn; /* AccECN related byte counters */
612
613 struct pacer t_pacer; /* Pacer state used to pace packets */
614
615 /* state for bad retransmit recovery */
616 uint32_t snd_cwnd_prev; /* cwnd prior to retransmit */
617 uint32_t snd_ssthresh_prev; /* ssthresh prior to retransmit */
618 tcp_seq snd_recover_prev; /* snd_recover prior to retransmit */
619 int t_srtt_prev; /* srtt prior to retransmit */
620 int t_rttvar_prev; /* rttvar prior to retransmit */
621 uint32_t t_badrexmt_time; /* bad rexmt detection time */
622
623 /* Packet reordering metric */
624 uint32_t t_reorderwin; /* Reordering late time offset */
625
626 /* SACK related state */
627 int16_t snd_numholes; /* number of holes seen by sender */
628 TAILQ_HEAD(sackhole_head, sackhole) snd_holes;
629 /* SACK scoreboard (sorted) */
630 tcp_seq snd_fack; /* last seq number(+1) sack'd by rcv'r*/
631 int rcv_numsacks; /* # distinct sack blks present */
632 struct sackblk sackblks[MAX_SACK_BLKS]; /* seq nos. of sack blocks */
633 struct sackhint sackhint; /* SACK scoreboard hint */
634
635 struct mbuf *t_pktlist_head; /* First packet in transmit chain */
636 struct mbuf *t_pktlist_tail; /* Last packet in transmit chain */
637 uint32_t t_pktlist_sentlen; /* total bytes in transmit chain */
638
639 uint32_t t_keepidle; /* keepalive idle timer (override global if > 0) */
640 uint32_t t_keepinit; /* connection timeout, i.e. idle time
641 * in SYN_SENT or SYN_RECV state */
642 uint32_t t_keepintvl; /* interval between keepalives */
643 uint32_t t_keepcnt; /* number of keepalives before close */
644
645 uint32_t tso_max_segment_size; /* TSO maximum segment unit for NIC */
646 uint16_t t_pmtud_lastseg_size; /* size of the last sent segment */
647 uint32_t t_pmtud_saved_maxopd; /* MSS saved before performing PMTU-D BlackHole detection */
648 uint32_t t_pmtud_start_ts; /* Time of PMTUD blackhole detection */
649
650 struct{
651 uint32_t rxduplicatebytes;
652 uint32_t rxoutoforderbytes;
653 uint32_t txretransmitbytes;
654 uint16_t synrxtshift;
655 uint16_t rxmitsyns;
656 uint16_t unused_pad_to_8;
657 uint32_t rxmitpkts;
658 uint32_t delayed_acks_sent;
659 uint32_t acks_delayed;
660 uint64_t bytes_acked;
661 } t_stat;
662 uint8_t t_syn_sent;
663 uint8_t t_syn_rcvd;
664 uint8_t t_notify_ack_count;
665 uint8_t t_ecn_recv_ce_pkt; /* Received data packet with CE bit set */
666 uint8_t t_ecn_recv_ece_pkt; /* Received ACK packet with ECE bit set */
667 uint32_t t_cached_maxopd; /* default for MSS adjustment using link status report */
668
669 uint32_t bg_ssthresh; /* Slow start threshold until delay increases */
670 uint32_t t_flagsext; /* Another field to accommodate more flags */
671 #define TF_RXTFINDROP 0x1 /* Drop conn after retransmitting FIN 3 times */
672 /* Unused 0x2 */
673 #define TF_BWMEAS_INPROGRESS 0x4 /* Indicate BW meas is happening */
674 #define TF_MEASURESNDBW 0x8 /* Measure send bw on this connection */
675 #define TF_LAST_IS_PSH 0x10 /* Indicates whether the last packet in the rcv socket buffer had the PUSH-flag set */
676 #define TF_SACK_ENABLE 0x20 /* SACK is enabled */
677 #define TF_RECOMPUTE_RTT 0x40 /* recompute RTT after spurious retransmit */
678 #define TF_DETECT_READSTALL 0x80 /* Used to detect a stall during read operation */
679 #define TF_RECV_THROTTLE 0x100 /* Input throttling active */
680 #define TF_QUICKACK 0x200 /* Force-ACK every other packet */
681 #define TF_SYN_COOKIE_ENABLED 0x400 /* SYN cookie is enabled for listener when max backlog is reached */
682 #define TF_NOTIMEWAIT 0x800 /* Avoid going into time-wait */
683 #define TF_SENT_TLPROBE 0x1000 /* Sent data in PTO */
684 #define TF_PKTS_REORDERED 0x2000 /* Detected reordering */
685 #define TF_DELAY_RECOVERY 0x4000 /* delay fast recovery */
686 #define TF_FORCE 0x8000 /* force 1 byte out */
687 /* Unused 0x10000 */
688 #define TF_NOBLACKHOLE_DETECTION 0x20000 /* Disable PMTU blackhole detection */
689 #define TF_SYN_COOKIE_FORCE_ENABLED 0x40000 /* SYN cookie is enabled for listener unconditionally */
690 #define TF_RESCUE_RXT 0x80000 /* SACK rescue retransmit */
691 #define TF_CWND_NONVALIDATED 0x100000 /* cwnd non validated */
692 #define TF_IF_PROBING 0x200000 /* Trigger interface probe timeout */
693 #define TF_FASTOPEN 0x400000 /* TCP Fastopen is enabled */
694 #define TF_REASS_INPROG 0x800000 /* Reassembly is in progress */
695 #define TF_FASTOPEN_FORCE_ENABLE 0x1000000 /* Force-enable TCP Fastopen */
696 #define TF_USR_OUTPUT 0x2000000 /* In connect() or send() so tcp_output() can log */
697 #define TF_L4S_ENABLED 0x8000000 /* L4S was force enabled */
698 #define TF_L4S_DISABLED 0x10000000 /* L4S was force disabled */
699 #define TF_RACK_ENABLED 0x20000000 /* RACK is enabled */
700 #define TF_TLP_IS_RETRANS 0x40000000 /* Is TLP-probe a retransmission ? (field TLP.is_retrans in RFC 8985) */
701
702 #if TRAFFIC_MGT
703 /* Inter-arrival jitter related state */
704 uint32_t iaj_rcv_ts; /* tcp clock when the first packet was received */
705 int iaj_size; /* Size of packet for iaj measurement */
706 uint8_t iaj_small_pkt; /* Count of packets smaller than iaj_size */
707 uint8_t t_pipeack_ind; /* index for next pipeack sample */
708 uint16_t iaj_pktcnt; /* packet count, to avoid throttling initially */
709 uint32_t acc_iaj; /* Accumulated iaj */
710 uint32_t avg_iaj; /* Mean */
711 uint32_t std_dev_iaj; /* Standard deviation */
712 #endif /* TRAFFIC_MGT */
713 struct bwmeas *t_bwmeas; /* State for bandwidth measurement */
714 tcp_seq t_idleat; /* rcv_nxt at idle time */
715 uint8_t t_fin_sent;
716 uint8_t t_fin_rcvd;
717 uint8_t t_rst_sent;
718 uint8_t t_rst_rcvd;
719 TAILQ_ENTRY(tcpcb) t_twentry; /* link for time wait queue */
720 struct tcp_ccstate *t_ccstate; /* congestion control related state */
721 struct tcp_ccstate _t_ccstate; /* congestion control related state, non-allocated */
722 /* Tail loss probe related state */
723 tcp_seq t_tlphighrxt; /* snd_nxt after PTO */
724 tcp_seq t_tlphightrxt_persist; /* like t_tlphighrxt but persists over ACKs until DSACK (if any) is processed */
725 uint32_t t_tlpstart; /* timestamp at PTO */
726 /* DSACK data receiver state */
727 tcp_seq t_dsack_lseq; /* DSACK left sequence */
728 tcp_seq t_dsack_rseq; /* DSACK right sequence */
729 /* DSACK data sender state */
730 SLIST_HEAD(tcp_rxt_seghead, tcp_rxt_seg) t_rxt_segments;
731 uint32_t t_rxt_seg_count;
732 uint32_t t_rxt_seg_drop;
733 tcp_seq t_dsack_lastuna; /* snd_una when last recovery episode started */
734 /* state for congestion window validation (draft-ietf-tcpm-newcwv-07) */
735 #define TCP_PIPEACK_SAMPLE_COUNT 3
736 uint32_t t_pipeack_sample[TCP_PIPEACK_SAMPLE_COUNT]; /* pipeack, bytes acked within RTT */
737 tcp_seq t_pipeack_lastuna; /* una when pipeack measurement started */
738 uint32_t t_pipeack;
739 uint32_t t_lossflightsize;
740
741 #if MPTCP
742 uint32_t t_mpflags; /* flags for multipath TCP */
743
744 #define TMPF_PREESTABLISHED 0x00000001 /* conn in pre-established state */
745 #define TMPF_SND_KEYS 0x00000002 /* indicates that keys should be send */
746 #define TMPF_MPTCP_TRUE 0x00000004 /* negotiated MPTCP successfully */
747 /* UNUSED */
748 #define TMPF_SND_MPPRIO 0x00000010 /* send priority of subflow */
749 #define TMPF_SND_REM_ADDR 0x00000020 /* initiate address removal */
750 #define TMPF_RCVD_DACK 0x00000040 /* received a data-ack */
751 #define TMPF_JOINED_FLOW 0x00000080 /* Indicates additional flow */
752 #define TMPF_BACKUP_PATH 0x00000100 /* Indicates backup path */
753 #define TMPF_MPTCP_ACKNOW 0x00000200 /* Send Data ACK */
754 #define TMPF_SEND_DSN 0x00000400 /* Send DSN mapping */
755 #define TMPF_SEND_DFIN 0x00000800 /* Send Data FIN */
756 #define TMPF_RECV_DFIN 0x00001000 /* Recv Data FIN */
757 #define TMPF_SENT_JOIN 0x00002000 /* Sent Join */
758 #define TMPF_RECVD_JOIN 0x00004000 /* Received Join */
759 #define TMPF_RESET 0x00008000 /* Send RST */
760 #define TMPF_TCP_FALLBACK 0x00010000 /* Fallback to TCP */
761 #define TMPF_FASTCLOSERCV 0x00020000 /* Received Fastclose option */
762 #define TMPF_EMBED_DSN 0x00040000 /* tp has DSN mapping */
763 #define TMPF_MPTCP_READY 0x00080000 /* Can send DSS options on data */
764 #define TMPF_INFIN_SENT 0x00100000 /* Sent infinite mapping */
765 #define TMPF_SND_MPFAIL 0x00200000 /* Received mapping csum failure */
766 #define TMPF_SND_JACK 0x00400000 /* Send a Join-ACK */
767 #define TMPF_TFO_REQUEST 0x00800000 /* TFO Requested */
768 #define TMPF_MPTCP_ECHO_ADDR 0x01000000 /* MPTCP echoes add_addr */
769
770 #define TMPF_MPTCP_SIGNALS (TMPF_SND_MPPRIO | TMPF_SND_REM_ADDR | TMPF_SND_MPFAIL | TMPF_SND_JACK | TMPF_MPTCP_ECHO_ADDR)
771
772 tcp_seq t_mpuna; /* unacknowledged sequence */
773 struct mptcb *t_mptcb; /* pointer to MPTCP TCB */
774 struct mptsub *t_mpsub; /* pointer to the MPTCP subflow */
775 uint8_t t_local_aid; /* Addr Id for authentication */
776 uint8_t t_rem_aid; /* Addr ID of another subflow */
777 uint8_t t_mprxtshift; /* join retransmission */
778 #endif /* MPTCP */
779
780 #define TFO_F_OFFER_COOKIE 0x01 /* We will offer a cookie */
781 #define TFO_F_COOKIE_VALID 0x02 /* The received cookie is valid */
782 #define TFO_F_COOKIE_REQ 0x04 /* Client requested a new cookie */
783 #define TFO_F_COOKIE_SENT 0x08 /* Client did send a cookie in the SYN */
784 #define TFO_F_SYN_LOSS 0x10 /* A SYN-loss triggered a fallback to regular TCP on the client-side */
785 #define TFO_F_NO_SNDPROBING 0x20 /* This network is guaranteed to support TFO in the upstream direction */
786 #define TFO_F_HEURISTIC_DONE 0x40 /* We have already marked this network as bad */
787 uint8_t t_tfo_flags;
788 #define TFO_S_SYNDATA_RCV 0x01 /* SYN+data has been received */
789 #define TFO_S_COOKIEREQ_RECV 0x02 /* TFO-cookie request received */
790 #define TFO_S_COOKIE_SENT 0x04 /* TFO-cookie announced in SYN/ACK */
791 #define TFO_S_COOKIE_INVALID 0x08 /* Received TFO-cookie is invalid */
792 #define TFO_S_COOKIE_REQ 0x10 /* TFO-cookie requested within the SYN */
793 #define TFO_S_COOKIE_RCV 0x20 /* TFO-cookie received in SYN/ACK */
794 #define TFO_S_SYN_DATA_SENT 0x40 /* SYN+data sent */
795 #define TFO_S_SYN_DATA_ACKED 0x80 /* SYN+data has been acknowledged in SYN/ACK */
796 #define TFO_S_SYN_LOSS 0x0100 /* SYN+TFO has been lost - fallback to regular TCP */
797 #define TFO_S_COOKIE_WRONG 0x0200 /* Cookie we sent in the SYN was wrong */
798 #define TFO_S_NO_COOKIE_RCV 0x0400 /* We asked for a cookie but didn't get one */
799 #define TFO_S_HEURISTICS_DISABLE 0x0800 /* TFO-heuristics disabled it for this connection */
800 #define TFO_S_SEND_BLACKHOLE 0x1000 /* TFO got blackholed in the send direction */
801 #define TFO_S_RECV_BLACKHOLE 0x2000 /* TFO got blackholed in the recv direction */
802 #define TFO_S_ONE_BYTE_PROXY 0x4000 /* TFO failed because of a proxy acknowledging just one byte */
803 uint16_t t_tfo_stats;
804
805 uint8_t t_tfo_probes; /* TFO-probes we did send */
806 /*
807 * This here is the TFO-probing state-machine. Transitions are as follows:
808 *
809 * Current state: PROBE_NONE
810 * Event: SYN+DATA acknowledged
811 * Action: Transition to PROBE_PROBING and set keepalive-timer
812 *
813 * Current state: PROBE_PROBING (initial state)
814 * Event: Receive data
815 * Action: Transition to PROBE_NONE and cancel keepalive-timer
816 * Event: Receive ACK that does not indicate a hole
817 * Action: Transition to PROBE_NONE and cancel keepalive-timer
818 * Event: Receive ACK that indicates a hole
819 * Action: Transition to PROBE_WAIT_DATA and set a short timer
820 * to wait for the final segment.
821 * Event: Keepalive-timeout (did not receive any segment)
822 * Action: Signal ETIMEDOUT as with regular keepalive-timers
823 *
824 * Current state: PROBE_WAIT_DATA
825 * Event: Receive data
826 * Action: Transition to PROBE_NONE and cancel keepalive-timer
827 * Event: Data-timeout (did not receive the expected data)
828 * Action: Signal ENODATA up to the app and close everything.
829 */
830 #define TFO_PROBE_NONE 0 /* Not probing now */
831 #define TFO_PROBE_PROBING 1 /* Sending out TCP-keepalives waiting for reply */
832 #define TFO_PROBE_WAIT_DATA 2 /* Received reply, waiting for data */
833 uint8_t t_tfo_probe_state;
834
835 uint32_t t_rcvoopack; /* out-of-order packets received */
836 uint32_t t_pawsdrop; /* segments dropped due to PAWS */
837 uint32_t t_sack_recovery_episode; /* SACK recovery episodes */
838 uint32_t t_rack_recovery_episode; /* RACK recovery episodes */
839 uint32_t t_rack_reo_timeout_recovery_episode; /* RACK recovery triggered by reordering timeout */
840 uint32_t t_reordered_pkts; /* packets reorderd */
841 uint32_t t_dsack_sent; /* Sent DSACK notification */
842 uint32_t t_dsack_recvd; /* Received a valid DSACK option */
843 SLIST_HEAD(, tcp_notify_ack_marker) t_notify_ack; /* state for notifying data acknowledgements */
844 uint32_t t_recv_throttle_ts; /* TS for start of recv throttle */
845 uint32_t t_rxt_minimum_timeout; /* minimum retransmit timeout in ms */
846 uint32_t t_challengeack_last; /* last time challenge ACK was sent per sec */
847 uint32_t t_challengeack_count; /* # of challenge ACKs already sent per sec */
848
849 uint32_t t_connect_time; /* time when the connection started */
850
851 uint64_t t_rcvwnd_limited_total_time;
852 uint64_t t_rcvwnd_limited_start_time;
853
854
855 uint32_t t_comp_rxmt_gencnt; /* Current compression generation-count for segments */
856
857 uint32_t t_comp_ack_gencnt; /* Current compression generation-count for ACKs */
858 uint32_t t_comp_ack_lastinc; /* Last time the gen-count was changed - should change every TCP_COMP_CHANGE_RATE ms */
859 #define TCP_COMP_CHANGE_RATE 5 /* Intervals at which we change the gencnt. Means that worst-case we send one ACK every TCP_COMP_CHANGE_RATE ms */
860
861 #define NCURR_RTT_HIST 4 /* Number of current RTT samples (k) */
862 uint32_t curr_rtt_hist[NCURR_RTT_HIST]; /* last k current RTT samples */
863 uint32_t curr_rtt_min; /* Minimum current RTT from last k samples */
864 uint32_t curr_rtt_index; /* Index for current RTT samples */
865
866 tcp_seq rcv_high; /* highest sequence number received */
867 uint32_t tsv_high; /* timestamp value of highest received sequence number */
868 struct tcp_rledbat_state t_rlstate; /* State used by rLedbat */
869
870 uint32_t rcv_srtt; /* receiver's SRTT, coarse when Timestamp not supported */
871 uint32_t rcv_rtt_est_ts; /* start of measurement for estimating RTT when Timestamp not supported */
872 uint32_t rcv_rtt_est_seq; /* expected sequence number for completion of 1RTT when Timestamp not supported */
873
874 TAILQ_HEAD(tcp_seg_sent_head, tcp_seg_sent) t_segs_sent; /* Time ordered segment list used for RACK */
875 struct tcp_seg_sent_tree_head t_segs_sent_tree; /* RB tree to track S/ACKED segments used for RACK */
876 TAILQ_HEAD(tcp_seg_acked_head, tcp_seg_sent) t_segs_acked; /* Temporary storage for ACKed segments used for RACK */
877 struct tcp_seg_pool seg_pool;
878
879 # define TCP_RACK_RECOVERY_PERSIST_MAX (16)
880 struct tcp_rack {
881 uint32_t xmit_ts;
882 uint32_t end_seq;
883 uint32_t rtt; /* RTT of the most recently delivered segment that was not marked as invalid as a possible spurious retransmission. */
884 tcp_seq dsack_round_end;
885 uint32_t reo_wnd;
886 uint8_t reo_wnd_multi;
887 uint8_t reo_wnd_persist:5,
888 advanced:1,
889 dsack_round_seen:1,
890 segs_retransmitted:1;
891 } rack;
892
893 /*
894 * Below counters are used to estmitate current flight size,
895 * hence these counters reflect current values instead of total
896 */
897 uint32_t bytes_lost;
898 uint32_t bytes_retransmitted;
899 uint32_t bytes_sacked;
900
901 uint8_t l4s_enabled:1,
902 accurate_ecn_on:1,
903 _pad:6;
904
905 uuid_t t_fsw_uuid;
906 uuid_t t_flow_uuid;
907 };
908
909 __CCT_DECLARE_CONSTRAINED_PTR_TYPES(struct tcpcb, tcpcb);
910
911 #define IN_FASTRECOVERY(tp) (tp->t_flags & TF_FASTRECOVERY)
912 #define SACK_ENABLED(tp) (tp->t_flagsext & TF_SACK_ENABLE)
913 #define TFO_ENABLED(tp) (tp->t_flagsext & TF_FASTOPEN)
914 #define TCP_RACK_ENABLED(tp) ((tp->t_flagsext & TF_RACK_ENABLED) && SACK_ENABLED(tp) && !TFO_ENABLED(tp))
915
916 extern int tcp_syncookie;
917 extern int soqlimitcompat;
918 extern int mptcp_enable;
919
920 #define LOOPBACK_INTERFACE(tp) (tp->t_inpcb->inp_boundifp != NULL && \
921 (tp->t_inpcb->inp_boundifp->if_flags & IFF_LOOPBACK))
922
923 #define TCP_SYN_COOKIE_DISABLED(tp) (TFO_ENABLED(tp) || tp->t_mpflags & TMPF_MPTCP_TRUE || LOOPBACK_INTERFACE(tp))
924
925 #define TCP_SYN_COOKIE_FORCE_ENABLED(tp) ((tp->t_flagsext & TF_SYN_COOKIE_FORCE_ENABLED) \
926 && !TCP_SYN_COOKIE_DISABLED(tp))
927
928 #define TCP_SYN_COOKIE_ENABLED(tp) ((tp->t_flagsext & (TF_SYN_COOKIE_ENABLED | TF_SYN_COOKIE_FORCE_ENABLED)) \
929 && !TCP_SYN_COOKIE_DISABLED(tp))
930
931 static __inline bool
tcp_can_send_syncookie(const struct socket * head,const struct tcpcb * tp,const uint8_t th_flags)932 tcp_can_send_syncookie(const struct socket *head, const struct tcpcb *tp, const uint8_t th_flags)
933 {
934 int backlog = soqlimitcompat ? head->so_qlimit : (3 * head->so_qlimit / 2);
935 backlog = backlog - (backlog >> 3);
936 bool backlog_reached = head->so_incqlen >= (backlog >> 1) || head->so_qlen >= backlog;
937 bool can_send_syncookie = (TCP_SYN_COOKIE_FORCE_ENABLED(tp) || (TCP_SYN_COOKIE_ENABLED(tp) && backlog_reached));
938 can_send_syncookie &= ((th_flags & (TH_RST | TH_ACK | TH_SYN)) == TH_SYN);
939 return can_send_syncookie;
940 }
941
942 static inline bool
tcp_sent_tlp_retrans(const struct tcpcb * tp)943 tcp_sent_tlp_retrans(const struct tcpcb *tp)
944 {
945 return (tp->t_flagsext & (TF_SENT_TLPROBE | TF_TLP_IS_RETRANS)) == (TF_SENT_TLPROBE | TF_TLP_IS_RETRANS);
946 }
947
948 /*
949 * If the connection is in a throttled state due to advisory feedback from
950 * the interface output queue, reset that state. We do this in favor
951 * of entering recovery because the data transfer during recovery
952 * should be just a trickle and it will help to improve performance.
953 * We also do not want to back off twice in the same RTT.
954 */
955 #define ENTER_FASTRECOVERY(_tp_) do { \
956 (_tp_)->t_flags |= TF_FASTRECOVERY; \
957 if (INP_IS_FLOW_CONTROLLED((_tp_)->t_inpcb)) \
958 inp_reset_fc_state((_tp_)->t_inpcb); \
959 if (!SLIST_EMPTY(&tp->t_rxt_segments)) \
960 tcp_rxtseg_clean(tp); \
961 } while(0)
962
963 #define EXIT_FASTRECOVERY(_tp_) do { \
964 (_tp_)->t_flags &= ~TF_FASTRECOVERY; \
965 (_tp_)->t_dupacks = 0; \
966 (_tp_)->t_rexmtthresh = (uint8_t)tcprexmtthresh; \
967 (_tp_)->t_bytes_acked = 0; \
968 (_tp_)->ecn_flags &= ~TE_INRECOVERY; \
969 (_tp_)->t_timer[TCPT_PTO] = 0; \
970 (_tp_)->t_flagsext &= ~TF_RESCUE_RXT; \
971 (_tp_)->t_lossflightsize = 0; \
972 (_tp_)->sackhint.sack_bytes_acked = 0; \
973 } while(0)
974
975 /*
976 * When the number of duplicate acks received is less than
977 * the retransmit threshold, use Limited Transmit algorithm
978 */
979 extern uint8_t tcprexmtthresh;
980 #define ALLOW_LIMITED_TRANSMIT(_tp_) \
981 ((_tp_)->t_dupacks > 0 && \
982 (_tp_)->t_dupacks < (_tp_)->t_rexmtthresh && \
983 ((_tp_)->t_flagsext & (TF_PKTS_REORDERED|TF_DELAY_RECOVERY)) \
984 != (TF_PKTS_REORDERED|TF_DELAY_RECOVERY))
985
986 /*
987 * This condition is true if timestamp option is supported
988 * on a connection.
989 */
990 #define TSTMP_SUPPORTED(_tp_) \
991 (((_tp_)->t_flags & (TF_REQ_TSTMP|TF_RCVD_TSTMP)) == \
992 (TF_REQ_TSTMP|TF_RCVD_TSTMP))
993
994 /*
995 * This condition is true if window scale option is supported
996 * on a connection
997 */
998 #define TCP_WINDOW_SCALE_ENABLED(_tp_) \
999 (((_tp_)->t_flags & (TF_RCVD_SCALE|TF_REQ_SCALE)) == \
1000 (TF_RCVD_SCALE|TF_REQ_SCALE))
1001
1002 /* Is ECN negotiated end-to-end */
1003 #define TCP_ECN_ENABLED(_tp_) \
1004 (((_tp_)->ecn_flags & (TE_ECN_ON)) == (TE_ECN_ON))
1005
1006 extern int tcp_l4s;
1007 extern int tcp_l4s_developer;
1008
1009 /* L4S Developer setting will override system setting */
1010 typedef enum {
1011 tcp_l4s_system = 0,
1012 tcp_l4s_developer_enable = 1,
1013 tcp_l4s_developer_disable = 2
1014 } tcp_l4s_t;
1015
1016 /*
1017 * Gives number of bytes acked by this ack
1018 */
1019 #define BYTES_ACKED(_th_, _tp_) \
1020 ((_th_)->th_ack - (_tp_)->snd_una)
1021
1022 /* Returns true if a DSACK option should be sent */
1023 #define TCP_SEND_DSACK_OPT(_tp_) \
1024 ((_tp_)->t_dsack_lseq > 0 && (_tp_)->t_dsack_rseq > 0)
1025
1026 /*
1027 * Returns true if a DSACK sequence is within the max send window that will
1028 * be accepted. In order to set a window to validate sequence numbers, the
1029 * max send window within which a DSACK option is processed is limited.
1030 *
1031 * We need to choose a maximum window to check if the sequence number is
1032 * within the window. One arbitrary choice is 256 * MSS because if the
1033 * window is as large as 256 segments it might be big enough to ignore the
1034 * DSACK option. Choosing a much larger limit means that the memory for
1035 * retransmit segments can be held for a longer time.
1036 */
1037 #define TCP_DSACK_MAX_SEND_WINDOW(_tp_) (MIN((_tp_)->snd_wnd, tcp_autosndbuf_max))
1038 #define TCP_DSACK_SEQ_IN_WINDOW(_tp_, _seq_, _una_) \
1039 (SEQ_LEQ((_seq_), (_tp_)->snd_max) && \
1040 SEQ_GEQ((_seq_), ((_una_) - TCP_DSACK_MAX_SEND_WINDOW(_tp_))))
1041
1042 #define TCP_RESET_REXMT_STATE(_tp_) do { \
1043 (_tp_)->t_rxtshift = 0; \
1044 (_tp_)->t_rxtstart = 0; \
1045 mptcp_reset_rexmit_state((_tp_)); \
1046 } while(0);
1047
1048 #define TCP_IF_STATE_CHANGED(tp, probe_if_index) \
1049 (probe_if_index > 0 && tp->t_inpcb->inp_last_outifp != NULL && \
1050 probe_if_index == tp->t_inpcb->inp_last_outifp->if_index)
1051
1052 #define TCP_RLEDBAT_ENABLED(_tp) \
1053 (tcp_rledbat == 1 && TSTMP_SUPPORTED(_tp))
1054
1055 #define TCP_RECV_BG(_so) \
1056 (tcp_recv_bg == 1 || IS_TCP_RECV_BG(_so))
1057
1058 #define TCP_USE_RLEDBAT(_tp, _so) \
1059 TCP_RLEDBAT_ENABLED(_tp) && TCP_RECV_BG(_so)
1060
1061 /*
1062 * Structure to hold TCP options that are only used during segment
1063 * processing (in tcp_input), but not held in the tcpcb.
1064 * It's basically used to reduce the number of parameters
1065 * to tcp_dooptions.
1066 */
1067 struct tcpopt {
1068 uint32_t to_flags; /* which options are present */
1069 #define TOF_TS 0x0001 /* timestamp */
1070 #define TOF_SACKPERM 0x0004 /* SACK permitted (only in SYN/ACK) */
1071 #define TOF_MSS 0x0010
1072 #define TOF_SCALE 0x0020
1073 #define TOF_SIGNATURE 0x0040 /* signature option present */
1074 #define TOF_SIGLEN 0x0080 /* signature length valid (RFC2385) */
1075 #define TOF_SACK 0x0100 /* SACK option present */
1076 #define TOF_MPTCP 0x0200 /* MPTCP options to be dropped */
1077 #define TOF_TFO 0x0400 /* TFO cookie option present */
1078 #define TOF_TFOREQ 0x0800 /* TFO cookie request present */
1079 #define TOF_MAXOPT 0x1000
1080 uint32_t to_tsval;
1081 uint32_t to_tsecr;
1082 uint16_t to_mss;
1083 uint8_t to_wscale;
1084 uint8_t to_nsacks; /* number of SACK blocks */
1085 u_char *to_sacks __sized_by(to_sacks_size); /* pointer to the first SACK blocks */
1086 uint32_t to_sacks_size; /* boundary for to_sacks */
1087 u_char *to_tfo __sized_by(to_tfo_size); /* pointer to the TFO cookie */
1088 uint32_t to_tfo_size; /* boundary for to_tfo */
1089 uint8_t to_num_accecn; /* number of Accurate ECN counters */
1090 uint8_t *to_accecn __sized_by(to_accecn_size); /* pointer to the first Accurate ECN counter */
1091 uint32_t to_accecn_size; /* boundary for to_accecn */
1092 uint8_t to_accecn_order; /* Accurate ECN ordering */
1093 };
1094
1095 #define intotcpcb(ip) ((struct tcpcb *)(ip)->inp_ppcb)
1096 #define sototcpcb(so) (intotcpcb(sotoinpcb(so)))
1097
1098 /* TFO-specific defines */
1099 #define TFO_COOKIE_LEN_MIN 4
1100 #define TFO_COOKIE_LEN_DEFAULT 8
1101 #define TFO_COOKIE_LEN_MAX 16
1102
1103 /*
1104 * Jaguar compatible TCP control block, for xtcpcb
1105 * Does not have the old fields
1106 */
1107 struct otcpcb {
1108 #else
1109 struct tseg_qent;
1110 _TCPCB_LIST_HEAD(tsegqe_head, tseg_qent);
1111
1112 struct tcpcb {
1113 #endif /* KERNEL_PRIVATE */
1114 #if defined(KERNEL_PRIVATE)
1115 u_int32_t t_segq;
1116 #else
1117 struct tsegqe_head t_segq;
1118 #endif /* KERNEL_PRIVATE */
1119 int t_dupacks; /* consecutive dup acks recd */
1120 u_int32_t unused; /* unused now: was t_template */
1121
1122 int t_timer[TCPT_NTIMERS_EXT]; /* tcp timers */
1123
1124 _TCPCB_PTR(struct inpcb *) t_inpcb; /* back pointer to internet pcb */
1125 int t_state; /* state of this connection */
1126 u_int t_flags;
1127 #define TF_ACKNOW 0x00001 /* ack peer immediately */
1128 #define TF_DELACK 0x00002 /* ack, but try to delay it */
1129 #define TF_NODELAY 0x00004 /* don't delay packets to coalesce */
1130 #define TF_NOOPT 0x00008 /* don't use tcp options */
1131 #define TF_SENTFIN 0x00010 /* have sent FIN */
1132 #define TF_REQ_SCALE 0x00020 /* have/will request window scaling */
1133 #define TF_RCVD_SCALE 0x00040 /* other side has requested scaling */
1134 #define TF_REQ_TSTMP 0x00080 /* have/will request timestamps */
1135 #define TF_RCVD_TSTMP 0x00100 /* a timestamp was received in SYN */
1136 #define TF_SACK_PERMIT 0x00200 /* other side said I could SACK */
1137 #define TF_NEEDSYN 0x00400 /* send SYN (implicit state) - unused but needed for backwards compatibility */
1138 #define TF_NEEDFIN 0x00800 /* send FIN (implicit state) */
1139 #define TF_NOPUSH 0x01000 /* don't push */
1140 #define TF_REQ_CC 0x02000 /* have/will request CC */
1141 #define TF_RCVD_CC 0x04000 /* a CC was received in SYN */
1142 #define TF_SENDCCNEW 0x08000 /* Not implemented */
1143 #define TF_MORETOCOME 0x10000 /* More data to be appended to sock */
1144 #define TF_LQ_OVERFLOW 0x20000 /* listen queue overflow */
1145 #define TF_RXWIN0SENT 0x40000 /* sent a receiver win 0 in response */
1146 #define TF_SLOWLINK 0x80000 /* route is a on a modem speed link */
1147
1148 int t_force; /* 1 if forcing out a byte */
1149
1150 tcp_seq snd_una; /* send unacknowledged */
1151 tcp_seq snd_max; /* highest sequence number sent;
1152 * used to recognize retransmits
1153 */
1154 tcp_seq snd_nxt; /* send next */
1155 tcp_seq snd_up; /* send urgent pointer */
1156
1157 tcp_seq snd_wl1; /* window update seg seq number */
1158 tcp_seq snd_wl2; /* window update seg ack number */
1159 tcp_seq iss; /* initial send sequence number */
1160 tcp_seq irs; /* initial receive sequence number */
1161
1162 tcp_seq rcv_nxt; /* receive next */
1163 tcp_seq rcv_adv; /* advertised window */
1164 u_int32_t rcv_wnd; /* receive window */
1165 tcp_seq rcv_up; /* receive urgent pointer */
1166
1167 u_int32_t snd_wnd; /* send window */
1168 u_int32_t snd_cwnd; /* congestion-controlled window */
1169 u_int32_t snd_ssthresh; /* snd_cwnd size threshold for
1170 * for slow start exponential to
1171 * linear switch
1172 */
1173 u_int t_maxopd; /* mss plus options */
1174
1175 u_int32_t t_rcvtime; /* time at which a packet was received */
1176 u_int32_t t_starttime; /* time connection was established */
1177 int t_rtttime; /* round trip time */
1178 tcp_seq t_rtseq; /* sequence number being timed */
1179
1180 int t_rxtcur; /* current retransmit value (ticks) */
1181 u_int t_maxseg; /* maximum segment size */
1182 int t_srtt; /* smoothed round-trip time */
1183 int t_rttvar; /* variance in round-trip time */
1184
1185 int t_rxtshift; /* log(2) of rexmt exp. backoff */
1186 u_int t_rttmin; /* minimum rtt allowed */
1187 u_int32_t t_rttupdated; /* number of times rtt sampled */
1188 u_int32_t max_sndwnd; /* largest window peer has offered */
1189
1190 int t_softerror; /* possible error not yet reported */
1191 /* out-of-band data */
1192 char t_oobflags; /* have some */
1193 char t_iobc; /* input character */
1194 #define TCPOOB_HAVEDATA 0x01
1195 #define TCPOOB_HADDATA 0x02
1196 /* RFC 1323 variables */
1197 u_char snd_scale; /* window scaling for send window */
1198 u_char rcv_scale; /* window scaling for recv window */
1199 u_char request_r_scale; /* pending window scaling */
1200 u_char requested_s_scale;
1201 u_int32_t ts_recent; /* timestamp echo data */
1202
1203 u_int32_t ts_recent_age; /* when last updated */
1204 tcp_seq last_ack_sent;
1205 /* RFC 1644 variables */
1206 tcp_cc cc_send; /* send connection count */
1207 tcp_cc cc_recv; /* receive connection count */
1208 tcp_seq snd_recover; /* for use in fast recovery */
1209 /* experimental */
1210 u_int32_t snd_cwnd_prev; /* cwnd prior to retransmit */
1211 u_int32_t snd_ssthresh_prev; /* ssthresh prior to retransmit */
1212 u_int32_t t_badrxtwin; /* window for retransmit recovery */
1213 };
1214
1215 #define tcps_ecn_setup tcps_ecn_client_success
1216 #define tcps_sent_cwr tcps_ecn_recv_ece
1217 #define tcps_sent_ece tcps_ecn_sent_ece
1218
1219 /*
1220 * TCP statistics.
1221 * Many of these should be kept per connection,
1222 * but that's inconvenient at the moment.
1223 */
1224 struct tcpstat {
1225 u_int32_t tcps_connattempt; /* connections initiated */
1226 u_int32_t tcps_accepts; /* connections accepted */
1227 u_int32_t tcps_connects; /* connections established */
1228 u_int32_t tcps_drops; /* connections dropped */
1229 u_int32_t tcps_conndrops; /* embryonic connections dropped */
1230 u_int32_t tcps_closed; /* conn. closed (includes drops) */
1231 u_int32_t tcps_segstimed; /* segs where we tried to get rtt */
1232 u_int32_t tcps_rttupdated; /* times we succeeded */
1233 u_int32_t tcps_delack; /* delayed acks sent */
1234 u_int32_t tcps_timeoutdrop; /* conn. dropped in rxmt timeout */
1235 u_int32_t tcps_rexmttimeo; /* retransmit timeouts */
1236 u_int32_t tcps_persisttimeo; /* persist timeouts */
1237 u_int32_t tcps_keeptimeo; /* keepalive timeouts */
1238 u_int32_t tcps_keepprobe; /* keepalive probes sent */
1239 u_int32_t tcps_keepdrops; /* connections dropped in keepalive */
1240
1241 u_int32_t tcps_sndtotal; /* total packets sent */
1242 u_int32_t tcps_sndpack; /* data packets sent */
1243 u_int32_t tcps_sndbyte; /* data bytes sent */
1244 u_int32_t tcps_sndrexmitpack; /* data packets retransmitted */
1245 u_int32_t tcps_sndrexmitbyte; /* data bytes retransmitted */
1246 u_int32_t tcps_sndacks; /* ack-only packets sent */
1247 u_int32_t tcps_sndprobe; /* window probes sent */
1248 u_int32_t tcps_sndurg; /* packets sent with URG only */
1249 u_int32_t tcps_sndwinup; /* window update-only packets sent */
1250 u_int32_t tcps_sndctrl; /* control (SYN|FIN|RST) packets sent */
1251
1252 u_int32_t tcps_rcvtotal; /* total packets received */
1253 u_int32_t tcps_rcvpack; /* packets received in sequence */
1254 u_int32_t tcps_rcvbyte; /* bytes received in sequence */
1255 u_int32_t tcps_rcvbadsum; /* packets received with ccksum errs */
1256 u_int32_t tcps_rcvbadoff; /* packets received with bad offset */
1257 u_int32_t tcps_rcvmemdrop; /* packets dropped for lack of memory */
1258 u_int32_t tcps_rcvshort; /* packets received too short */
1259 u_int32_t tcps_rcvduppack; /* duplicate-only packets received */
1260 u_int32_t tcps_rcvdupbyte; /* duplicate-only bytes received */
1261 u_int32_t tcps_rcvpartduppack; /* packets with some duplicate data */
1262 u_int32_t tcps_rcvpartdupbyte; /* dup. bytes in part-dup. packets */
1263 u_int32_t tcps_rcvoopack; /* out-of-order packets received */
1264 u_int32_t tcps_rcvoobyte; /* out-of-order bytes received */
1265 u_int32_t tcps_rcvpackafterwin; /* packets with data after window */
1266 u_int32_t tcps_rcvbyteafterwin; /* bytes rcvd after window */
1267 u_int32_t tcps_rcvafterclose; /* packets rcvd after "close" */
1268 u_int32_t tcps_rcvwinprobe; /* rcvd window probe packets */
1269 u_int32_t tcps_rcvdupack; /* rcvd duplicate acks */
1270 u_int32_t tcps_rcvacktoomuch; /* rcvd acks for unsent data */
1271 u_int32_t tcps_rcvackpack; /* rcvd ack packets */
1272 u_int32_t tcps_rcvackbyte; /* bytes acked by rcvd acks */
1273 u_int32_t tcps_rcvwinupd; /* rcvd window update packets */
1274 u_int32_t tcps_pawsdrop; /* segments dropped due to PAWS */
1275 u_int32_t tcps_predack; /* times hdr predict ok for acks */
1276 u_int32_t tcps_preddat; /* times hdr predict ok for data pkts */
1277 u_int32_t tcps_cachedrtt; /* times cached RTT in route updated */
1278 u_int32_t tcps_cachedrttvar; /* times cached rttvar updated */
1279 u_int32_t tcps_cachedssthresh; /* times cached ssthresh updated */
1280 u_int32_t tcps_usedrtt; /* times RTT initialized from route */
1281 u_int32_t tcps_usedrttvar; /* times RTTVAR initialized from rt */
1282 u_int32_t tcps_usedssthresh; /* times ssthresh initialized from rt*/
1283 u_int32_t tcps_persistdrop; /* timeout in persist state */
1284 u_int32_t tcps_badsyn; /* bogus SYN, e.g. premature ACK */
1285 u_int32_t tcps_mturesent; /* resends due to MTU discovery */
1286 u_int32_t tcps_listendrop; /* listen queue overflows */
1287 u_int32_t tcps_synchallenge; /* challenge ACK due to bad SYN */
1288 u_int32_t tcps_rstchallenge; /* challenge ACK due to bad RST */
1289
1290 /* new stats from FreeBSD 5.4 sync up */
1291 u_int32_t tcps_minmssdrops; /* average minmss too low drops */
1292
1293 u_int32_t tcps_sndrexmitbad; /* unnecessary packet retransmissions */
1294 u_int32_t tcps_badrst; /* ignored RSTs in the window */
1295
1296 u_int32_t tcps_sc_dropped; /* could not reply to packet */
1297 u_int32_t tcps_sc_completed; /* successful extraction of entry */
1298 u_int32_t tcps_sc_aborted; /* syncache entry aborted */
1299 u_int32_t tcps_sc_sendcookie; /* SYN cookie sent */
1300 u_int32_t tcps_sc_recvcookie; /* SYN cookie received */
1301
1302 /* SACK related stats */
1303 u_int32_t tcps_sack_recovery_episode; /* SACK recovery episodes */
1304 u_int32_t tcps_sack_rexmits; /* SACK rexmit segments */
1305 u_int32_t tcps_sack_rexmit_bytes; /* SACK rexmit bytes */
1306 u_int32_t tcps_sack_rcv_blocks; /* SACK blocks (options) received */
1307 u_int32_t tcps_sack_send_blocks; /* SACK blocks (options) sent */
1308 u_int32_t tcps_sack_sboverflow; /* SACK sendblock overflow */
1309
1310 /* RACK related stats */
1311 u_int32_t tcps_rack_recovery_episode; /* RACK recovery episodes */
1312 u_int32_t tcps_rack_reordering_timeout_recovery_episode; /* RACK recovery episodes due to reordering timeout */
1313 u_int32_t tcps_rack_rexmits; /* RACK rexmit segments */
1314
1315 u_int32_t tcps_bg_rcvtotal; /* total background packets received */
1316 u_int32_t tcps_rxtfindrop; /* drop conn after retransmitting FIN */
1317 u_int32_t tcps_fcholdpacket; /* packets withheld because of flow control */
1318
1319 u_int32_t tcps_limited_txt; /* Limited transmit used */
1320 u_int32_t tcps_early_rexmt; /* Early retransmit used */
1321 u_int32_t tcps_sack_ackadv; /* Cumulative ack advanced along with sack */
1322
1323 /* Checksum related stats */
1324 u_int32_t tcps_rcv_swcsum; /* tcp swcksum (inbound), packets */
1325 u_int32_t tcps_rcv_swcsum_bytes; /* tcp swcksum (inbound), bytes */
1326 u_int32_t tcps_rcv6_swcsum; /* tcp6 swcksum (inbound), packets */
1327 u_int32_t tcps_rcv6_swcsum_bytes; /* tcp6 swcksum (inbound), bytes */
1328 u_int32_t tcps_snd_swcsum; /* tcp swcksum (outbound), packets */
1329 u_int32_t tcps_snd_swcsum_bytes; /* tcp swcksum (outbound), bytes */
1330 u_int32_t tcps_snd6_swcsum; /* tcp6 swcksum (outbound), packets */
1331 u_int32_t tcps_snd6_swcsum_bytes; /* tcp6 swcksum (outbound), bytes */
1332
1333 /* MPTCP Related stats */
1334 u_int32_t tcps_invalid_mpcap; /* Invalid MPTCP capable opts */
1335 u_int32_t tcps_invalid_joins; /* Invalid MPTCP joins */
1336 u_int32_t tcps_mpcap_fallback; /* TCP fallback in primary */
1337 u_int32_t tcps_join_fallback; /* No MPTCP in secondary */
1338 u_int32_t tcps_estab_fallback; /* DSS option dropped */
1339 u_int32_t tcps_invalid_opt; /* Catchall error stat */
1340 u_int32_t tcps_mp_reducedwin; /* Reduced subflow window */
1341 u_int32_t tcps_mp_badcsum; /* Bad DSS csum */
1342 u_int32_t tcps_mp_oodata; /* Out of order data */
1343 u_int32_t tcps_mp_switches; /* number of subflow switch */
1344 u_int32_t tcps_mp_rcvtotal; /* number of rcvd packets */
1345 u_int32_t tcps_mp_rcvbytes; /* number of bytes received */
1346 u_int32_t tcps_mp_sndpacks; /* number of data packs sent */
1347 u_int32_t tcps_mp_sndbytes; /* number of bytes sent */
1348 u_int32_t tcps_join_rxmts; /* join ack retransmits */
1349 u_int32_t tcps_tailloss_rto; /* RTO due to tail loss */
1350 u_int32_t tcps_reordered_pkts; /* packets reorderd */
1351 u_int32_t tcps_recovered_pkts; /* recovered after loss */
1352 u_int32_t tcps_pto; /* probe timeout */
1353 u_int32_t tcps_rto_after_pto; /* RTO after a probe */
1354 u_int32_t tcps_tlp_recovery; /* TLP induced fast recovery */
1355 u_int32_t tcps_tlp_recoverlastpkt; /* TLP recoverd last pkt */
1356 u_int32_t tcps_ecn_client_success; /* client-side connection negotiated ECN */
1357 u_int32_t tcps_ecn_recv_ece; /* ECE received, sent CWR */
1358 u_int32_t tcps_ecn_sent_ece; /* Sent ECE notification */
1359 u_int32_t tcps_detect_reordering; /* Detect pkt reordering */
1360 u_int32_t tcps_delay_recovery; /* Delay fast recovery */
1361 u_int32_t tcps_avoid_rxmt; /* Retransmission was avoided */
1362 u_int32_t tcps_pto_in_recovery; /* rescue retransmit in fast recovery */
1363 u_int32_t tcps_pmtudbh_reverted; /* PMTU Blackhole detection, segment size reverted */
1364
1365 /* DSACK related statistics */
1366 u_int32_t tcps_dsack_ackloss; /* ignore DSACK due to ack loss */
1367 u_int32_t tcps_dsack_badrexmt; /* DSACK based bad rexmt recovery */
1368 u_int32_t tcps_dsack_sent; /* Sent DSACK notification */
1369 u_int32_t tcps_dsack_recvd; /* Received a valid DSACK option */
1370 u_int32_t tcps_dsack_recvd_old; /* Received an out of window DSACK option */
1371
1372 /* MPTCP Subflow selection stats */
1373 u_int32_t tcps_mp_sel_rtt; /* By RTT comparison */
1374 u_int32_t tcps_mp_sel_rto; /* By RTO comparison */
1375 u_int32_t tcps_mp_num_probes; /* Number of probes sent */
1376 u_int32_t tcps_mp_verdowngrade; /* MPTCP version downgrade */
1377 u_int32_t tcps_drop_after_sleep; /* drop after long AP sleep */
1378 u_int32_t tcps_probe_if; /* probe packets after interface availability */
1379 u_int32_t tcps_probe_if_conflict; /* Can't send probe packets for interface */
1380
1381 u_int32_t tcps_ecn_client_setup; /* Attempted ECN setup from client side */
1382 u_int32_t tcps_ecn_server_setup; /* Attempted ECN setup from server side */
1383 u_int32_t tcps_ecn_server_success; /* server-side connection negotiated ECN */
1384 u_int32_t tcps_ecn_ace_syn_not_ect; /* received AccECN SYN packet with Not-ECT */
1385 u_int32_t tcps_ecn_ace_syn_ect1; /* received AccECN SYN packet with ECT1 */
1386 u_int32_t tcps_ecn_ace_syn_ect0; /* received AccECN SYN packet with ECT0 */
1387 u_int32_t tcps_ecn_ace_syn_ce; /* received AccECN SYN packet with CE */
1388 u_int32_t tcps_ecn_lost_synack; /* Lost SYN-ACK with ECN setup */
1389 u_int32_t tcps_ecn_lost_syn; /* Lost SYN with ECN setup */
1390 u_int32_t tcps_ecn_not_supported; /* Server did not support ECN setup */
1391 u_int32_t tcps_ecn_recv_ce; /* Received CE from the network */
1392 u_int32_t tcps_ecn_ace_recv_ce; /* CE count received in ACE field */
1393 u_int32_t tcps_ecn_conn_recv_ce; /* Number of connections received CE atleast once */
1394 u_int32_t tcps_ecn_conn_recv_ece; /* Number of connections received ECE atleast once */
1395 u_int32_t tcps_ecn_conn_plnoce; /* Number of connections that received no CE and sufferred packet loss */
1396 u_int32_t tcps_ecn_conn_pl_ce; /* Number of connections that received CE and sufferred packet loss */
1397 u_int32_t tcps_ecn_conn_nopl_ce; /* Number of connections that received CE and sufferred no packet loss */
1398 u_int32_t tcps_ecn_fallback_synloss; /* Number of times we did fall back due to SYN-Loss */
1399 u_int32_t tcps_ecn_fallback_reorder; /* Number of times we fallback because we detected the PAWS-issue */
1400 u_int32_t tcps_ecn_fallback_ce; /* Number of times we fallback because we received too many CEs */
1401
1402 /* TFO-related statistics */
1403 u_int32_t tcps_tfo_syn_data_rcv; /* Received a SYN+data with valid cookie */
1404 u_int32_t tcps_tfo_cookie_req_rcv;/* Received a TFO cookie-request */
1405 u_int32_t tcps_tfo_cookie_sent; /* Offered a TFO-cookie to the client */
1406 u_int32_t tcps_tfo_cookie_invalid;/* Received an invalid TFO-cookie */
1407 u_int32_t tcps_tfo_cookie_req; /* Cookie requested with the SYN */
1408 u_int32_t tcps_tfo_cookie_rcv; /* Cookie received in a SYN/ACK */
1409 u_int32_t tcps_tfo_syn_data_sent; /* SYN+data+cookie sent */
1410 u_int32_t tcps_tfo_syn_data_acked;/* SYN+data has been acknowledged */
1411 u_int32_t tcps_tfo_syn_loss; /* SYN+TFO has been lost and we fallback */
1412 u_int32_t tcps_tfo_blackhole; /* TFO got blackholed by a middlebox. */
1413 u_int32_t tcps_tfo_cookie_wrong; /* TFO-cookie we sent was wrong */
1414 u_int32_t tcps_tfo_no_cookie_rcv; /* We asked for a cookie but didn't get one */
1415 u_int32_t tcps_tfo_heuristics_disable; /* TFO got disabled due to heuristics */
1416 u_int32_t tcps_tfo_sndblackhole; /* TFO got blackholed in the sending direction */
1417 u_int32_t tcps_mss_to_default; /* Change MSS to default using link status report */
1418 u_int32_t tcps_mss_to_medium; /* Change MSS to medium using link status report */
1419 u_int32_t tcps_mss_to_low; /* Change MSS to low using link status report */
1420 u_int32_t tcps_ecn_fallback_droprst; /* ECN fallback caused by connection drop due to RST */
1421 u_int32_t tcps_ecn_fallback_droprxmt; /* ECN fallback due to drop after multiple retransmits */
1422 u_int32_t tcps_ecn_fallback_synrst; /* ECN fallback due to rst after syn */
1423
1424 u_int32_t tcps_mptcp_rcvmemdrop; /* MPTCP packets dropped for lack of memory */
1425 u_int32_t tcps_mptcp_rcvduppack; /* MPTCP duplicate-only packets received */
1426 u_int32_t tcps_mptcp_rcvpackafterwin; /* MPTCP packets with data after window */
1427
1428 /* TCP timer statistics */
1429 u_int32_t tcps_timer_drift_le_1_ms; /* Timer drift less or equal to 1 ms */
1430 u_int32_t tcps_timer_drift_le_10_ms; /* Timer drift less or equal to 10 ms */
1431 u_int32_t tcps_timer_drift_le_20_ms; /* Timer drift less or equal to 20 ms */
1432 u_int32_t tcps_timer_drift_le_50_ms; /* Timer drift less or equal to 50 ms */
1433 u_int32_t tcps_timer_drift_le_100_ms; /* Timer drift less or equal to 100 ms */
1434 u_int32_t tcps_timer_drift_le_200_ms; /* Timer drift less or equal to 200 ms */
1435 u_int32_t tcps_timer_drift_le_500_ms; /* Timer drift less or equal to 500 ms */
1436 u_int32_t tcps_timer_drift_le_1000_ms; /* Timer drift less or equal to 1000 ms */
1437 u_int32_t tcps_timer_drift_gt_1000_ms; /* Timer drift greater than 1000 ms */
1438
1439 u_int32_t tcps_mptcp_handover_attempt; /* Total number of MPTCP-attempts using handover mode */
1440 u_int32_t tcps_mptcp_interactive_attempt; /* Total number of MPTCP-attempts using interactive mode */
1441 u_int32_t tcps_mptcp_aggregate_attempt; /* Total number of MPTCP-attempts using aggregate mode */
1442 u_int32_t tcps_mptcp_fp_handover_attempt; /* Same as previous three but only for first-party apps */
1443 u_int32_t tcps_mptcp_fp_interactive_attempt;
1444 u_int32_t tcps_mptcp_fp_aggregate_attempt;
1445 u_int32_t tcps_mptcp_heuristic_fallback; /* Total number of MPTCP-connections that fell back due to heuristics */
1446 u_int32_t tcps_mptcp_fp_heuristic_fallback; /* Same as previous but for first-party apps */
1447 u_int32_t tcps_mptcp_handover_success_wifi; /* Total number of successfull handover-mode connections that *started* on WiFi */
1448 u_int32_t tcps_mptcp_handover_success_cell; /* Total number of successfull handover-mode connections that *started* on Cell */
1449 u_int32_t tcps_mptcp_interactive_success; /* Total number of interactive-mode connections that negotiated MPTCP */
1450 u_int32_t tcps_mptcp_aggregate_success; /* Same as previous but for aggregate */
1451 u_int32_t tcps_mptcp_fp_handover_success_wifi; /* Same as previous four, but for first-party apps */
1452 u_int32_t tcps_mptcp_fp_handover_success_cell;
1453 u_int32_t tcps_mptcp_fp_interactive_success;
1454 u_int32_t tcps_mptcp_fp_aggregate_success;
1455 u_int32_t tcps_mptcp_handover_cell_from_wifi; /* Total number of connections that use cell in handover-mode (coming from WiFi) */
1456 u_int32_t tcps_mptcp_handover_wifi_from_cell; /* Total number of connections that use WiFi in handover-mode (coming from cell) */
1457 u_int32_t tcps_mptcp_interactive_cell_from_wifi; /* Total number of connections that use cell in interactive mode (coming from WiFi) */
1458 u_int64_t tcps_mptcp_handover_cell_bytes; /* Total number of bytes sent on cell in handover-mode (on new subflows, ignoring initial one) */
1459 u_int64_t tcps_mptcp_interactive_cell_bytes; /* Same as previous but for interactive */
1460 u_int64_t tcps_mptcp_aggregate_cell_bytes;
1461 u_int64_t tcps_mptcp_handover_all_bytes; /* Total number of bytes sent in handover */
1462 u_int64_t tcps_mptcp_interactive_all_bytes;
1463 u_int64_t tcps_mptcp_aggregate_all_bytes;
1464 u_int32_t tcps_mptcp_back_to_wifi; /* Total number of connections that succeed to move traffic away from cell (when starting on cell) */
1465 u_int32_t tcps_mptcp_wifi_proxy; /* Total number of new subflows that fell back to regular TCP on cell */
1466 u_int32_t tcps_mptcp_cell_proxy; /* Total number of new subflows that fell back to regular TCP on WiFi */
1467
1468 /* TCP offload statistics */
1469 u_int32_t tcps_ka_offload_drops; /* Keep alive drops for timeout reported by firmware */
1470
1471 u_int32_t tcps_mptcp_triggered_cell; /* Total number of times an MPTCP-connection triggered cell bringup */
1472
1473 u_int32_t tcps_fin_timeout_drops;
1474
1475 /* RST compression statistics */
1476 u_int64_t tcps_rst_dup_suppressed;
1477 u_int64_t tcps_rst_not_suppressed;
1478 };
1479
1480 #ifdef PRIVATE
1481 #define HAS_TCPSTAT_RST_SUPPRESSION 1
1482 #endif /* PRIVATE */
1483
1484 struct tcpstat_local {
1485 u_int64_t badformat;
1486 u_int64_t unspecv6;
1487 u_int64_t synfin;
1488 u_int64_t badformatipsec;
1489 u_int64_t noconnnolist;
1490 u_int64_t noconnlist;
1491 u_int64_t listbadsyn;
1492 u_int64_t icmp6unreach;
1493 u_int64_t deprecate6;
1494 u_int64_t ooopacket;
1495 u_int64_t rstinsynrcv;
1496 u_int64_t dospacket;
1497 u_int64_t cleanup;
1498 u_int64_t synwindow;
1499 u_int64_t linkheur_stealthdrop;
1500 u_int64_t linkheur_noackpri;
1501 u_int64_t linkheur_comprxmt;
1502 u_int64_t linkheur_synrxmt;
1503 u_int64_t linkheur_rxmtfloor;
1504 };
1505
1506 #pragma pack(4)
1507
1508 /*
1509 * TCB structure exported to user-land via sysctl(3).
1510 * Evil hack: declare only if in_pcb.h and sys/socketvar.h have been
1511 * included. Not all of our clients do.
1512 */
1513
1514 struct xtcpcb {
1515 u_int32_t xt_len;
1516 #ifdef KERNEL_PRIVATE
1517 struct inpcb_compat xt_inp;
1518 #else
1519 struct inpcb xt_inp;
1520 #endif
1521 #ifdef KERNEL_PRIVATE
1522 struct otcpcb xt_tp;
1523 #else
1524 struct tcpcb xt_tp;
1525 #endif
1526 struct xsocket xt_socket;
1527 u_quad_t xt_alignment_hack;
1528 };
1529
1530 #if XNU_TARGET_OS_OSX || KERNEL || !(TARGET_OS_IPHONE && !TARGET_OS_SIMULATOR)
1531
1532 struct xtcpcb64 {
1533 u_int32_t xt_len;
1534 struct xinpcb64 xt_inpcb;
1535
1536 u_int64_t t_segq;
1537 int t_dupacks; /* consecutive dup acks recd */
1538
1539 int t_timer[TCPT_NTIMERS_EXT]; /* tcp timers */
1540
1541 int t_state; /* state of this connection */
1542 u_int t_flags;
1543
1544 int t_force; /* 1 if forcing out a byte */
1545
1546 tcp_seq snd_una; /* send unacknowledged */
1547 tcp_seq snd_max; /* highest sequence number sent;
1548 * used to recognize retransmits
1549 */
1550 tcp_seq snd_nxt; /* send next */
1551 tcp_seq snd_up; /* send urgent pointer */
1552
1553 tcp_seq snd_wl1; /* window update seg seq number */
1554 tcp_seq snd_wl2; /* window update seg ack number */
1555 tcp_seq iss; /* initial send sequence number */
1556 tcp_seq irs; /* initial receive sequence number */
1557
1558 tcp_seq rcv_nxt; /* receive next */
1559 tcp_seq rcv_adv; /* advertised window */
1560 u_int32_t rcv_wnd; /* receive window */
1561 tcp_seq rcv_up; /* receive urgent pointer */
1562
1563 u_int32_t snd_wnd; /* send window */
1564 u_int32_t snd_cwnd; /* congestion-controlled window */
1565 u_int32_t snd_ssthresh; /* snd_cwnd size threshold for
1566 * for slow start exponential to
1567 * linear switch
1568 */
1569 u_int t_maxopd; /* mss plus options */
1570
1571 u_int32_t t_rcvtime; /* time at which a packet was received */
1572 u_int32_t t_starttime; /* time connection was established */
1573 int t_rtttime; /* round trip time */
1574 tcp_seq t_rtseq; /* sequence number being timed */
1575
1576 int t_rxtcur; /* current retransmit value (ticks) */
1577 u_int t_maxseg; /* maximum segment size */
1578 int t_srtt; /* smoothed round-trip time */
1579 int t_rttvar; /* variance in round-trip time */
1580
1581 int t_rxtshift; /* log(2) of rexmt exp. backoff */
1582 u_int t_rttmin; /* minimum rtt allowed */
1583 u_int32_t t_rttupdated; /* number of times rtt sampled */
1584 u_int32_t max_sndwnd; /* largest window peer has offered */
1585
1586 int t_softerror; /* possible error not yet reported */
1587 /* out-of-band data */
1588 char t_oobflags; /* have some */
1589 char t_iobc; /* input character */
1590 /* RFC 1323 variables */
1591 u_char snd_scale; /* window scaling for send window */
1592 u_char rcv_scale; /* window scaling for recv window */
1593 u_char request_r_scale; /* pending window scaling */
1594 u_char requested_s_scale;
1595 u_int32_t ts_recent; /* timestamp echo data */
1596
1597 u_int32_t ts_recent_age; /* when last updated */
1598 tcp_seq last_ack_sent;
1599 /* RFC 1644 variables */
1600 tcp_cc cc_send; /* send connection count */
1601 tcp_cc cc_recv; /* receive connection count */
1602 tcp_seq snd_recover; /* for use in fast recovery */
1603 /* experimental */
1604 u_int32_t snd_cwnd_prev; /* cwnd prior to retransmit */
1605 u_int32_t snd_ssthresh_prev; /* ssthresh prior to retransmit */
1606 u_int32_t t_badrxtwin; /* window for retransmit recovery */
1607
1608 u_quad_t xt_alignment_hack;
1609 };
1610
1611 #endif /* XNU_TARGET_OS_OSX || KERNEL || !(TARGET_OS_IPHONE && !TARGET_OS_SIMULATOR) */
1612
1613 #ifdef PRIVATE
1614
1615 struct xtcpcb_n {
1616 u_int32_t xt_len;
1617 u_int32_t xt_kind; /* XSO_TCPCB */
1618
1619 u_int64_t t_segq;
1620 int t_dupacks; /* consecutive dup acks recd */
1621
1622 int t_timer[TCPT_NTIMERS_EXT]; /* tcp timers */
1623
1624 int t_state; /* state of this connection */
1625 u_int t_flags;
1626
1627 int t_force; /* 1 if forcing out a byte */
1628
1629 tcp_seq snd_una; /* send unacknowledged */
1630 tcp_seq snd_max; /* highest sequence number sent;
1631 * used to recognize retransmits
1632 */
1633 tcp_seq snd_nxt; /* send next */
1634 tcp_seq snd_up; /* send urgent pointer */
1635
1636 tcp_seq snd_wl1; /* window update seg seq number */
1637 tcp_seq snd_wl2; /* window update seg ack number */
1638 tcp_seq iss; /* initial send sequence number */
1639 tcp_seq irs; /* initial receive sequence number */
1640
1641 tcp_seq rcv_nxt; /* receive next */
1642 tcp_seq rcv_adv; /* advertised window */
1643 u_int32_t rcv_wnd; /* receive window */
1644 tcp_seq rcv_up; /* receive urgent pointer */
1645
1646 u_int32_t snd_wnd; /* send window */
1647 u_int32_t snd_cwnd; /* congestion-controlled window */
1648 u_int32_t snd_ssthresh; /* snd_cwnd size threshold for
1649 * for slow start exponential to
1650 * linear switch
1651 */
1652 u_int t_maxopd; /* mss plus options */
1653
1654 u_int32_t t_rcvtime; /* time at which a packet was received */
1655 u_int32_t t_starttime; /* time connection was established */
1656 int t_rtttime; /* round trip time */
1657 tcp_seq t_rtseq; /* sequence number being timed */
1658
1659 int t_rxtcur; /* current retransmit value (ticks) */
1660 u_int t_maxseg; /* maximum segment size */
1661 int t_srtt; /* smoothed round-trip time */
1662 int t_rttvar; /* variance in round-trip time */
1663
1664 int t_rxtshift; /* log(2) of rexmt exp. backoff */
1665 u_int t_rttmin; /* minimum rtt allowed */
1666 u_int32_t t_rttupdated; /* number of times rtt sampled */
1667 u_int32_t max_sndwnd; /* largest window peer has offered */
1668
1669 int t_softerror; /* possible error not yet reported */
1670 /* out-of-band data */
1671 char t_oobflags; /* have some */
1672 char t_iobc; /* input character */
1673 /* RFC 1323 variables */
1674 u_char snd_scale; /* window scaling for send window */
1675 u_char rcv_scale; /* window scaling for recv window */
1676 u_char request_r_scale; /* pending window scaling */
1677 u_char requested_s_scale;
1678 u_int32_t ts_recent; /* timestamp echo data */
1679
1680 u_int32_t ts_recent_age; /* when last updated */
1681 tcp_seq last_ack_sent;
1682 /* RFC 1644 variables */
1683 tcp_cc cc_send; /* send connection count */
1684 tcp_cc cc_recv; /* receive connection count */
1685 tcp_seq snd_recover; /* for use in fast recovery */
1686 /* experimental */
1687 u_int32_t snd_cwnd_prev; /* cwnd prior to retransmit */
1688 u_int32_t snd_ssthresh_prev; /* ssthresh prior to retransmit */
1689 };
1690
1691 /*
1692 * The rtt measured is in milliseconds as the timestamp granularity is
1693 * a millisecond. The smoothed round-trip time and estimated variance
1694 * are stored as fixed point numbers scaled by the values below.
1695 * For convenience, these scales are also used in smoothing the average
1696 * (smoothed = (1/scale)sample + ((scale-1)/scale)smoothed).
1697 * With these scales, srtt has 5 bits to the right of the binary point,
1698 * and thus an "ALPHA" of 0.875. rttvar has 4 bits to the right of the
1699 * binary point, and is smoothed with an ALPHA of 0.75.
1700 */
1701 #define TCP_RTT_SCALE 32 /* multiplier for srtt; 3 bits frac. */
1702 #define TCP_RTT_SHIFT 5 /* shift for srtt; 5 bits frac. */
1703 #define TCP_RTTVAR_SCALE 16 /* multiplier for rttvar; 4 bits */
1704 #define TCP_RTTVAR_SHIFT 4 /* shift for rttvar; 4 bits */
1705 #define TCP_DELTA_SHIFT 2 /* see tcp_input.c */
1706
1707 struct tcpprobereq {
1708 u_int64_t ifindex; /* Optional interface index for TCP keep-alive probing */
1709 u_int64_t enable; /* Flag to enable or disable probing (1=on, 0=off)*/
1710 u_int64_t filter_flags; /* Optional flags for filtering interfaces per ntstat.h (NSTAT_IFNET_IS_*) */
1711 u_int32_t reserved; /* Expansion */
1712 u_int32_t reserved2; /* Expansion */
1713 };
1714
1715 #endif /* PRIVATE */
1716
1717 #pragma pack()
1718
1719 /*
1720 * Names for TCP sysctl objects
1721 */
1722 #define TCPCTL_DO_RFC1323 1 /* use RFC-1323 extensions */
1723 #define TCPCTL_DO_RFC1644 2 /* use RFC-1644 extensions */
1724 #define TCPCTL_MSSDFLT 3 /* MSS default */
1725 #define TCPCTL_STATS 4 /* statistics (read-only) */
1726 #define TCPCTL_RTTDFLT 5 /* default RTT estimate */
1727 #define TCPCTL_KEEPIDLE 6 /* keepalive idle timer */
1728 #define TCPCTL_KEEPINTVL 7 /* interval to send keepalives */
1729 #define TCPCTL_SENDSPACE 8 /* send buffer space */
1730 #define TCPCTL_RECVSPACE 9 /* receive buffer space */
1731 #define TCPCTL_KEEPINIT 10 /* timeout for establishing syn */
1732 #define TCPCTL_PCBLIST 11 /* list of all outstanding PCBs */
1733 #define TCPCTL_DELACKTIME 12 /* time before sending delayed ACK */
1734 #define TCPCTL_V6MSSDFLT 13 /* MSS default for IPv6 */
1735 #define TCPCTL_MAXID 14
1736
1737 #ifdef BSD_KERNEL_PRIVATE
1738 #include <sys/bitstring.h>
1739
1740 #define TCP_PKTLIST_CLEAR(tp) { \
1741 (tp)->t_pktlist_head = (tp)->t_pktlist_tail = NULL; \
1742 (tp)->t_lastchain = (tp)->t_pktlist_sentlen = 0; \
1743 }
1744
1745 extern int tcp_TCPTV_MIN;
1746
1747 #ifdef SYSCTL_DECL
1748 SYSCTL_DECL(_net_inet_tcp);
1749 #endif /* SYSCTL_DECL */
1750
1751 extern struct inpcbhead tcb; /* head of queue of active tcpcb's */
1752 extern struct inpcbinfo tcbinfo;
1753 extern struct tcpstat tcpstat; /* tcp statistics */
1754 extern int tcp_mssdflt; /* XXX */
1755 extern int tcp_minmss;
1756 #define TCP_FASTOPEN_SERVER 0x01
1757 #define TCP_FASTOPEN_CLIENT 0x02
1758
1759 extern int tcp_tfo_halfcnt;
1760 extern int tcp_tfo_backlog;
1761 extern int tcp_fastopen;
1762 extern int ss_fltsz_local;
1763 extern int target_qdelay;
1764 extern uint32_t tcp_now; /* for RFC 1323 timestamps */
1765 extern int tcp_delack_enabled;
1766 extern int maxseg_unacked;
1767 extern int tcp_ecn;
1768 extern uint32_t tcp_do_autorcvbuf;
1769 extern uint32_t tcp_autorcvbuf_max;
1770 extern int tcp_recv_bg;
1771 extern int tcp_do_ack_compression;
1772 extern int tcp_randomize_timestamps;
1773 extern int tcp_rledbat;
1774 extern int tcp_use_min_curr_rtt;
1775 extern int tcp_do_timestamps;
1776
1777 /*
1778 * Feature flags for LQM heuristics
1779 * Can be useful for testing
1780 */
1781 #define TCP_LINK_HEUR_RXMT_COMP 0x0001
1782 #define TCP_LINK_HEUR_NOACKPRI 0x0002
1783 #define TCP_LINK_HEUR_SYNRMXT 0x0004
1784 #define TCP_LINK_HEUR_STEALTH 0x0008
1785 #define TCP_LINK_HEUR_RTOMIN 0x0010
1786 #define TCP_LINK_HEUR_NOTLP 0x0020
1787
1788 #define TCP_LINK_HEURISTICS_DEFAULT (\
1789 TCP_LINK_HEUR_RXMT_COMP | \
1790 TCP_LINK_HEUR_NOACKPRI | \
1791 TCP_LINK_HEUR_SYNRMXT | \
1792 TCP_LINK_HEUR_STEALTH | \
1793 TCP_LINK_HEUR_RTOMIN | \
1794 TCP_LINK_HEUR_NOTLP)
1795
1796 extern int32_t tcp_link_heuristics_flags;
1797 extern int32_t tcp_link_heuristics_rto_min;
1798
1799 #define TCP_COMP_RXMT_GENCNT_MASK 0x80000000
1800
1801 /* 3 seconds is conservative value (see RFC 2988 and RFC 6298) */
1802 #define TCP_DEFAULT_LINK_HEUR_RTOMIN 3000
1803
1804 /*
1805 * Dummy value used for when there is no flow and we want to ensure that compression
1806 * can happen.
1807 */
1808 #define TCP_ACK_COMPRESSION_DUMMY 1
1809
1810 extern struct tseg_qent *tcp_create_reass_qent(struct tcpcb *tp, struct mbuf *m,
1811 struct tcphdr *th, int len);
1812 extern struct mbuf *tcp_destroy_reass_qent(struct tcpcb *tp,
1813 struct tseg_qent *q);
1814 KALLOC_TYPE_DECLARE(tcp_reass_zone);
1815 extern struct tseg_qent *tcp_reass_qent_alloc(struct protosw *proto);
1816 extern void tcp_reass_qent_free(struct protosw *proto, struct tseg_qent *te);
1817
1818 extern int tcp_rack;
1819
1820 extern int tcp_reass_total_qlen;
1821
1822 struct protosw;
1823 struct domain;
1824
1825 struct tcp_respond_args {
1826 unsigned int ifscope;
1827 unsigned int nocell:1,
1828 noexpensive:1,
1829 awdl_unrestricted:1,
1830 intcoproc_allowed:1,
1831 keep_alive:1,
1832 noconstrained:1,
1833 management_allowed:1,
1834 ultra_constrained_allowed:1;
1835 };
1836
1837 void tcp_canceltimers(struct tcpcb *);
1838 uint8_t tcp_addoptions(struct tcpopt *to, u_char * __ended_by(optend) optp, u_char * optend);
1839 struct tcpcb *
1840 tcp_close(struct tcpcb *);
1841 void tcp_ctlinput(int, struct sockaddr *, void *, struct ifnet *);
1842 int tcp_ctloutput(struct socket *, struct sockopt *);
1843 struct tcpcb *
1844 tcp_drop(struct tcpcb *, int);
1845 void tcp_drain(void);
1846 void tcp_getrt_rtt(struct tcpcb *tp, struct rtentry *rt);
1847 void tcp_init(struct protosw *, struct domain *);
1848 bool tcp_create_server_socket(struct tcp_inp *tpi, struct socket **so2, bool *syn_cookie_sent, int *dropsocket);
1849 bool tcp_setup_server_socket(struct tcp_inp *tpi, struct socket *so, bool syn_cookie_used);
1850 void tcp_input(struct mbuf *, int);
1851 void tcp_mss(struct tcpcb *, int, unsigned int);
1852 uint32_t tcp_ceil(double a);
1853 uint32_t tcp_round_to(uint32_t val, uint32_t round);
1854 uint32_t tcp_round_up(uint32_t val, uint32_t base);
1855 uint32_t ntoh24(u_char * p __sized_by(3));
1856 uint32_t tcp_packets_this_ack(struct tcpcb *tp, uint32_t acked);
1857 int tcp_mssopt(struct tcpcb *);
1858 void tcp_drop_syn_sent(struct inpcb *, int);
1859 uint32_t tcp_get_effective_mtu(struct rtentry *, uint32_t);
1860 void tcp_mtudisc(struct inpcb *, int);
1861 struct tcpcb *
1862 tcp_newtcpcb(struct inpcb *);
1863 int tcp_output(struct tcpcb *);
1864 void tcp_respond(struct tcpcb *, void *ipgen __sized_by(ipgen_size), size_t ipgen_size, struct tcphdr *, struct mbuf *,
1865 tcp_seq, tcp_seq, uint32_t, uint16_t, struct tcpopt *, uint16_t, uint8_t, uint32_t, struct tcp_respond_args *, bool send_syncookie);
1866 struct rtentry *
1867 tcp_rtlookup(struct inpcb *, unsigned int);
1868 void tcp_setpersist(struct tcpcb *);
1869 void tcp_gc(struct inpcbinfo *);
1870 void tcp_itimer(struct inpcbinfo *ipi);
1871 void tcp_check_timer_state(struct tcpcb *tp);
1872 void tcp_run_timerlist(void *arg1, void *arg2);
1873 void tcp_sched_timers(struct tcpcb *tp);
1874
1875 struct tcptemp *tcp_maketemplate(struct tcpcb *, struct mbuf **, struct sockaddr *, struct sockaddr *);
1876 void tcp_fillheaders(struct mbuf *, struct tcpcb *, void *, void *, struct sockaddr *, struct sockaddr *);
1877 struct tcpcb *tcp_timers(struct tcpcb *, int);
1878 void tcp_trace(int, int, struct tcpcb *, void *, struct tcphdr *, int);
1879
1880 void tcp_fill_info(struct tcpcb *, struct tcp_info *);
1881 void tcp_sack_doack(struct tcpcb *, struct tcpopt *, struct tcphdr *,
1882 uint32_t *, uint32_t *);
1883 extern boolean_t tcp_sack_process_dsack(struct tcpcb *, struct tcpopt *,
1884 struct tcphdr *, boolean_t *);
1885 int tcp_detect_bad_rexmt(struct tcpcb *, struct tcphdr *, struct tcpopt *,
1886 u_int32_t rxtime);
1887 void tcp_update_sack_list(struct tcpcb *tp, tcp_seq rcv_laststart, tcp_seq rcv_lastend);
1888 void tcp_clean_sackreport(struct tcpcb *tp);
1889 uint32_t tcp_sack_adjust(struct tcpcb *tp);
1890 struct sackhole *tcp_sack_output(struct tcpcb *tp, int *sack_bytes_rexmt);
1891 void tcp_sack_partialack(struct tcpcb *, struct tcphdr *);
1892 void tcp_free_sackholes(struct tcpcb *tp);
1893 int32_t tcp_sbspace(struct tcpcb *tp);
1894 void tcp_set_tso(struct tcpcb *tp, struct ifnet *ifp);
1895 void tcp_set_ecn(struct tcpcb *tp);
1896 void tcp_set_l4s(struct tcpcb *tp, struct ifnet *ifp);
1897 void tcp_set_accurate_ecn(struct tcpcb *tp);
1898 bool tcp_ecn_enabled(uint32_t ecn_flags);
1899 uint8_t tcp_get_ace(struct tcphdr *th);
1900 uint32_t tcp_flight_size(struct tcpcb *tp);
1901 extern void tcp_get_ports_used(ifnet_t ifp, int, u_int32_t, bitstr_t *__counted_by(bitstr_size(IP_PORTRANGE_SIZE)));
1902 uint32_t tcp_count_opportunistic(unsigned int ifindex, u_int32_t flags);
1903 uint32_t tcp_find_anypcb_byaddr(struct ifaddr *ifa);
1904 uint8_t tcp_get_max_rwinscale(struct tcpcb *tp, struct socket *so);
1905 struct bwmeas* tcp_bwmeas_alloc(struct tcpcb *tp);
1906 void tcp_bwmeas_free(struct tcpcb *tp);
1907 extern int32_t timer_diff(uint32_t t1, uint32_t toff1, uint32_t t2, uint32_t toff2);
1908
1909 /* RACK related functions */
1910 void tcp_rack_transmit_seg(struct tcpcb *tp, struct tcp_seg_sent *seg, tcp_seq start, tcp_seq end, uint32_t xmit_ts, uint8_t flags);
1911 void tcp_rack_update_reordering_window(struct tcpcb *tp, tcp_seq highest_acked_sacked);
1912 void tcp_rack_update_reordering_win_persist(struct tcpcb *tp);
1913 void tcp_rack_bad_rexmt_restore(struct tcpcb *tp);
1914 void tcp_rack_reset_segs_retransmitted(struct tcpcb *tp);
1915 void tcp_rack_update_segment_acked(struct tcpcb *tp, uint32_t tsecr, uint32_t xmit_ts, uint32_t end_seq, bool retransmitted);
1916 bool tcp_rack_detect_loss_and_arm_timer(struct tcpcb *tp, uint32_t dup_acks);
1917 void tcp_rack_reordering_timeout(struct tcpcb *tp, uint32_t dup_acks);
1918 struct tcp_seg_sent * tcp_rack_output(struct tcpcb *tp, uint32_t cwin, uint16_t *rack_seg_len);
1919 void tcp_rack_loss_on_rto(struct tcpcb *tp, bool in_rto);
1920 uint32_t tcp_rack_adjust(struct tcpcb *tp, uint32_t cwin);
1921 void tcp_rack_detect_reordering_dsack(struct tcpcb *tp, tcp_seq start, tcp_seq end);
1922 void tcp_rack_detect_reordering_acked(struct tcpcb *tp, struct tcp_seg_sent *seg);
1923 /* RACK segment related functions */
1924 uint32_t tcp_seg_len(struct tcp_seg_sent *seg);
1925 void tcp_seg_sent_insert(struct tcpcb *tp, struct tcp_seg_sent *seg, tcp_seq start, tcp_seq end, uint32_t xmit_ts, uint8_t flags);
1926 void tcp_segs_doack(struct tcpcb *tp, tcp_seq th_ack, struct tcpopt *to);
1927 void tcp_segs_dosack(struct tcpcb *tp, tcp_seq sblk_start, tcp_seq sblk_end, uint32_t tsecr, uint32_t *newbytes_sacked);
1928 void tcp_segs_clear_sacked(struct tcpcb *tp);
1929 void tcp_mark_seg_lost(struct tcpcb *tp, struct tcp_seg_sent *seg);
1930 void tcp_seg_delete(struct tcpcb *tp, struct tcp_seg_sent *seg);
1931 void tcp_segs_sent_clean(struct tcpcb *tp, bool free_segs);
1932
1933 extern void tcp_set_background_cc(struct socket *);
1934 extern void tcp_set_foreground_cc(struct socket *);
1935 extern void tcp_set_recv_bg(struct socket *);
1936 extern void tcp_clear_recv_bg(struct socket *);
1937 extern boolean_t tcp_sack_byte_islost(struct tcpcb *tp);
1938 #define IS_TCP_RECV_BG(_so) \
1939 ((_so)->so_flags1 & SOF1_TRAFFIC_MGT_TCP_RECVBG)
1940
1941 #if TRAFFIC_MGT
1942 #define CLEAR_IAJ_STATE(_tp_) (_tp_)->iaj_rcv_ts = 0
1943 void reset_acc_iaj(struct tcpcb *tp);
1944 #endif /* TRAFFIC_MGT */
1945
1946 int tcp_lock(struct socket *, int, void *);
1947 int tcp_unlock(struct socket *, int, void *);
1948 void calculate_tcp_clock(void);
1949
1950 extern void tcp_keepalive_reset(struct tcpcb *);
1951 extern uint32_t get_base_rtt(struct tcpcb *tp);
1952
1953 #ifdef _KERN_LOCKS_H_
1954 lck_mtx_t * tcp_getlock(struct socket *, int);
1955 #else
1956 void * tcp_getlock(struct socket *, int);
1957 #endif
1958
1959 extern struct pr_usrreqs tcp_usrreqs;
1960 extern uint32_t tcp_sendspace;
1961 extern uint32_t tcp_recvspace;
1962 extern tcp_seq tcp_new_isn(struct tcpcb *tp);
1963
1964 extern int tcp_input_checksum(int, struct mbuf *, struct tcphdr *, int, int);
1965 extern void tcp_getconninfo(struct socket *, struct conninfo_tcp *);
1966 extern void add_to_time_wait(struct tcpcb *, uint32_t delay);
1967 extern void add_to_time_wait_now(struct tcpcb *tp, uint32_t delay);
1968 extern void tcp_pmtud_revert_segment_size(struct tcpcb *tp);
1969 extern void tcp_rxtseg_insert(struct tcpcb *, tcp_seq, tcp_seq);
1970 extern struct tcp_rxt_seg *tcp_rxtseg_find(struct tcpcb *, tcp_seq, tcp_seq);
1971 extern void tcp_rxtseg_set_spurious(struct tcpcb *tp, tcp_seq start, tcp_seq end);
1972 extern void tcp_rxtseg_clean(struct tcpcb *);
1973 extern boolean_t tcp_rxtseg_detect_bad_rexmt(struct tcpcb *, tcp_seq);
1974 extern boolean_t tcp_rxtseg_dsack_for_tlp(struct tcpcb *);
1975 extern u_int32_t tcp_rxtseg_total_size(struct tcpcb *tp);
1976 extern void tcp_rexmt_save_state(struct tcpcb *tp);
1977 void tcp_local_congestion_notification(struct tcpcb *tp);
1978 void tcp_enter_fast_recovery(struct tcpcb *tp);
1979 extern void tcp_interface_send_probe(u_int16_t if_index_available);
1980 extern void tcp_probe_connectivity(struct ifnet *ifp, u_int32_t enable);
1981 extern void tcp_get_connectivity_status(struct tcpcb *,
1982 struct tcp_conn_status *);
1983
1984 extern void tcp_clear_keep_alive_offload(struct socket *so);
1985 extern void tcp_fill_keepalive_offload_frames(struct ifnet *,
1986 struct ifnet_keepalive_offload_frame * frames_array __counted_by(frames_array_count), u_int32_t frames_array_count, size_t, u_int32_t *);
1987 extern int tcp_notify_kao_timeout(ifnet_t ifp,
1988 struct ifnet_keepalive_offload_frame *frame);
1989
1990 extern void tcp_disable_tfo(struct tcpcb *tp);
1991 extern void tcp_tfo_gen_cookie(struct inpcb *inp, u_char *out __sized_by(blk_size), size_t blk_size);
1992 #define TCP_FASTOPEN_KEYLEN 16
1993 extern errno_t tcp_notify_ack_id_valid(struct tcpcb *, struct socket *, u_int32_t);
1994 extern errno_t tcp_add_notify_ack_marker(struct tcpcb *, u_int32_t);
1995 extern void tcp_notify_ack_free(struct tcpcb *);
1996 extern void tcp_notify_acknowledgement(struct tcpcb *, struct socket *);
1997 extern void tcp_get_notify_ack_count(struct tcpcb *,
1998 struct tcp_notify_ack_complete *);
1999 extern void tcp_get_notify_ack_ids(struct tcpcb *tp,
2000 struct tcp_notify_ack_complete *);
2001 extern void tcp_update_mss_locked(struct socket *, struct ifnet *);
2002
2003 extern int get_tcp_inp_list(struct inpcb * __single * __counted_by(n), size_t n, inp_gen_t);
2004 extern bool tcp_notify_ack_active(struct socket *so);
2005 extern void tcp_set_finwait_timeout(struct tcpcb *);
2006
2007 #if MPTCP
2008 extern uint16_t mptcp_output_csum(struct mbuf *m, uint64_t dss_val,
2009 uint32_t sseq, uint16_t dlen);
2010 extern int mptcp_adj_mss(struct tcpcb *, boolean_t);
2011 extern void mptcp_insert_rmap(struct tcpcb *tp, struct mbuf *m, struct tcphdr *th);
2012 #endif
2013
2014 extern uint32_t tcp_reass_qlen_space(struct socket *);
2015
2016 __private_extern__ void tcp_update_stats_per_flow(
2017 struct ifnet_stats_per_flow *, struct ifnet *);
2018
2019 extern void tcp_set_rto(struct tcpcb *tp);
2020 extern void tcp_set_pto(struct tcpcb *tp);
2021
2022 extern bool tcp_rst_rlc_compress(void *ipgen __sized_by(ipgen_size), size_t ipgen_size, struct tcphdr *th);
2023
2024 extern struct mem_acct *tcp_memacct;
2025
2026 #if SKYWALK
2027 void tcp_add_fsw_flow(struct tcpcb *, struct ifnet *);
2028 void tcp_del_fsw_flow(struct tcpcb *);
2029 #else /* !SKYWALK */
2030 #define tcp_add_fsw_flow(...)
2031 #define tcp_del_fsw_flow(...)
2032 #endif /* !SKYWALK */
2033
2034 typedef void *__single lr_ref_t;
2035 #define TCP_INIT_LR_SAVED(lr) ((lr) == NULL \
2036 ? __unsafe_forge_single(void *, __builtin_return_address(0)) \
2037 : (lr))
2038
2039 /*
2040 * The initial retransmission should happen at rtt + 4 * rttvar.
2041 * Because of the way we do the smoothing, srtt and rttvar
2042 * will each average +1/2 tick of bias. When we compute
2043 * the retransmit timer, we want 1/2 tick of rounding and
2044 * 1 extra tick because of +-1/2 tick uncertainty in the
2045 * firing of the timer. The bias will give us exactly the
2046 * 1.5 tick we need. But, because the bias is
2047 * statistical, we have to test that we don't drop below
2048 * the minimum feasible timer (which is 2 ticks).
2049 * This version of the macro adapted from a paper by Lawrence
2050 * Brakmo and Larry Peterson which outlines a problem caused
2051 * by insufficient precision in the original implementation,
2052 * which results in inappropriately large RTO values for very
2053 * fast networks.
2054 */
2055 static inline uint32_t
tcp_rto_formula(uint32_t rttmin,uint32_t srtt,uint32_t rttvar)2056 tcp_rto_formula(uint32_t rttmin, uint32_t srtt, uint32_t rttvar)
2057 {
2058 return max(rttmin,
2059 ((srtt >> (TCP_RTT_SHIFT - TCP_DELTA_SHIFT)) + rttvar) >> TCP_DELTA_SHIFT);
2060 }
2061
2062 static inline uint32_t
_tcp_offset_from_start(const struct tcpcb * tp,uint32_t offset,uint32_t tcp_now_var)2063 _tcp_offset_from_start(const struct tcpcb *tp, uint32_t offset,
2064 uint32_t tcp_now_var)
2065 {
2066 return tcp_now_var + offset - tp->tentry.te_timer_start;
2067 }
2068
2069 static inline uint32_t
tcp_offset_from_start(const struct tcpcb * tp,uint32_t offset)2070 tcp_offset_from_start(const struct tcpcb *tp, uint32_t offset)
2071 {
2072 return _tcp_offset_from_start(tp, offset, tcp_now);
2073 }
2074
2075 #define TCP_REXMTVAL(tp) tcp_rto_formula((tp)->t_rttmin, (tp)->t_srtt, (tp)->t_rttvar)
2076 #endif /* BSD_KERNEL_PRIVATE */
2077
2078 #endif /* _NETINET_TCP_VAR_H_ */
2079