sys/netinet/tcp_stacks/tcp_bbr.h

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