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