sys/netinet/tcp_stacks/tcp_bbr.h

   1 /*-
   2  * Copyright (c) 2016-2020 Netflix, Inc.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  * 1. Redistributions of source code must retain the above copyright
   8  *    notice, this list of conditions and the following disclaimer.
   9  * 2. Redistributions in binary form must reproduce the above copyright
  10  *    notice, this list of conditions and the following disclaimer in the
  11  *    documentation and/or other materials provided with the distribution.
  12  *
  13  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  14  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  16  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  17  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  18  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  19  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  20  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  21  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  22  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  23  * SUCH DAMAGE.
  24  *
  25  * $FreeBSD$
  26  */
  27
  28 #ifndef _NETINET_TCP_BBR_H_
  29 #define _NETINET_TCP_BBR_H_
  30
  31 #define BBR_INITIAL_RTO  1000000        /* 1 second in micro-seconds */
  32 /* Send map flags */
  33 #define BBR_ACKED         0x0001        /* The remote endpoint acked this */
  34 #define BBR_WAS_RENEGED   0x0002        /* The peer reneged the ack  */
  35 #define BBR_RXT_CLEARED   0x0004        /* ACK Cleared by the RXT timer  */
  36 #define BBR_OVERMAX       0x0008        /* We have more retran's then we can
  37                                          * fit */
  38 #define BBR_SACK_PASSED   0x0010        /* A sack was done above this block */
  39 #define BBR_WAS_SACKPASS  0x0020        /* We retransmitted due to SACK pass */
  40 #define BBR_HAS_FIN       0x0040        /* segment is sent with fin */
  41 #define BBR_TLP           0x0080        /* segment sent as tail-loss-probe */
  42 #define BBR_HAS_SYN       0x0100        /* segment has the syn */
  43 #define BBR_MARKED_LOST   0x0200        /*
  44                                          * This segments is lost and
  45                                          * totaled into bbr->rc_ctl.rc_lost
  46                                          */
  47 #define BBR_RWND_COLLAPSED 0x0400       /* The peer collapsed the rwnd on the segment */
  48 #define BBR_NUM_OF_RETRANS 7
  49
  50 /* Defines for socket options to set pacing overheads */
  51 #define BBR_INCL_ENET_OH 0x01
  52 #define BBR_INCL_IP_OH   0x02
  53 #define BBR_INCL_TCP_OH  0x03
  54
  55 /*
  56  * With the addition of both measurement algorithms
  57  * I had to move over the size of a
  58  * cache line (unfortunately). For now there is
  59  * no way around this. We may be able to cut back
  60  * at some point I hope.
  61  */
  62 struct bbr_sendmap {
  63         TAILQ_ENTRY(bbr_sendmap) r_next;        /* seq number arrayed next */
  64         TAILQ_ENTRY(bbr_sendmap) r_tnext;       /* Time of tmit based next */
  65         uint32_t r_start;       /* Sequence number of the segment */
  66         uint32_t r_end;         /* End seq, this is 1 beyond actually */
  67
  68         uint32_t r_rtr_bytes;   /* How many bytes have been retransmitted */
  69         uint32_t r_delivered;   /* Delivered amount at send */
  70
  71         uint32_t r_del_time;    /* The time of the last delivery update */
  72         uint8_t r_rtr_cnt:4,    /* Retran count, index this -1 to get time
  73                                  * sent */
  74                 unused_bit:1,
  75                 r_is_drain:1,   /* In a draining cycle */
  76                 r_app_limited:1,/* We went app limited */
  77                 r_ts_valid:1;   /* Timestamp field is valid (r_del_ack_ts) */
  78         uint8_t r_dupack;       /* Dup ack count */
  79         uint8_t r_in_tmap:1,    /* Flag to see if its in the r_tnext array */
  80                 r_is_smallmap:1,/* Was logged as a small-map send-map item */
  81                 r_is_gain:1,    /* Was in gain cycle */
  82                 r_bbr_state:5;  /* The BBR state at send */
  83         uint8_t r_limit_type;   /* is this entry counted against a limit? */
  84
  85         uint16_t r_flags;       /* Flags as defined above */
  86         uint16_t r_spare16;
  87         uint32_t r_del_ack_ts;  /* At send what timestamp of peer was (if r_ts_valid set) */
  88         /****************Cache line*****************/
  89         uint32_t r_tim_lastsent[BBR_NUM_OF_RETRANS];
  90         /*
  91          * Question, should we instead just grab the sending b/w
  92          * from the filter with the gain and store it in a
  93          * uint64_t instead?
  94          */
  95         uint32_t r_first_sent_time; /* Time of first pkt in flight sent */
  96         uint32_t r_pacing_delay;        /* pacing delay of this send */
  97         uint32_t r_flight_at_send;      /* flight at the time of the send */
  98 #ifdef _KERNEL
  99 }           __aligned(CACHE_LINE_SIZE);
 100 #else
 101 };
 102 #endif
 103 #define BBR_LIMIT_TYPE_SPLIT    1
 104
 105 TAILQ_HEAD(bbr_head, bbr_sendmap);
 106
 107 #define BBR_SEGMENT_TIME_SIZE 1500      /* How many bytes in time_between */
 108
 109 #define BBR_MIN_SEG 1460                /* MSS size */
 110 #define BBR_MAX_GAIN_VALUE 0xffff
 111
 112 #define BBR_TIMER_FUDGE  1500   /* 1.5ms in micro seconds */
 113
 114 /* BW twiddle secret codes */
 115 #define BBR_RED_BW_CONGSIG       0      /* We enter recovery and set using b/w */
 116 #define BBR_RED_BW_RATECAL       1      /* We are calculating the loss rate */
 117 #define BBR_RED_BW_USELRBW       2      /* We are dropping the lower b/w with
 118                                          * cDR */
 119 #define BBR_RED_BW_SETHIGHLOSS   3      /* We have set our highloss value at
 120                                          * exit from probe-rtt */
 121 #define BBR_RED_BW_PE_CLREARLY   4      /* We have decided to clear the
 122                                          * reduction early */
 123 #define BBR_RED_BW_PE_CLAFDEL    5      /* We are clearing it on schedule
 124                                          * delayed */
 125 #define BBR_RED_BW_REC_ENDCLL    6      /* Recover exits save high if needed
 126                                          * an clear to start measuring */
 127 #define BBR_RED_BW_PE_NOEARLY_OUT 7     /* Set pkt epoch judged that we do not
 128                                          * get out of jail early */
 129 /* For calculating a rate */
 130 #define BBR_CALC_BW     1
 131 #define BBR_CALC_LOSS   2
 132
 133 #define BBR_RTT_BY_TIMESTAMP    0
 134 #define BBR_RTT_BY_EXACTMATCH   1
 135 #define BBR_RTT_BY_EARLIER_RET  2
 136 #define BBR_RTT_BY_THIS_RETRAN  3
 137 #define BBR_RTT_BY_SOME_RETRAN  4
 138 #define BBR_RTT_BY_TSMATCHING   5
 139
 140 /* Markers to track where we enter persists from */
 141 #define BBR_PERSISTS_FROM_1     1
 142 #define BBR_PERSISTS_FROM_2     2
 143 #define BBR_PERSISTS_FROM_3     3
 144 #define BBR_PERSISTS_FROM_4     4
 145 #define BBR_PERSISTS_FROM_5     5
 146
 147 /* magic cookies to ask for the RTT */
 148 #define BBR_RTT_PROP    0
 149 #define BBR_RTT_RACK    1
 150 #define BBR_RTT_PKTRTT  2
 151 #define BBR_SRTT        3
 152
 153 #define BBR_SACKED 0
 154 #define BBR_CUM_ACKED  1
 155
 156 /* threshold in useconds where we consider we need a higher min cwnd */
 157 #define BBR_HIGH_SPEED 1000
 158 #define BBR_HIGHSPEED_NUM_MSS 12
 159
 160 #define MAX_REDUCE_RXT 3        /* What is the maximum times we are willing to
 161                                  * reduce b/w in RTX's. Setting this has a
 162                                  * multiplicative effect e.g. if we are
 163                                  * reducing by 20% then setting it to 3 means
 164                                  * you will have reduced the b/w estimate by >
 165                                  * 60% before you stop. */
 166 /*
 167  * We use the rate sample structure to
 168  * assist in single sack/ack rate and rtt
 169  * calculation. In the future we will expand
 170  * this in BBR to do forward rate sample
 171  * b/w estimation.
 172  */
 173 #define BBR_RS_RTT_EMPTY 0x00000001     /* Nothing yet stored in RTT's */
 174 #define BBR_RS_BW_EMPTY  0x00000002     /* Nothing yet stored in cDR */
 175 #define BBR_RS_RTT_VALID 0x00000004     /* We have at least one valid RTT */
 176 #define BBR_RS_BW_VAILD  0x00000008     /* We have a valid cDR */
 177 #define BBR_RS_EMPTY   (BBR_RS_RTT_EMPTY|BBR_RS_BW_EMPTY)
 178 struct bbr_rtt_sample {
 179         uint32_t rs_flags;
 180         uint32_t rs_rtt_lowest;
 181         uint32_t rs_rtt_lowest_sendtime;
 182         uint32_t rs_rtt_low_seq_start;
 183
 184         uint32_t rs_rtt_highest;
 185         uint32_t rs_rtt_cnt;
 186
 187         uint64_t rs_rtt_tot;
 188         uint32_t cur_rtt;
 189         uint32_t cur_rtt_bytecnt;
 190
 191         uint32_t cur_rtt_rsmcnt;
 192         uint32_t rc_crtt_set:1,
 193                 avail_bits:31;
 194         uint64_t rs_cDR;
 195 };
 196
 197 /* RTT shrink reasons */
 198 #define BBR_RTTS_INIT     0
 199 #define BBR_RTTS_NEWRTT   1
 200 #define BBR_RTTS_RTTPROBE 2
 201 #define BBR_RTTS_WASIDLE  3
 202 #define BBR_RTTS_PERSIST  4
 203 #define BBR_RTTS_REACHTAR 5
 204 #define BBR_RTTS_ENTERPROBE 6
 205 #define BBR_RTTS_SHRINK_PG 7
 206 #define BBR_RTTS_SHRINK_PG_FINAL 8
 207 #define BBR_RTTS_NEW_TARGET 9
 208 #define BBR_RTTS_LEAVE_DRAIN 10
 209 #define BBR_RTTS_RESETS_VALUES 11
 210
 211 #define BBR_NUM_RATES 5
 212 /* Rate flags */
 213 #define BBR_RT_FLAG_FREE       0x00     /* Is on the free list */
 214 #define BBR_RT_FLAG_INUSE      0x01     /* Has been allocated */
 215 #define BBR_RT_FLAG_READY      0x02     /* Ready to initiate a measurement. */
 216 #define BBR_RT_FLAG_CAPPED_PRE 0x04     /* Ready to cap if we send the next segment */
 217 #define BBR_RT_FLAG_CAPPED     0x08     /* Measurement is capped */
 218 #define BBR_RT_FLAG_PASTFA     0x10     /* Past the first ack. */
 219 #define BBR_RT_FLAG_LIMITED    0x20     /* Saw application/cwnd or rwnd limited period */
 220 #define BBR_RT_SEEN_A_ACK      0x40     /* A ack has been saved */
 221 #define BBR_RT_PREV_RTT_SET    0x80     /* There was a RTT set in */
 222 #define BBR_RT_PREV_SEND_TIME  0x100    /*
 223                                          *There was a RTT send time set that can be used
 224                                          * no snd_limits
 225                                          */
 226 #define BBR_RT_SET_GRADIENT    0x200
 227 #define BBR_RT_TS_VALID        0x400
 228
 229
 230 struct bbr_log {
 231         union {
 232                 struct bbr_sendmap *rsm;        /* For alloc/free */
 233                 uint64_t sb_acc;        /* For out/ack or t-o */
 234         };
 235         struct tcpcb *tp;
 236         uint32_t t_flags;
 237         uint32_t th_seq;
 238         uint32_t th_ack;
 239         uint32_t snd_una;
 240         uint32_t snd_nxt;
 241         uint32_t snd_max;
 242         uint32_t snd_cwnd;
 243         uint32_t snd_wnd;
 244         uint32_t rc_lost;
 245         uint32_t target_cwnd;   /* UU */
 246         uint32_t inflight;      /* UU */
 247         uint32_t applimited;    /* UU */
 248         /* Things for BBR */
 249         uint32_t delivered;     /* UU */
 250         uint64_t cur_del_rate;  /* UU */
 251         uint64_t delRate;       /* UU */
 252         uint64_t rttProp;       /* UU */
 253         uint64_t lt_bw;         /* UU */
 254         uint32_t timeStamp;
 255         uint32_t time;
 256         uint32_t slot;          /* UU */
 257         uint32_t delayed_by;
 258         uint32_t exp_del;
 259         uint32_t pkts_out;
 260         uint32_t new_win;
 261         uint32_t hptsi_gain;    /* UU */
 262         uint32_t cwnd_gain;     /* UU */
 263         uint32_t epoch;         /* UU */
 264         uint32_t lt_epoch;      /* UU */
 265         /* Sack fun */
 266         uint32_t blk_start[4];  /* xx */
 267         uint32_t blk_end[4];
 268         uint32_t len;           /* Timeout T3=1, TLP=2, RACK=3 */
 269         uint8_t type;
 270         uint8_t n_sackblks;
 271         uint8_t applied;        /* UU */
 272         uint8_t inhpts;         /* UU */
 273         uint8_t ininput;        /* UU */
 274         uint8_t use_lt_bw;      /* UU */
 275 };
 276
 277 struct bbr_log_sysctl_out {
 278         uint32_t bbr_log_at;
 279         uint32_t bbr_log_max;
 280         struct bbr_log entries[0];
 281 };
 282
 283 /*
 284  * Magic numbers for logging timeout events if the
 285  * logging is enabled.
 286  */
 287 #define BBR_TO_FRM_TMR  1
 288 #define BBR_TO_FRM_TLP  2
 289 #define BBR_TO_FRM_RACK 3
 290 #define BBR_TO_FRM_KEEP 4
 291 #define BBR_TO_FRM_PERSIST 5
 292 #define BBR_TO_FRM_DELACK 6
 293
 294 #define BBR_SEES_STRETCH_ACK 1
 295 #define BBR_SEES_COMPRESSED_ACKS 2
 296
 297
 298 /*
 299  * As we get each SACK we wade through the
 300  * rc_map and mark off what is acked.
 301  * We also increment rc_sacked as well.
 302  *
 303  * We also pay attention to missing entries
 304  * based on the time and possibly mark them
 305  * for retransmit. If we do and we are not already
 306  * in recovery we enter recovery. In doing
 307  * so we claer prr_delivered/holes_rxt and prr_sent_dur_rec.
 308  * We also setup rc_next/rc_snd_nxt/rc_send_end so
 309  * we will know where to send from. When not in
 310  * recovery rc_next will be NULL and rc_snd_nxt should
 311  * equal snd_max.
 312  *
 313  * Whenever we retransmit from recovery we increment
 314  * rc_holes_rxt as we retran a block and mark it as retransmitted
 315  * with the time it was sent. During non-recovery sending we
 316  * add to our map and note the time down of any send expanding
 317  * the rc_map at the tail and moving rc_snd_nxt up with snd_max.
 318  *
 319  * In recovery during SACK/ACK processing if a chunk has
 320  * been retransmitted and it is now acked, we decrement rc_holes_rxt.
 321  * When we retransmit from the scoreboard we use
 322  * rc_next and rc_snd_nxt/rc_send_end to help us
 323  * find what needs to be retran.
 324  *
 325  * To calculate pipe we simply take (snd_max - snd_una) + rc_holes_rxt
 326  * This gets us the effect of RFC6675 pipe, counting twice for
 327  * bytes retransmitted.
 328  */
 329
 330 #define TT_BBR_FR_TMR   0x2001
 331
 332 #define BBR_SCALE 8
 333 #define BBR_UNIT (1 << BBR_SCALE)
 334
 335 #define BBR_NUM_RTTS_FOR_DEL_LIMIT 8    /* How many pkt-rtts do we keep
 336                                          * Delivery rate for */
 337 #define BBR_NUM_RTTS_FOR_GOOG_DEL_LIMIT 10      /* How many pkt-rtts do we keep
 338                                                  * Delivery rate for google */
 339
 340 #define BBR_SECONDS_NO_RTT 10   /* 10 seconds with no RTT shrinkage */
 341 #define BBR_PROBERTT_MAX 200    /* 200ms */
 342 #define BBR_PROBERTT_NUM_MSS 4
 343 #define BBR_STARTUP_EPOCHS 3
 344 #define USECS_IN_MSEC 1000
 345 #define BBR_TIME_TO_SECONDS(a) (a / USECS_IN_SECOND)
 346 #define BBR_TIME_TO_MILLI(a) (a / MS_IN_USEC)
 347
 348
 349 /* BBR keeps time in usec's so we divide by 1000 and round up */
 350 #define BBR_TS_TO_MS(t)  ((t+999)/MS_IN_USEC)
 351
 352 /*
 353  * Locking for the rack control block.
 354  * a) Locked by INP_WLOCK
 355  * b) Locked by the hpts-mutex
 356  *
 357  */
 358 #define BBR_STATE_STARTUP   0x01
 359 #define BBR_STATE_DRAIN     0x02
 360 #define BBR_STATE_PROBE_BW  0x03
 361 #define BBR_STATE_PROBE_RTT 0x04
 362 #define BBR_STATE_IDLE_EXIT 0x05
 363
 364 /* Substate defines for STATE == PROBE_BW */
 365 #define BBR_SUB_GAIN  0         /* State 0 where we are 5/4 BBR_UNIT */
 366 #define BBR_SUB_DRAIN 1         /* State 1 where we are at 3/4 BBR_UNIT */
 367 #define BBR_SUB_LEVEL1 2        /* State 1 first BBR_UNIT */
 368 #define BBR_SUB_LEVEL2 3        /* State 2nd BBR_UNIT */
 369 #define BBR_SUB_LEVEL3 4        /* State 3rd BBR_UNIT */
 370 #define BBR_SUB_LEVEL4 5        /* State 4th BBR_UNIT */
 371 #define BBR_SUB_LEVEL5 6        /* State 5th BBR_UNIT */
 372 #define BBR_SUB_LEVEL6 7        /* State last BBR_UNIT */
 373 #define BBR_SUBSTATE_COUNT 8
 374
 375 /* Single remaining reduce log */
 376 #define BBR_REDUCE_AT_FR 5
 377
 378 #define BBR_BIG_LOG_SIZE 300000
 379
 380 struct bbr_stats {
 381         uint64_t bbr_badfr;             /* 0 */
 382         uint64_t bbr_badfr_bytes;       /* 1 */
 383         uint64_t bbr_saw_oerr;          /* 2 */
 384         uint64_t bbr_saw_emsgsiz;       /* 3 */
 385         uint64_t bbr_reorder_seen;      /* 4 */
 386         uint64_t bbr_tlp_tot;           /* 5 */
 387         uint64_t bbr_tlp_newdata;       /* 6 */
 388         uint64_t bbr_offset_recovery;   /* 7 */
 389         uint64_t bbr_tlp_retran_fail;   /* 8 */
 390         uint64_t bbr_to_tot;            /* 9 */
 391         uint64_t bbr_to_arm_rack;       /* 10 */
 392         uint64_t bbr_enter_probertt;    /* 11 */
 393         uint64_t bbr_tlp_set;           /* 12 */
 394         uint64_t bbr_resends_set;       /* 13 */
 395         uint64_t bbr_force_output;      /* 14 */
 396         uint64_t bbr_to_arm_tlp;        /* 15 */
 397         uint64_t bbr_paced_segments;    /* 16 */
 398         uint64_t bbr_saw_enobuf;        /* 17 */
 399         uint64_t bbr_to_alloc_failed;   /* 18 */
 400         uint64_t bbr_to_alloc_emerg;    /* 19 */
 401         uint64_t bbr_sack_proc_all;     /* 20 */
 402         uint64_t bbr_sack_proc_short;   /* 21 */
 403         uint64_t bbr_sack_proc_restart; /* 22 */
 404         uint64_t bbr_to_alloc;          /* 23 */
 405         uint64_t bbr_offset_drop;       /* 24 */
 406         uint64_t bbr_runt_sacks;        /* 25 */
 407         uint64_t bbr_sack_passed;       /* 26 */
 408         uint64_t bbr_rlock_left_ret0;   /* 27 */
 409         uint64_t bbr_rlock_left_ret1;   /* 28 */
 410         uint64_t bbr_dynamic_rwnd;      /* 29 */
 411         uint64_t bbr_static_rwnd;       /* 30 */
 412         uint64_t bbr_sack_blocks;       /* 31 */
 413         uint64_t bbr_sack_blocks_skip;  /* 32 */
 414         uint64_t bbr_sack_search_both;  /* 33 */
 415         uint64_t bbr_sack_search_fwd;   /* 34 */
 416         uint64_t bbr_sack_search_back;  /* 35 */
 417         uint64_t bbr_plain_acks;        /* 36 */
 418         uint64_t bbr_acks_with_sacks;   /* 37 */
 419         uint64_t bbr_progress_drops;    /* 38 */
 420         uint64_t bbr_early;             /* 39 */
 421         uint64_t bbr_reneges_seen;      /* 40 */
 422         uint64_t bbr_persist_reneg;     /* 41 */
 423         uint64_t bbr_dropped_af_data;   /* 42 */
 424         uint64_t bbr_failed_mbuf_aloc;  /* 43 */
 425         uint64_t bbr_cwnd_limited;      /* 44 */
 426         uint64_t bbr_rwnd_limited;      /* 45 */
 427         uint64_t bbr_app_limited;       /* 46 */
 428         uint64_t bbr_force_timer_start; /* 47 */
 429         uint64_t bbr_hpts_min_time;     /* 48 */
 430         uint64_t bbr_meets_tso_thresh;  /* 49 */
 431         uint64_t bbr_miss_tso_rwnd;     /* 50 */
 432         uint64_t bbr_miss_tso_cwnd;     /* 51 */
 433         uint64_t bbr_miss_tso_app;      /* 52 */
 434         uint64_t bbr_miss_retran;       /* 53 */
 435         uint64_t bbr_miss_tlp;          /* 54 */
 436         uint64_t bbr_miss_unknown;      /* 55 */
 437         uint64_t bbr_hdwr_rl_add_ok;    /* 56 */
 438         uint64_t bbr_hdwr_rl_add_fail;  /* 57 */
 439         uint64_t bbr_hdwr_rl_mod_ok;    /* 58 */
 440         uint64_t bbr_hdwr_rl_mod_fail;  /* 59 */
 441         uint64_t bbr_collapsed_win;     /* 60 */
 442         uint64_t bbr_alloc_limited;     /* 61 */
 443         uint64_t bbr_alloc_limited_conns; /* 62 */
 444         uint64_t bbr_split_limited;     /* 63 */
 445 };
 446
 447 /*
 448  * The structure bbr_opt_stats is a simple
 449  * way to see how many options are being
 450  * changed in the stack.
 451  */
 452 struct bbr_opts_stats {
 453         uint64_t tcp_bbr_pace_per_sec;
 454         uint64_t tcp_bbr_pace_del_tar;
 455         uint64_t tcp_bbr_pace_seg_max;
 456         uint64_t tcp_bbr_pace_seg_min;
 457         uint64_t tcp_bbr_pace_cross;
 458         uint64_t tcp_bbr_drain_inc_extra;
 459         uint64_t tcp_bbr_unlimited;
 460         uint64_t tcp_bbr_iwintso;
 461         uint64_t tcp_bbr_rec_over_hpts;
 462         uint64_t tcp_bbr_recforce;
 463         uint64_t tcp_bbr_startup_pg;
 464         uint64_t tcp_bbr_drain_pg;
 465         uint64_t tcp_bbr_rwnd_is_app;
 466         uint64_t tcp_bbr_probe_rtt_int;
 467         uint64_t tcp_bbr_one_retran;
 468         uint64_t tcp_bbr_startup_loss_exit;
 469         uint64_t tcp_bbr_use_lowgain;
 470         uint64_t tcp_bbr_lowgain_thresh;
 471         uint64_t tcp_bbr_lowgain_half;
 472         uint64_t tcp_bbr_lowgain_fd;
 473         uint64_t tcp_bbr_usedel_rate;
 474         uint64_t tcp_bbr_min_rto;
 475         uint64_t tcp_bbr_max_rto;
 476         uint64_t tcp_rack_pace_max_seg;
 477         uint64_t tcp_rack_min_to;
 478         uint64_t tcp_rack_reord_thresh;
 479         uint64_t tcp_rack_reord_fade;
 480         uint64_t tcp_rack_tlp_thresh;
 481         uint64_t tcp_rack_pkt_delay;
 482         uint64_t tcp_bbr_startup_exit_epoch;
 483         uint64_t tcp_bbr_ack_comp_alg;
 484         uint64_t tcp_rack_cheat;
 485         uint64_t tcp_iwnd_tso;
 486         uint64_t tcp_utter_max_tso;
 487         uint64_t tcp_hdwr_pacing;
 488         uint64_t tcp_extra_state;
 489         uint64_t tcp_floor_min_tso;
 490         /* New */
 491         uint64_t tcp_bbr_algorithm;
 492         uint64_t tcp_bbr_tslimits;
 493         uint64_t tcp_bbr_probertt_len;
 494         uint64_t tcp_bbr_probertt_gain;
 495         uint64_t tcp_bbr_topaceout;
 496         uint64_t tcp_use_rackcheat;
 497         uint64_t tcp_delack;
 498         uint64_t tcp_maxpeak;
 499         uint64_t tcp_retran_wtso;
 500         uint64_t tcp_data_ac;
 501         uint64_t tcp_ts_raises;
 502         uint64_t tcp_pacing_oh_tmr;
 503         uint64_t tcp_pacing_oh;
 504         uint64_t tcp_policer_det;
 505 };
 506
 507
 508 #ifdef _KERNEL
 509 #define BBR_STAT_SIZE (sizeof(struct bbr_stats)/sizeof(uint64_t))
 510 extern counter_u64_t bbr_stat_arry[BBR_STAT_SIZE];
 511 #define BBR_STAT_ADD(name, amm) counter_u64_add(bbr_stat_arry[(offsetof(struct bbr_stats, name)/sizeof(uint64_t))], (amm))
 512 #define BBR_STAT_INC(name) BBR_STAT_ADD(name, 1)
 513 #define BBR_OPTS_SIZE (sizeof(struct bbr_stats)/sizeof(uint64_t))
 514 extern counter_u64_t bbr_opts_arry[BBR_OPTS_SIZE];
 515 #define BBR_OPTS_ADD(name, amm) counter_u64_add(bbr_opts_arry[(offsetof(struct bbr_opts_stats, name)/sizeof(uint64_t))], (amm))
 516 #define BBR_OPTS_INC(name) BBR_OPTS_ADD(name, 1)
 517 #endif
 518
 519 #define BBR_NUM_LOSS_RATES 3
 520 #define BBR_NUM_BW_RATES 3
 521
 522 #define BBR_RECOVERY_LOWRTT 1
 523 #define BBR_RECOVERY_MEDRTT 2
 524 #define BBR_RECOVERY_HIGHRTT 3
 525 #define BBR_RECOVERY_EXTREMERTT 4
 526
 527
 528 struct bbr_control {
 529         /*******************************/
 530         /* Cache line 2 from bbr start */
 531         /*******************************/
 532         struct bbr_head rc_map; /* List of all segments Lock(a) */
 533         struct bbr_head rc_tmap;        /* List in transmit order Lock(a) */
 534         struct bbr_sendmap *rc_resend;  /* something we have been asked to
 535                                          * resend */
 536         uint32_t rc_last_delay_val;     /* How much we expect to delay Lock(a) */
 537         uint32_t rc_bbr_hptsi_gain:16,  /* Current hptsi gain Lock(a) */
 538                  rc_hpts_flags:16;      /* flags on whats on the pacer wheel */
 539
 540         uint32_t rc_delivered;  /* BRR delivered amount Lock(a) */
 541         uint32_t rc_hptsi_agg_delay;    /* How much time are we behind */
 542
 543         uint32_t rc_flight_at_input;
 544         uint32_t rc_lost_bytes;         /* Total bytes currently marked lost */
 545         /*******************************/
 546         /* Cache line 3 from bbr start */
 547         /*******************************/
 548         struct time_filter rc_delrate;
 549         /*******************************/
 550         /* Cache line 4 from bbr start */
 551         /*******************************/
 552         struct bbr_head rc_free;        /* List of Free map entries Lock(a) */
 553         struct bbr_sendmap *rc_tlp_send;        /* something we have been
 554                                                  * asked to resend */
 555         uint32_t rc_del_time;
 556         uint32_t rc_target_at_state;    /* Target for a state */
 557
 558         uint16_t rc_free_cnt;   /* Number of free entries on the rc_free list
 559                                  * Lock(a) */
 560         uint16_t rc_startup_pg;
 561
 562         uint32_t cur_rtt;       /* Last RTT from ack */
 563
 564
 565         uint32_t rc_went_idle_time;     /* Used for persits to see if its
 566                                          * probe-rtt qualified */
 567         uint32_t rc_pace_max_segs:17,   /* How much in any single TSO we send Lock(a) */
 568                  rc_pace_min_segs:15;   /* The minimum single segment size before we enter persists */
 569
 570         uint32_t rc_rtt_shrinks;        /* Time of last rtt shrinkage Lock(a) */
 571         uint32_t r_app_limited_until;
 572         uint32_t rc_timer_exp;  /* If a timer ticks of expiry */
 573         uint32_t rc_rcv_epoch_start;    /* Start time of the Epoch Lock(a) */
 574
 575         /*******************************/
 576         /* Cache line 5 from bbr start */
 577         /*******************************/
 578
 579         uint32_t rc_lost_at_pktepoch;   /* what the lost value was at the last
 580                                          * pkt-epoch */
 581         uint32_t r_measurement_count;   /* count of measurement applied lock(a) */
 582
 583
 584         uint32_t rc_last_tlp_seq;       /* Last tlp sequence Lock(a) */
 585         uint16_t rc_reorder_shift;      /* Socket option value Lock(a) */
 586         uint16_t rc_pkt_delay;  /* Socket option value Lock(a) */
 587
 588         struct bbr_sendmap *rc_sacklast;        /* sack remembered place
 589                                                  * Lock(a) */
 590         struct bbr_sendmap *rc_next;    /* remembered place where we next
 591                                          * retransmit at Lock(a) */
 592
 593         uint32_t rc_sacked;     /* Tot sacked on scoreboard Lock(a) */
 594         uint32_t rc_holes_rxt;  /* Tot retraned from scoreboard Lock(a) */
 595
 596         uint32_t rc_reorder_ts; /* Last time we saw reordering Lock(a) */
 597         uint32_t rc_init_rwnd;  /* Initial rwnd when we transitioned */
 598                                 /*- ---
 599                                  * used only initial and close
 600                                  */
 601         uint32_t rc_high_rwnd;  /* Highest rwnd seen */
 602         uint32_t rc_lowest_rtt; /* Smallest RTT we have seen */
 603
 604         uint32_t rc_last_rtt;   /* Last valid measured RTT that ack'd data */
 605         uint32_t bbr_cross_over;
 606
 607         /*******************************/
 608         /* Cache line 6 from bbr start */
 609         /*******************************/
 610         struct sack_filter bbr_sf;
 611
 612         /*******************************/
 613         /* Cache line 7 from bbr start */
 614         /*******************************/
 615         struct time_filter_small rc_rttprop;
 616         uint32_t last_inbound_ts;       /* Peers last timestamp */
 617
 618         uint32_t rc_inc_tcp_oh: 1,
 619                  rc_inc_ip_oh: 1,
 620                  rc_inc_enet_oh:1,
 621                  rc_incr_tmrs:1,
 622                  restrict_growth:28;
 623         uint32_t rc_lt_epoch_use;       /* When we started lt-bw use Lock(a) */
 624
 625         uint32_t rc_recovery_start;     /* Time we start recovery Lock(a) */
 626         uint32_t rc_lt_del;     /* Delivered at lt bw sampling start Lock(a) */
 627
 628         uint64_t rc_bbr_cur_del_rate;   /* Current measured delivery rate
 629                                          * Lock(a) */
 630
 631         /*******************************/
 632         /* Cache line 8 from bbr start */
 633         /*******************************/
 634         uint32_t rc_cwnd_on_ent;        /* On entry to recovery the cwnd
 635                                          * Lock(a) */
 636         uint32_t rc_agg_early;  /* aggregate amount early */
 637
 638         uint32_t rc_rcvtime;    /* When we last received data Lock(a) */
 639         uint32_t rc_pkt_epoch_del;      /* seq num that we need for RTT epoch */
 640
 641         uint32_t rc_pkt_epoch;  /* Epoch based on packet RTTs */
 642         uint32_t rc_pkt_epoch_time;     /* Time we started the pkt epoch */
 643
 644         uint32_t rc_pkt_epoch_rtt;      /* RTT using the packet epoch */
 645         uint32_t rc_rtt_epoch;  /* Current RTT epoch, it ticks every rttProp
 646                                  * Lock(a) */
 647         uint32_t lowest_rtt;
 648         uint32_t bbr_smallest_srtt_this_state;
 649
 650         uint32_t rc_lt_epoch;   /* LT epoch start of bw_sampling */
 651         uint32_t rc_lost_at_startup;
 652
 653         uint32_t rc_bbr_state_atflight;
 654         uint32_t rc_bbr_last_startup_epoch;     /* Last startup epoch where we
 655                                                  * increased 20% */
 656         uint32_t rc_bbr_enters_probertt;        /* Timestamp we entered
 657                                                  * probertt Lock(a) */
 658         uint32_t rc_lt_time;    /* Time of lt sampling start Lock(a) */
 659
 660         /*******************************/
 661         /* Cache line 9 from bbr start */
 662         /*******************************/
 663         uint64_t rc_lt_bw;      /* LT bw calculated Lock(a) */
 664         uint64_t rc_bbr_lastbtlbw;      /* For startup, what was last btlbw I
 665                                          * saw to check the 20% gain Lock(a) */
 666
 667
 668         uint32_t rc_bbr_cwnd_gain;      /* Current cwnd gain Lock(a) */
 669         uint32_t rc_pkt_epoch_loss_rate;        /* pkt-epoch loss rate */
 670
 671         uint32_t rc_saved_cwnd; /* Saved cwnd during Probe-rtt drain Lock(a) */
 672         uint32_t substate_pe;
 673
 674         uint32_t rc_lost;       /* Number of bytes lost Lock(a) */
 675         uint32_t rc_exta_time_gd; /* How much extra time we got in d/g */
 676
 677         uint32_t rc_lt_lost;    /* Number of lt bytes lost at sampling start
 678                                  * Lock(a) */
 679         uint32_t rc_bbr_state_time;
 680
 681         uint32_t rc_min_to;     /* Socket option value Lock(a) */
 682         uint32_t rc_initial_hptsi_bw;   /* Our initial startup bw Lock(a) */
 683
 684         uint32_t bbr_lost_at_state;     /* Temp counter debug lost value as we
 685                                          * enter a state */
 686         /*******************************/
 687         /* Cache line 10 from bbr start */
 688         /*******************************/
 689         uint32_t rc_level_state_extra;
 690         uint32_t rc_red_cwnd_pe;
 691         const struct tcp_hwrate_limit_table *crte;
 692         uint64_t red_bw;
 693
 694         uint32_t rc_probertt_int;
 695         uint32_t rc_probertt_srttchktim;        /* Time we last did a srtt
 696                                                  * check  */
 697         uint32_t gain_epoch;    /* Epoch we should be out of gain */
 698         uint32_t rc_min_rto_ms;
 699
 700         uint32_t rc_reorder_fade;       /* Socket option value Lock(a) */
 701         uint32_t last_startup_measure;
 702
 703         int32_t bbr_hptsi_per_second;
 704         int32_t bbr_hptsi_segments_delay_tar;
 705
 706         int32_t bbr_hptsi_segments_max;
 707         uint32_t bbr_rttprobe_gain_val;
 708         /*******************************/
 709         /* Cache line 11 from bbr start */
 710         /*******************************/
 711         uint32_t cur_rtt_send_time;     /* Time we sent our rtt measured packet */
 712         uint32_t bbr_peer_tsratio;      /* Our calculated ts ratio to multply */
 713         uint32_t bbr_ts_check_tstmp;    /* When we filled it the TS that came on the ack */
 714         uint32_t bbr_ts_check_our_cts;  /* When we filled it the cts of the send */
 715         uint32_t rc_tlp_rxt_last_time;
 716         uint32_t bbr_smallest_srtt_state2;
 717         uint32_t bbr_hdwr_cnt_noset_snt;        /* count of hw pacing sends during delay */
 718         uint32_t startup_last_srtt;
 719         uint32_t rc_ack_hdwr_delay;
 720         uint32_t highest_hdwr_delay;            /* Largest delay we have seen from hardware */
 721         uint32_t non_gain_extra;
 722         uint32_t recovery_lr;                   /* The sum of the loss rate from the pe's during recovery */
 723         uint32_t last_in_probertt;
 724         uint32_t flightsize_at_drain;           /* In draining what was the last marked flight size */
 725         uint32_t rc_pe_of_prtt;                 /* PE we went into probe-rtt */
 726         uint32_t ts_in;                         /* ts that went with the last rtt */
 727
 728         uint16_t rc_tlp_seg_send_cnt;   /* Number of times we have TLP sent
 729                                          * rc_last_tlp_seq Lock(a) */
 730         uint16_t rc_drain_pg;
 731         uint32_t rc_num_maps_alloced;           /* num send map entries allocated */
 732         uint32_t rc_num_split_allocs;           /* num split map entries allocated */
 733         uint16_t rc_num_small_maps_alloced;     /* Number of sack blocks
 734                                                  * allocated */
 735         uint16_t bbr_hptsi_bytes_min;
 736
 737         uint16_t bbr_hptsi_segments_floor;
 738         uint16_t bbr_utter_max;
 739         uint16_t bbr_google_discount;
 740
 741 };
 742
 743
 744 struct socket;
 745 struct tcp_bbr {
 746         /* First cache line 0x00 */
 747         int32_t(*r_substate) (struct mbuf *, struct tcphdr *,
 748             struct socket *, struct tcpcb *, struct tcpopt *,
 749             int32_t, int32_t, uint32_t, int32_t, int32_t, uint8_t);     /* Lock(a) */
 750         struct tcpcb *rc_tp;    /* The tcpcb Lock(a) */
 751         struct inpcb *rc_inp;   /* The inpcb Lock(a) */
 752         struct timeval rc_tv;
 753         uint32_t rc_pacer_started;  /* Time we started the pacer */
 754         uint16_t no_pacing_until:8, /* No pacing until N packet epochs */
 755                  ts_can_raise:1,/* TS b/w calculations can raise the bw higher */
 756                  skip_gain:1,   /* Skip the gain cycle (hardware pacing) */
 757                  gain_is_limited:1,     /* With hardware pacing we are limiting gain */
 758                  output_error_seen:1,
 759                  oerror_cnt:4,
 760                 hw_pacing_set:1;        /* long enough has passed for us to start pacing */
 761         uint16_t xxx_r_ack_count;       /* During recovery count of ack's received
 762                                  * that added data since output */
 763         uint16_t bbr_segs_rcvd; /* In Segment count since we sent a ack */
 764
 765         uint8_t bbr_timer_src:4,        /* Used for debugging Lock(a) */
 766                 bbr_use_rack_cheat:1,   /* Use the rack cheat */
 767                 bbr_init_win_cheat:1,   /* Send full IW for TSO */
 768                 bbr_attempt_hdwr_pace:1,/* Try to do hardware pacing */
 769                 bbr_hdrw_pacing:1;      /* Hardware pacing is available */
 770         uint8_t bbr_hdw_pace_ena:1,     /* Does the connection allow hardware pacing to be attempted */
 771                 bbr_prev_in_rec:1,      /* We were previously in recovery */
 772                 pkt_conservation:1,
 773                 use_policer_detection:1,
 774                 xxx_bbr_hdw_pace_idx:4; /* If hardware pacing is on, index to slot in pace tbl */
 775         uint16_t r_wanted_output:1,
 776                  rtt_valid:1,
 777                  rc_timer_first:1,
 778                  rc_output_starts_timer:1,
 779                  rc_resends_use_tso:1,
 780                  rc_all_timers_stopped:1,
 781                  rc_loss_exit:1,
 782                  rc_ack_was_delayed:1,
 783                  rc_lt_is_sampling:1,
 784                  rc_filled_pipe:1,
 785                  rc_tlp_new_data:1,
 786                  rc_hit_state_1:1,
 787                  rc_ts_valid:1,
 788                  rc_prtt_set_ts:1,
 789                  rc_is_pkt_epoch_now:1,
 790                  rc_has_collapsed:1;
 791
 792         uint8_t r_state:4,      /* Current bbr state Lock(a) */
 793                 r_agg_early_set:1,      /* Did we get called early */
 794                 r_init_rtt:1,
 795                 r_use_policer:1,        /* For google mode only */
 796                 r_recovery_bw:1;
 797         uint8_t r_timer_override:1,     /* pacer override Lock(a)  0/1 */
 798                 rc_in_persist:1,
 799                 rc_lt_use_bw:1,
 800                 rc_allow_data_af_clo:1,
 801                 rc_tlp_rtx_out:1,       /* A TLP is in flight  */
 802                 rc_tlp_in_progress:1,   /* a TLP timer is running needed? */
 803                 rc_use_idle_restart:1;   /* Do we restart fast after idle (persist or applim) */
 804         uint8_t rc_bbr_state:3, /* What is the major BBR state */
 805                 rc_bbr_substate:3,      /* For probeBW state */
 806                 r_is_v6:1,
 807                 rc_past_init_win:1;
 808         uint8_t rc_last_options;
 809         uint8_t rc_tlp_threshold;       /* Socket option value Lock(a) */
 810         uint8_t rc_max_rto_sec;
 811         uint8_t rc_cwnd_limited:1,      /* We are cwnd limited */
 812                 rc_tmr_stopped:7;       /* What timers have been stopped  */
 813         uint8_t rc_use_google:1,
 814                 rc_use_ts_limit:1,
 815                 rc_ts_data_set:1,       /* We have filled a set point to determine */
 816                 rc_ts_clock_set:1,      /* We have determined the ts type */
 817                 rc_ts_cant_be_used:1,   /* We determined we can't use ts values */
 818                 rc_ack_is_cumack:1,
 819                 rc_no_pacing:1,
 820                 alloc_limit_reported:1;
 821         uint8_t rc_init_win;
 822         /* Cache line 2 0x40 */
 823         struct bbr_control r_ctl;
 824 #ifdef _KERNEL
 825 }       __aligned(CACHE_LINE_SIZE);
 826 #else
 827 };
 828 #endif
 829
 830 #endif