Lines Matching defs:cts
445 bbr_set_probebw_gains(struct tcp_bbr *bbr, uint32_t cts, uint32_t losses);
447 bbr_substate_change(struct tcp_bbr *bbr, uint32_t cts, int line,
452 bbr_state_change(struct tcp_bbr *bbr, uint32_t cts, int32_t epoch,
455 bbr_calc_thresh_rack(struct tcp_bbr *bbr, uint32_t srtt, uint32_t cts,
461 struct bbr_sendmap *rsm, uint32_t srtt, uint32_t cts);
463 bbr_exit_persist(struct tcpcb *tp, struct tcp_bbr *bbr, uint32_t cts,
468 bbr_enter_probe_rtt(struct tcp_bbr *bbr, uint32_t cts, int32_t line);
473 tcp_bbr_tso_size_check(struct tcp_bbr *bbr, uint32_t cts);
475 bbr_setup_red_bw(struct tcp_bbr *bbr, uint32_t cts);
477 bbr_log_rtt_shrinks(struct tcp_bbr *bbr, uint32_t cts, uint32_t applied,
485 bbr_log_to_start(struct tcp_bbr *bbr, uint32_t cts, uint32_t to, int32_t slot,
488 bbr_log_timer_var(struct tcp_bbr *bbr, int mode, uint32_t cts,
492 bbr_log_hpts_diag(struct tcp_bbr *bbr, uint32_t cts, struct hpts_diag *diag);
495 uint32_t del_by, uint32_t cts, uint32_t sloton,
498 bbr_enter_persist(struct tcpcb *tp, struct tcp_bbr *bbr, uint32_t cts,
503 bbr_exit_probe_rtt(struct tcpcb *tp, struct tcp_bbr *bbr, uint32_t cts);
505 bbr_check_probe_rtt_limits(struct tcp_bbr *bbr, uint32_t cts);
507 bbr_timer_cancel(struct tcp_bbr *bbr, int32_t line, uint32_t cts);
510 uint32_t cts, uint32_t usecs, uint64_t bw,
553 bbr_timer_start(struct tcpcb *tp, struct tcp_bbr *bbr, uint32_t cts)
592 if (TSTMP_GT(tstmp_touse, cts))
593 time_since_sent = cts - tstmp_touse;
610 bbr_log_timer_var(bbr, 2, cts, 0, bbr_get_rtt(bbr, BBR_SRTT), 0, to);
634 thresh = bbr_calc_thresh_rack(bbr, srtt, cts, rsm);
637 if (SEQ_GEQ(exp, cts)) {
638 to = exp - cts;
669 if (TSTMP_GT(tstmp_touse, cts))
670 time_since_sent = cts - tstmp_touse;
673 thresh = bbr_calc_thresh_tlp(tp, bbr, rsm, srtt, cts);
707 bbr_log_timer_var(bbr, 1, cts, time_since_sent, srtt, thresh, to);
729 bbr_start_hpts_timer(struct tcp_bbr *bbr, struct tcpcb *tp, uint32_t cts, int32_t frm, int32_t slot, uint32_t tot_len)
749 if (stopped && TSTMP_GT(bbr->r_ctl.rc_timer_exp, cts)) {
750 left = bbr->r_ctl.rc_timer_exp - cts;
763 if (TSTMP_GT(cts, bbr->rc_pacer_started)) {
765 delay_calc = cts - bbr->rc_pacer_started;
772 bbr_log_pacing_delay_calc(bbr, 0, bbr->r_ctl.rc_agg_early, cts, slot, 0, bbr->r_agg_early_set, 2);
790 hpts_timeout = bbr_timer_start(tp, bbr, cts);
881 bbr->r_ctl.rc_timer_exp = cts + hpts_timeout;
903 bbr->rc_pacer_started = cts;
909 bbr_log_to_start(bbr, cts, hpts_timeout, slot, 1);
910 bbr_log_hpts_diag(bbr, cts, &diag);
925 bbr->rc_pacer_started = cts;
941 bbr_log_to_start(bbr, cts, hpts_timeout, slot, 0);
942 bbr_log_hpts_diag(bbr, cts, &diag);
946 bbr_log_type_bbrsnd(bbr, tot_len, slot, delay_calc, cts, frm, prev_delay);
950 bbr_timer_audit(struct tcpcb *tp, struct tcp_bbr *bbr, uint32_t cts, struct sockbuf *sb)
1045 bbr_timer_cancel(bbr, __LINE__, cts);
1046 bbr_start_hpts_timer(bbr, tp, cts, 1, bbr->r_ctl.rc_last_delay_val,
1057 hpts_timeout = bbr_timer_start(tp, bbr, cts);
1071 bbr->r_ctl.rc_timer_exp = cts + hpts_timeout;
1079 * Considers the two time values now (cts) and earlier.
1080 * If cts is smaller than earlier, we could have
1085 * a case (where cts is behind earlier time by
1090 bbr_calc_time(uint32_t cts, uint32_t earlier_time) {
1092 * Given two timestamps, the current time stamp cts, and some other
1095 * after the cts. If this occurs we need to return 0.
1097 if (TSTMP_GEQ(cts, earlier_time))
1098 return (cts - earlier_time);
1100 * cts is behind earlier_time if its less than 10ms consider it 0.
1105 if (TSTMP_GEQ((cts + 10000), earlier_time))
1111 return (cts - earlier_time);
1849 bbr_fill_in_logging_data(struct tcp_bbr *bbr, struct tcp_log_bbr *l, uint32_t cts)
1860 l->timeStamp = cts;
1916 bbr_log_type_just_return(struct tcp_bbr *bbr, uint32_t cts, uint32_t tlen, uint8_t hpts_calling,
1922 bbr_fill_in_logging_data(bbr, &log.u_bbr, cts);
1960 bbr_log_msgsize_fail(struct tcp_bbr *bbr, struct tcpcb *tp, uint32_t len, uint32_t maxseg, uint32_t mtu, int32_t csum_flags, int32_t tso, uint32_t cts)
1965 bbr_fill_in_logging_data(bbr, &log.u_bbr, cts);
2001 bbr_log_pkt_epoch(struct tcp_bbr *bbr, uint32_t cts, uint32_t line,
2007 bbr_fill_in_logging_data(bbr, &log.u_bbr, cts);
2026 bbr_log_time_epoch(struct tcp_bbr *bbr, uint32_t cts, uint32_t line, uint32_t epoch_time)
2031 bbr_fill_in_logging_data(bbr, &log.u_bbr, cts);
2069 bbr_log_type_statechange(struct tcp_bbr *bbr, uint32_t cts, int32_t line)
2074 bbr_fill_in_logging_data(bbr, &log.u_bbr, cts);
2096 bbr_log_rtt_shrinks(struct tcp_bbr *bbr, uint32_t cts, uint32_t applied,
2102 bbr_fill_in_logging_data(bbr, &log.u_bbr, cts);
2189 bbr_log_type_pesist(struct tcp_bbr *bbr, uint32_t cts, uint32_t time_in, int32_t line, uint8_t enter_exit)
2194 bbr_fill_in_logging_data(bbr, &log.u_bbr, cts);
2206 bbr_log_ack_clear(struct tcp_bbr *bbr, uint32_t cts)
2211 bbr_fill_in_logging_data(bbr, &log.u_bbr, cts);
2227 uint16_t nsegs, uint32_t cts, int32_t nxt_pkt, struct mbuf *m)
2233 bbr_fill_in_logging_data(bbr, &log.u_bbr, cts);
2275 bbr_log_doseg_done(struct tcp_bbr *bbr, uint32_t cts, int32_t nxt_pkt, int32_t did_out)
2280 bbr_fill_in_logging_data(bbr, &log.u_bbr, cts);
2299 bbr_log_enobuf_jmp(struct tcp_bbr *bbr, uint32_t len, uint32_t cts,
2305 bbr_fill_in_logging_data(bbr, &log.u_bbr, cts);
2319 bbr_log_to_processing(struct tcp_bbr *bbr, uint32_t cts, int32_t ret, int32_t timers, uint8_t hpts_calling)
2324 bbr_fill_in_logging_data(bbr, &log.u_bbr, cts);
2329 log.u_bbr.flex5 = cts;
2341 bbr_log_to_event(struct tcp_bbr *bbr, uint32_t cts, int32_t to_num)
2347 bbr_fill_in_logging_data(bbr, &log.u_bbr, cts);
2369 bbr_log_startup_event(struct tcp_bbr *bbr, uint32_t cts, uint32_t flex1, uint32_t flex2, uint32_t flex3, uint8_t reason)
2374 bbr_fill_in_logging_data(bbr, &log.u_bbr, cts);
2392 bbr_log_hpts_diag(struct tcp_bbr *bbr, uint32_t cts, struct hpts_diag *diag)
2397 bbr_fill_in_logging_data(bbr, &log.u_bbr, cts);
2428 bbr_log_timer_var(struct tcp_bbr *bbr, int mode, uint32_t cts, uint32_t time_since_sent, uint32_t srtt,
2434 bbr_fill_in_logging_data(bbr, &log.u_bbr, cts);
2452 uint32_t cts, uint32_t usecs, uint64_t bw, uint32_t override, int mod)
2457 bbr_fill_in_logging_data(bbr, &log.u_bbr, cts);
2478 bbr_log_to_start(struct tcp_bbr *bbr, uint32_t cts, uint32_t to, int32_t slot, uint8_t which)
2483 bbr_fill_in_logging_data(bbr, &log.u_bbr, cts);
2502 bbr_log_thresh_choice(struct tcp_bbr *bbr, uint32_t cts, uint32_t thresh, uint32_t lro, uint32_t srtt, struct bbr_sendmap *rsm, uint8_t frm)
2507 bbr_fill_in_logging_data(bbr, &log.u_bbr, cts);
2525 bbr_log_to_cancel(struct tcp_bbr *bbr, int32_t line, uint32_t cts, uint8_t hpts_removed)
2530 bbr_fill_in_logging_data(bbr, &log.u_bbr, cts);
2570 bbr_log_type_tsosize(struct tcp_bbr *bbr, uint32_t cts, uint32_t tsosz, uint32_t tls, uint32_t old_val, uint32_t maxseg, int hdwr)
2575 bbr_fill_in_logging_data(bbr, &log.u_bbr, cts);
2598 bbr_log_type_rsmclear(struct tcp_bbr *bbr, uint32_t cts, struct bbr_sendmap *rsm,
2604 bbr_fill_in_logging_data(bbr, &log.u_bbr, cts);
2624 bbr_log_type_bbrupd(struct tcp_bbr *bbr, uint8_t flex8, uint32_t cts,
2633 bbr_fill_in_logging_data(bbr, &log.u_bbr, cts);
2657 bbr_log_type_ltbw(struct tcp_bbr *bbr, uint32_t cts, int32_t reason,
2664 bbr_fill_in_logging_data(bbr, &log.u_bbr, cts);
2708 uint64_t rate, uint64_t hw_rate, int line, uint32_t cts,
2715 bbr_fill_in_logging_data(bbr, &log.u_bbr, cts);
2738 bbr_log_type_bbrsnd(struct tcp_bbr *bbr, uint32_t len, uint32_t slot, uint32_t del_by, uint32_t cts, uint32_t line, uint32_t prev_delay)
2743 bbr_fill_in_logging_data(bbr, &log.u_bbr, cts);
2761 bbr_log_type_bbrrttprop(struct tcp_bbr *bbr, uint32_t t, uint32_t end, uint32_t tsconv, uint32_t cts, int32_t match, uint32_t seq, uint8_t flags)
2766 bbr_fill_in_logging_data(bbr, &log.u_bbr, cts);
2784 bbr_log_exit_gain(struct tcp_bbr *bbr, uint32_t cts, int32_t entry_method)
2789 bbr_fill_in_logging_data(bbr, &log.u_bbr, cts);
2843 bbr_set_pktepoch(struct tcp_bbr *bbr, uint32_t cts, int32_t line)
2870 tcp_bbr_tso_size_check(bbr, cts);
2872 bbr->r_ctl.rc_pkt_epoch_rtt = bbr_calc_time(cts, bbr->r_ctl.rc_pkt_epoch_time);
2873 bbr->r_ctl.rc_pkt_epoch_time = cts;
2875 bbr_log_pkt_epoch(bbr, cts, line, lost, del);
2881 bbr_set_epoch(struct tcp_bbr *bbr, uint32_t cts, int32_t line)
2887 epoch_time = cts - bbr->r_ctl.rc_rcv_epoch_start;
2888 bbr_log_time_epoch(bbr, cts, line, epoch_time);
2889 bbr->r_ctl.rc_rcv_epoch_start = cts;
2893 bbr_isit_a_pkt_epoch(struct tcp_bbr *bbr, uint32_t cts, struct bbr_sendmap *rsm, int32_t line, int32_t cum_acked)
3003 bbr_reset_lt_bw_interval(struct tcp_bbr *bbr, uint32_t cts)
3012 bbr_reset_lt_bw_sampling(struct tcp_bbr *bbr, uint32_t cts)
3017 bbr_reset_lt_bw_interval(bbr, cts);
3021 bbr_lt_bw_samp_done(struct tcp_bbr *bbr, uint64_t bw, uint32_t cts, uint32_t timin)
3050 bbr_log_type_ltbw(bbr, cts, 4, (uint32_t)bw, saved_bw, (uint32_t)diff, timin);
3055 bbr_reset_lt_bw_interval(bbr, cts);
3056 bbr_log_type_ltbw(bbr, cts, 5, 0, (uint32_t)bw, 0, timin);
3075 bbr_pick_probebw_substate(struct tcp_bbr *bbr, uint32_t cts)
3095 if ((cts - bbr->r_ctl.rc_rcv_epoch_start) >= bbr_get_rtt(bbr, BBR_RTT_PROP))
3096 bbr_set_epoch(bbr, cts, __LINE__);
3103 bbr_lt_bw_sampling(struct tcp_bbr *bbr, uint32_t cts, int32_t loss_detected)
3116 bbr_reset_lt_bw_sampling(bbr, cts);
3118 bbr_set_epoch(bbr, cts, __LINE__);
3119 bbr->rc_bbr_substate = bbr_pick_probebw_substate(bbr, cts);
3120 bbr_substate_change(bbr, cts, __LINE__, 0);
3122 bbr_log_type_statechange(bbr, cts, __LINE__);
3130 bbr_set_epoch(bbr, cts, __LINE__);
3131 bbr->r_ctl.rc_bbr_state_time = cts;
3136 bbr_log_type_statechange(bbr, cts, __LINE__);
3139 bbr_log_type_ltbw(bbr, cts, 0, 0, 0, 0, 0);
3158 bbr_log_type_ltbw(bbr, cts, 7, lost, delivered, 0, 0);
3161 bbr_log_type_ltbw(bbr, cts, 8, lost, delivered, 0, 0);
3177 bbr_reset_lt_bw_interval(bbr, cts);
3179 bbr_log_type_ltbw(bbr, cts, 1, 0, 0, 0, 0);
3191 bbr_reset_lt_bw_sampling(bbr, cts);
3193 bbr_log_type_ltbw(bbr, cts, 2, 0, 0, 0, d_time);
3204 bbr_log_type_ltbw(bbr, cts, 6, 0, 0, 0, d_time);
3215 bbr_reset_lt_bw_sampling(bbr, cts);
3217 bbr_log_type_ltbw(bbr, cts, 3, 0, 0, 0, d_time);
3227 bbr_log_type_ltbw(bbr, cts, 6, 0, 0, 0, d_time);
3235 bbr_log_type_ltbw(bbr, cts, 6, lost, delivered, 0, d_time);
3241 bbr_log_type_ltbw(bbr, cts, 6, 0, 0, 0, d_time);
3246 bbr_reset_lt_bw_sampling(bbr, cts);
3248 bbr_log_type_ltbw(bbr, cts, 3, 0, 0, 0, d_time);
3255 bbr_lt_bw_samp_done(bbr, bw, cts, d_time);
3529 bbr_get_pacing_delay(struct tcp_bbr *bbr, uint16_t gain, int32_t len, uint32_t cts, int nolog)
3578 bbr_log_pacing_delay_calc(bbr, gain, len, cts, usecs, bw, over, 1);
3895 bbr_setup_red_bw(struct tcp_bbr *bbr, uint32_t cts)
3903 tcp_bbr_tso_size_check(bbr, cts);
4065 bbr_calc_thresh_rack(struct tcp_bbr *bbr, uint32_t srtt, uint32_t cts, struct bbr_sendmap *rsm)
4090 if (SEQ_GEQ(cts, bbr->r_ctl.rc_reorder_ts)) {
4091 lro = cts - bbr->r_ctl.rc_reorder_ts;
4137 bbr_log_thresh_choice(bbr, cts, thresh, lro, srtt, rsm, BBR_TO_FRM_RACK);
4149 uint32_t cts)
4197 bbr_log_thresh_choice(bbr, cts, thresh, t_rxtcur, srtt, rsm, BBR_TO_FRM_TLP);
4265 bbr_is_lost(struct tcp_bbr *bbr, struct bbr_sendmap *rsm, uint32_t cts)
4270 cts, rsm);
4271 if ((cts - rsm->r_tim_lastsent[(rsm->r_rtr_cnt - 1)]) >= thresh) {
4282 bbr_check_recovery_mode(struct tcpcb *tp, struct tcp_bbr *bbr, uint32_t cts)
4316 if (SEQ_LEQ(cts, rsm->r_tim_lastsent[idx])) {
4321 if (bbr_is_lost(bbr, rsm, cts) &&
4347 bbr_timeout_rack(struct tcpcb *tp, struct tcp_bbr *bbr, uint32_t cts)
4361 if (TSTMP_LT(cts, bbr->r_ctl.rc_timer_exp)) {
4369 bbr_log_to_event(bbr, cts, BBR_TO_FRM_RACK);
4372 bbr->r_ctl.rc_resend = bbr_check_recovery_mode(tp, bbr, cts);
4375 bbr_lt_bw_sampling(bbr, cts, (bbr->r_ctl.rc_lost > lost));
4534 bbr_timeout_tlp(struct tcpcb *tp, struct tcp_bbr *bbr, uint32_t cts)
4549 if (TSTMP_LT(cts, bbr->r_ctl.rc_timer_exp)) {
4688 bbr_log_to_event(bbr, cts, BBR_TO_FRM_TLP);
4702 bbr_timeout_delack(struct tcpcb *tp, struct tcp_bbr *bbr, uint32_t cts)
4707 bbr_log_to_event(bbr, cts, BBR_TO_FRM_DELACK);
4723 bbr_timeout_persist(struct tcpcb *tp, struct tcp_bbr *bbr, uint32_t cts)
4738 bbr_log_to_event(bbr, cts, BBR_TO_FRM_PERSIST);
4763 bbr_exit_persist(tp, bbr, cts, __LINE__);
4789 bbr_start_hpts_timer(bbr, tp, cts, 3, 0, 0);
4801 bbr_timeout_keepalive(struct tcpcb *tp, struct tcp_bbr *bbr, uint32_t cts)
4810 bbr_log_to_event(bbr, cts, BBR_TO_FRM_KEEP);
4841 bbr_start_hpts_timer(bbr, tp, cts, 4, 0, 0);
4862 uint32_t cts, lost;
4865 cts = tcp_get_usecs(&bbr->rc_tv);
4887 bbr_log_type_rsmclear(bbr, cts, rsm, old_flags, __LINE__);
4926 bbr_log_to_event(bbr, cts, BBR_TO_FRM_TMR);
4937 bbr_lt_bw_sampling(bbr, cts, (bbr->r_ctl.rc_lost > lost));
4945 bbr_timeout_rxt(struct tcpcb *tp, struct tcp_bbr *bbr, uint32_t cts)
5176 bbr_process_timers(struct tcpcb *tp, struct tcp_bbr *bbr, uint32_t cts, uint8_t hpts_calling)
5190 if (TSTMP_LT(cts, bbr->r_ctl.rc_timer_exp)) {
5195 bbr_log_to_processing(bbr, cts, ret, 0, hpts_calling);
5200 bbr_log_to_processing(bbr, cts, ret, 0, hpts_calling);
5207 left = bbr->r_ctl.rc_timer_exp - cts;
5209 bbr_log_to_processing(bbr, cts, ret, left, hpts_calling);
5216 ret = bbr_timeout_delack(tp, bbr, cts);
5218 ret = bbr_timeout_persist(tp, bbr, cts);
5220 bbr->r_ctl.rc_tlp_rxt_last_time = cts;
5221 ret = bbr_timeout_rack(tp, bbr, cts);
5223 bbr->r_ctl.rc_tlp_rxt_last_time = cts;
5224 ret = bbr_timeout_tlp(tp, bbr, cts);
5226 bbr->r_ctl.rc_tlp_rxt_last_time = cts;
5227 ret = bbr_timeout_rxt(tp, bbr, cts);
5229 ret = bbr_timeout_keepalive(tp, bbr, cts);
5231 bbr_log_to_processing(bbr, cts, ret, timers, hpts_calling);
5236 bbr_timer_cancel(struct tcp_bbr *bbr, int32_t line, uint32_t cts)
5254 if (TSTMP_GT(cts, bbr->rc_pacer_started))
5255 time_since_send = cts - bbr->rc_pacer_started;
5264 bbr->rc_pacer_started = cts;
5268 bbr_log_to_cancel(bbr, line, cts, hpts_removed);
5288 bbr_get_earliest_send_outstanding(struct tcp_bbr *bbr, struct bbr_sendmap *u_rsm, uint32_t cts)
5294 return (cts);
5300 struct bbr_sendmap *rsm, uint32_t cts, uint32_t pacing_time)
5335 rsm->r_tim_lastsent[idx] = cts;
5355 bbr_log_type_rsmclear(bbr, cts, rsm, old_flags, __LINE__);
5370 rsm->r_first_sent_time = bbr_get_earliest_send_outstanding(bbr, rsm, cts);
5395 struct bbr_sendmap *rsm, uint32_t cts, int32_t *lenp, uint32_t pacing_time)
5412 bbr_update_rsm(tp, bbr, rsm, cts, pacing_time);
5450 bbr_update_rsm(tp, bbr, rsm, cts, pacing_time);
5467 bbr_setup_less_of_rate(struct tcp_bbr *bbr, uint32_t cts,
5482 filter_reduce_by(&bbr->r_ctl.rc_delrate, red, cts);
5491 bbr_update_hardware_pacing_rate(struct tcp_bbr *bbr, uint32_t cts)
5509 tcp_bbr_tso_size_check(bbr, cts);
5528 bbr_setup_less_of_rate(bbr, cts,
5547 cts,
5553 bbr_adjust_for_hw_pacing(struct tcp_bbr *bbr, uint32_t cts)
5587 bbr->r_ctl.rc_pace_max_segs, cts, 1);
5594 bbr_log_type_tsosize(bbr, cts, delta, cur_delay, hdwr_delay,
5669 bbr_log_type_tsosize(bbr, cts, new_tso, 0, bbr->r_ctl.rc_pace_max_segs, maxseg, 0);
5675 tcp_bbr_tso_size_check(struct tcp_bbr *bbr, uint32_t cts)
5764 bbr_log_type_tsosize(bbr, cts, bbr->r_ctl.rc_pace_max_segs, tls_seg, old_tso, maxseg, 0);
5765 bbr_adjust_for_hw_pacing(bbr, cts);
5863 bbr_log_type_tsosize(bbr, cts, new_tso, tls_seg, old_tso, maxseg, 0);
5867 bbr_adjust_for_hw_pacing(bbr, cts);
5872 uint32_t seq_out, uint16_t th_flags, int32_t err, uint32_t cts,
5942 pacing_time = bbr_get_pacing_delay(bbr, bbr->r_ctl.rc_bbr_hptsi_gain, len, cts, 1);
5955 rsm->r_tim_lastsent[0] = cts;
5971 rsm->r_first_sent_time = bbr_get_earliest_send_outstanding(bbr, rsm, cts);
6017 seq_out = bbr_update_entry(tp, bbr, rsm, cts, &len, pacing_time);
6027 seq_out = bbr_update_entry(tp, bbr, rsm, cts, &len, pacing_time);
6043 bbr_update_rsm(tp, bbr, rsm, cts, pacing_time);
6057 seq_out = bbr_update_entry(tp, bbr, nrsm, cts, &len, pacing_time);
6244 tcp_bbr_xmit_timer_commit(struct tcp_bbr *bbr, struct tcpcb *tp, uint32_t cts)
6273 filter_increase_by_small(&bbr->r_ctl.rc_rttprop, (rtt - rtt_prop), cts);
6275 apply_filter_min_small(&bbr->r_ctl.rc_rttprop, rtt, cts);
6396 bbr_set_reduced_rtt(struct tcp_bbr *bbr, uint32_t cts, uint32_t line)
6398 bbr->r_ctl.rc_rtt_shrinks = cts;
6400 (TSTMP_GT(cts, bbr->r_ctl.last_in_probertt)) &&
6401 ((cts - bbr->r_ctl.last_in_probertt) > bbr->r_ctl.rc_probertt_int)) {
6406 bbr_enter_probe_rtt(bbr, cts, __LINE__);
6408 bbr_check_probe_rtt_limits(bbr, cts);
6412 tcp_bbr_commit_bw(struct tcp_bbr *bbr, uint32_t cts)
6418 bbr_log_type_bbrupd(bbr, 20, cts, 0, 0,
6426 bbr_log_type_bbrupd(bbr, 21, cts, (uint32_t)orig_bw,
6436 bbr_update_hardware_pacing_rate(bbr, cts);
6439 tcp_bbr_tso_size_check(bbr, cts);
6441 bbr_setup_red_bw(bbr, cts);
6445 tcp_bbr_tso_size_check(bbr, cts);
6449 bbr_nf_measurement(struct tcp_bbr *bbr, struct bbr_sendmap *rsm, uint32_t rtt, uint32_t cts)
6488 bbr_log_type_bbrupd(bbr, 61, cts,
6497 bbr_log_type_bbrupd(bbr, 62, cts,
6503 bbr_log_type_bbrupd(bbr, 8, cts,
6511 bbr_log_type_bbrupd(bbr, 7, cts,
6541 bbr_log_type_bbrupd(bbr, 6, cts,
6555 tcp_bbr_commit_bw(bbr, cts);
6556 bbr_log_type_bbrupd(bbr, 10, cts, (uint32_t)tim, delivered,
6563 bbr_google_measurement(struct tcp_bbr *bbr, struct bbr_sendmap *rsm, uint32_t rtt, uint32_t cts)
6586 bbr_log_type_bbrupd(bbr, 99, cts, (uint32_t)tim, delivered,
6617 bbr_log_type_bbrupd(bbr, 6, cts,
6628 bbr_log_type_bbrupd(bbr, 99, cts, (uint32_t)tim, delivered,
6638 tcp_bbr_commit_bw(bbr, cts);
6639 bbr_log_type_bbrupd(bbr, 10, cts, (uint32_t)tim, delivered,
6646 bbr_update_bbr_info(struct tcp_bbr *bbr, struct bbr_sendmap *rsm, uint32_t rtt, uint32_t cts, uint32_t tsin,
6653 bbr->r_ctl.rc_del_time = cts;
6701 bbr_log_rtt_shrinks(bbr, cts, 0, rtt, __LINE__, BBR_RTTS_NEWRTT, 0);
6702 bbr_set_reduced_rtt(bbr, cts, __LINE__);
6704 bbr_log_type_bbrrttprop(bbr, rtt, rsm->r_end, uts, cts,
6706 apply_filter_min_small(&bbr->r_ctl.rc_rttprop, rtt, cts);
6714 bbr_log_rtt_shrinks(bbr, cts, 0, 0,
6718 bbr_check_probe_rtt_limits(bbr, cts);
6735 bbr_google_measurement(bbr, rsm, rtt, cts);
6737 bbr_nf_measurement(bbr, rsm, rtt, cts);
6747 bbr_ts_convert(uint32_t cts) {
6750 sec = cts / MS_IN_USEC;
6751 msec = cts - (MS_IN_USEC * sec);
6761 struct bbr_sendmap *rsm, struct tcpopt *to, uint32_t cts, int32_t ack_type, uint32_t th_ack)
6780 if (TSTMP_GT(cts, rsm->r_tim_lastsent[0]))
6781 t = cts - rsm->r_tim_lastsent[0];
6785 bbr_update_bbr_info(bbr, rsm, t, cts, to->to_tsecr, 0,
6799 bbr_update_bbr_info(bbr, rsm, t, cts, to->to_tsecr, 0,
6820 if (TSTMP_GT(cts, rsm->r_tim_lastsent[i]))
6821 t = cts - rsm->r_tim_lastsent[i];
6825 bbr_update_bbr_info(bbr, rsm, t, cts, to->to_tsecr, uts, BBR_RTT_BY_TSMATCHING,
6849 if (TSTMP_GT(cts, rsm->r_tim_lastsent[i]))
6850 t = cts - rsm->r_tim_lastsent[i];
6871 if (TSTMP_GT(cts, rsm->r_tim_lastsent[i]))
6872 t = cts - rsm->r_tim_lastsent[i];
6875 bbr_update_bbr_info(bbr, rsm, t, cts, to->to_tsecr, uts, BBR_RTT_BY_EARLIER_RET,
6884 bbr_update_bbr_info(bbr, rsm, 0, cts, to->to_tsecr, uts,
6895 bbr_update_bbr_info(bbr, rsm, t, cts, to->to_tsecr, uts,
6898 bbr_update_bbr_info(bbr, rsm, 0, cts, to->to_tsecr, uts,
6951 struct tcpopt *to, struct bbr_sendmap **prsm, uint32_t cts)
7056 bbr_update_rtt(tp, bbr, rsm, to, cts, BBR_SACKED, 0);
7066 bbr->r_ctl.rc_reorder_ts = cts;
7081 bbr_isit_a_pkt_epoch(bbr, cts, rsm, __LINE__, BBR_SACKED);
7121 bbr_update_rtt(tp, bbr, rsm, to, cts, BBR_SACKED, 0);
7122 bbr_isit_a_pkt_epoch(bbr, cts, rsm, __LINE__, BBR_SACKED);
7132 bbr->r_ctl.rc_reorder_ts = cts;
7248 uint32_t cts;
7251 cts = bbr->r_ctl.rc_rcvtime;
7268 bbr_update_rtt(tp, bbr, rsm, to, cts, BBR_CUM_ACKED, 0);
7293 uint32_t cts, acked, ack_point, sack_changed = 0;
7302 cts = bbr->r_ctl.rc_rcvtime;
7338 tp->iss, 0, cts,
7340 apply_filter_min_small(&bbr->r_ctl.rc_rttprop, rtt, cts);
7406 bbr_update_rtt(tp, bbr, rsm, to, cts, BBR_CUM_ACKED, th_ack);
7417 bbr->r_ctl.rc_reorder_ts = cts;
7438 bbr_isit_a_pkt_epoch(bbr, cts, rsm, __LINE__, BBR_CUM_ACKED);
7466 bbr_update_rtt(tp, bbr, &lrsm, to, cts, BBR_CUM_ACKED, th_ack);
7477 bbr_isit_a_pkt_epoch(bbr, cts, rsm, __LINE__, BBR_CUM_ACKED);
7610 acked = bbr_proc_sack_blk(tp, bbr, &sack_blocks[i], to, &rsm, cts);
7626 rsm = bbr_check_recovery_mode(tp, bbr, cts);
7647 bbr->r_ctl.rc_resend = bbr_check_recovery_mode(tp, bbr, cts);
7879 bbr_enter_persist(struct tcpcb *tp, struct tcp_bbr *bbr, uint32_t cts, int32_t line)
7882 bbr_timer_cancel(bbr, __LINE__, cts);
7886 bbr->r_ctl.rc_went_idle_time = cts;
7888 bbr_log_type_pesist(bbr, cts, 0, line, 1);
7890 if (SEQ_GT(cts, bbr->r_ctl.rc_bbr_state_time)) {
7893 time_in = cts - bbr->r_ctl.rc_bbr_state_time;
7903 bbr->r_ctl.rc_bbr_state_time = cts;
7908 bbr_restart_after_idle(struct tcp_bbr *bbr, uint32_t cts, uint32_t idle_time)
7930 bbr_log_type_statechange(bbr, cts, __LINE__);
7932 bbr_substate_change(bbr, cts, __LINE__, 1);
7938 bbr_exit_persist(struct tcpcb *tp, struct tcp_bbr *bbr, uint32_t cts, int32_t line)
7944 idle_time = bbr_calc_time(cts, bbr->r_ctl.rc_went_idle_time);
7947 bbr->r_ctl.rc_del_time = cts;
7962 bbr_log_type_pesist(bbr, cts, idle_time, line, 0);
7969 bbr_log_rtt_shrinks(bbr, cts, 0, 0, __LINE__, BBR_RTTS_PERSIST, 0);
7970 bbr->r_ctl.last_in_probertt = bbr->r_ctl.rc_rtt_shrinks = cts;
7978 bbr_set_epoch(bbr, cts, __LINE__);
7985 bbr->r_ctl.rc_bbr_state_time = cts;
7993 bbr_restart_after_idle(bbr, cts, idle_time);
9941 uint32_t cts;
9970 cts = tcp_get_usecs(&bbr->rc_tv);
9988 bbr->r_ctl.rc_went_idle_time = cts;
9989 bbr->rc_pacer_started = cts;
9990 bbr->r_ctl.rc_pkt_epoch_time = cts;
9991 bbr->r_ctl.rc_rcvtime = cts;
9992 bbr->r_ctl.rc_bbr_state_time = cts;
9993 bbr->r_ctl.rc_del_time = cts;
9994 bbr->r_ctl.rc_tlp_rxt_last_time = cts;
9995 bbr->r_ctl.last_in_probertt = cts;
10060 bbr->r_ctl.rc_rtt_shrinks = cts;
10074 bbr_log_rtt_shrinks(bbr, cts, 0, 0, __LINE__, BBR_RTTS_INIT, 0);
10094 rsm->r_tim_lastsent[0] = cts;
10103 rsm->r_del_time = cts;
10127 bbr_log_type_statechange(bbr, cts, __LINE__);
10133 apply_filter_min_small(&bbr->r_ctl.rc_rttprop, rtt, cts);
10137 tcp_bbr_tso_size_check(bbr, cts);
10154 bbr_start_hpts_timer(bbr, tp, cts, 5, 0, 0);
10285 bbr_substate_change(struct tcp_bbr *bbr, uint32_t cts, int32_t line, int dolog)
10338 bbr->r_ctl.rc_bbr_state_atflight = cts;
10349 bbr->r_ctl.rc_bbr_state_atflight = cts;
10360 if ((cts - bbr->r_ctl.rc_bbr_state_time) > bbr_get_rtt(bbr, BBR_RTT_PROP))
10361 bbr->r_ctl.rc_exta_time_gd += ((cts - bbr->r_ctl.rc_bbr_state_time) -
10375 bbr->r_ctl.rc_bbr_state_atflight = max(1, cts);
10379 bbr->r_ctl.rc_bbr_state_atflight = max(1, cts);
10384 bbr_log_type_statechange(bbr, cts, line);
10386 if (SEQ_GT(cts, bbr->r_ctl.rc_bbr_state_time)) {
10389 time_in = cts - bbr->r_ctl.rc_bbr_state_time;
10419 tcp_bbr_tso_size_check(bbr, cts);
10420 bbr->r_ctl.gain_epoch = cts;
10421 bbr->r_ctl.rc_bbr_state_time = cts;
10426 bbr_set_probebw_google_gains(struct tcp_bbr *bbr, uint32_t cts, uint32_t losses)
10434 if (TSTMP_LT(cts, bbr->r_ctl.rc_bbr_state_time)) {
10437 if ((cts - bbr->r_ctl.rc_bbr_state_time) < bbr_get_rtt(bbr, BBR_RTT_PROP)) {
10460 bbr_substate_change(bbr, cts, __LINE__, 1);
10464 bbr_set_probebw_gains(struct tcp_bbr *bbr, uint32_t cts, uint32_t losses)
10469 bbr_set_probebw_google_gains(bbr, cts, losses);
10472 if (cts == 0) {
10474 * Never alow cts to be 0 we
10478 cts = 1;
10500 if (TSTMP_GT(cts, bbr->r_ctl.gain_epoch) &&
10501 (((cts - bbr->r_ctl.gain_epoch) > bbr_get_rtt(bbr, BBR_RTT_PROP)) ||
10526 bbr_log_exit_gain(bbr, cts, 4);
10531 bbr->r_ctl.gain_epoch = cts;
10540 bbr->r_ctl.rc_bbr_state_atflight = max(cts, 1);
10541 bbr_log_exit_gain(bbr, cts, 3);
10546 bbr->r_ctl.rc_bbr_state_atflight = max(cts, 1);
10552 bbr->r_ctl.rc_bbr_state_atflight = max(cts, 1);
10553 bbr_log_exit_gain(bbr, cts, 2);
10568 if (TSTMP_LT(cts, bbr->r_ctl.rc_bbr_state_time))
10570 if ((cts - bbr->r_ctl.rc_bbr_state_time) < bbr_cur_cycle_time) {
10576 ((cts - bbr->r_ctl.rc_bbr_state_time) <
10584 ((cts - bbr->r_ctl.rc_bbr_state_time) <
10589 bbr_substate_change(bbr, cts, __LINE__, 1);
10657 bbr_enter_probe_rtt(struct tcp_bbr *bbr, uint32_t cts, int32_t line)
10670 if (SEQ_GT(cts, bbr->r_ctl.rc_bbr_state_time)) {
10671 time_in = cts - bbr->r_ctl.rc_bbr_state_time;
10674 bbr_log_rtt_shrinks(bbr, cts, 0, 0, __LINE__, BBR_RTTS_ENTERPROBE, 0);
10675 bbr->r_ctl.rc_rtt_shrinks = cts;
10676 bbr->r_ctl.last_in_probertt = cts;
10677 bbr->r_ctl.rc_probertt_srttchktim = cts;
10678 bbr->r_ctl.rc_bbr_state_time = cts;
10719 bbr->r_ctl.rc_bbr_enters_probertt = cts;
10726 bbr_log_exit_gain(bbr, cts, 0);
10727 bbr_log_type_statechange(bbr, cts, line);
10731 bbr_check_probe_rtt_limits(struct tcp_bbr *bbr, uint32_t cts)
10796 bbr_log_rtt_shrinks(bbr, cts, cur_rttp, newval, __LINE__, BBR_RTTS_RESETS_VALUES, val);
10801 bbr_exit_probe_rtt(struct tcpcb *tp, struct tcp_bbr *bbr, uint32_t cts)
10809 bbr_log_exit_gain(bbr, cts, 1);
10811 bbr->r_ctl.rc_rtt_shrinks = cts;
10812 bbr->r_ctl.last_in_probertt = cts;
10813 bbr_log_rtt_shrinks(bbr, cts, 0, 0, __LINE__, BBR_RTTS_RTTPROBE, 0);
10818 if (SEQ_GT(cts, bbr->r_ctl.rc_bbr_state_time)) {
10821 time_in = cts - bbr->r_ctl.rc_bbr_state_time;
10827 bbr->rc_bbr_substate = bbr_pick_probebw_substate(bbr, cts);
10829 bbr_substate_change(bbr, cts, __LINE__, 0);
10830 bbr_log_type_statechange(bbr, cts, __LINE__);
10834 bbr->r_ctl.rc_bbr_state_time = cts;
10854 bbr_log_type_statechange(bbr, cts, __LINE__);
10855 bbr_log_startup_event(bbr, cts, bbr->r_ctl.rc_bbr_last_startup_epoch,
10858 bbr_check_probe_rtt_limits(bbr, cts);
10862 bbr_should_enter_probe_rtt(struct tcp_bbr *bbr, uint32_t cts)
10866 (bbr_calc_time(cts, bbr->r_ctl.rc_rtt_shrinks) >= bbr->r_ctl.rc_probertt_int)) {
10871 (TSTMP_GT(cts, bbr->r_ctl.last_in_probertt)) &&
10872 ((cts - bbr->r_ctl.last_in_probertt) > bbr->r_ctl.rc_probertt_int)) {
10879 bbr_google_startup(struct tcp_bbr *bbr, uint32_t cts, int32_t pkt_epoch)
10893 bbr_log_startup_event(bbr, cts, bbr->r_ctl.rc_bbr_last_startup_epoch,
10899 bbr_log_startup_event(bbr, cts, bbr->r_ctl.rc_bbr_last_startup_epoch,
10905 bbr_state_startup(struct tcp_bbr *bbr, uint32_t cts, int32_t epoch, int32_t pkt_epoch)
10913 (bbr_calc_time(cts, bbr->r_ctl.rc_went_idle_time) >= bbr_rtt_probe_time)) {
10919 bbr_log_rtt_shrinks(bbr, cts, 0, 0, __LINE__, BBR_RTTS_WASIDLE, 0);
10920 bbr_set_reduced_rtt(bbr, cts, __LINE__);
10922 if (bbr_should_enter_probe_rtt(bbr, cts)) {
10923 bbr_enter_probe_rtt(bbr, cts, __LINE__);
10927 return (bbr_google_startup(bbr, cts, pkt_epoch));
10967 bbr_log_startup_event(bbr, cts, rtt_gain,
10983 bbr_log_startup_event(bbr, cts, bbr->r_ctl.rc_bbr_last_startup_epoch,
11005 bbr_log_startup_event(bbr, cts, bbr->r_ctl.rc_bbr_last_startup_epoch,
11023 bbr_log_startup_event(bbr, cts, bbr->r_ctl.rc_bbr_last_startup_epoch,
11028 bbr_log_startup_event(bbr, cts, bbr->r_ctl.rc_bbr_last_startup_epoch,
11039 bbr_log_startup_event(bbr, cts, bbr->r_ctl.rc_bbr_last_startup_epoch,
11045 bbr_state_change(struct tcp_bbr *bbr, uint32_t cts, int32_t epoch, int32_t pkt_epoch, uint32_t losses)
11062 if (bbr_state_startup(bbr, cts, epoch, pkt_epoch)) {
11065 bbr_log_startup_event(bbr, cts, bbr->r_ctl.rc_bbr_last_startup_epoch,
11069 if (SEQ_GT(cts, bbr->r_ctl.rc_bbr_state_time)) {
11070 time_in = cts - bbr->r_ctl.rc_bbr_state_time;
11076 bbr->r_ctl.rc_bbr_state_time = cts;
11088 bbr_log_type_statechange(bbr, cts, __LINE__);
11096 bbr->rc_bbr_substate = bbr_pick_probebw_substate(bbr, cts);
11097 bbr_substate_change(bbr, cts, __LINE__, 0);
11099 bbr_log_type_statechange(bbr, cts, __LINE__);
11121 bbr_substate_change(bbr, cts, __LINE__, 1);
11145 if (SEQ_GT(cts, bbr->r_ctl.rc_bbr_state_time)) {
11148 time_in = cts - bbr->r_ctl.rc_bbr_state_time;
11159 bbr->r_ctl.rc_rtt_shrinks = cts;
11160 bbr->r_ctl.last_in_probertt = cts;
11161 bbr_log_rtt_shrinks(bbr, cts, 0, 0, __LINE__, BBR_RTTS_LEAVE_DRAIN, 0);
11163 bbr->rc_bbr_substate = bbr_pick_probebw_substate(bbr, cts);
11164 bbr_substate_change(bbr, cts, __LINE__, 0);
11165 bbr_log_type_statechange(bbr, cts, __LINE__);
11189 bbr_log_rtt_shrinks(bbr, cts, 0, 0, __LINE__, BBR_RTTS_REACHTAR, 0);
11190 bbr->r_ctl.rc_bbr_enters_probertt = cts;
11208 (((cts - bbr->r_ctl.rc_probertt_srttchktim) > bbr_get_rtt(bbr, bbr_drain_rtt)) ||
11221 bbr->r_ctl.rc_probertt_srttchktim = cts;
11226 bbr_log_rtt_shrinks(bbr, cts, 0, 0, __LINE__, BBR_RTTS_SHRINK_PG, 0);
11230 bbr_log_rtt_shrinks(bbr, cts, 0, 0, __LINE__, BBR_RTTS_SHRINK_PG_FINAL, 0);
11238 (TSTMP_GT(cts, bbr->r_ctl.rc_bbr_enters_probertt)) &&
11239 ((cts - bbr->r_ctl.rc_bbr_enters_probertt) >= bbr_rtt_probe_time)) {
11241 bbr_exit_probe_rtt(bbr->rc_tp, bbr, cts);
11245 (bbr_calc_time(cts, bbr->r_ctl.rc_went_idle_time) >= bbr_rtt_probe_time)) {
11251 bbr_log_rtt_shrinks(bbr, cts, 0, 0, __LINE__, BBR_RTTS_WASIDLE, 0);
11252 bbr_set_reduced_rtt(bbr, cts, __LINE__);
11254 if (bbr_should_enter_probe_rtt(bbr, cts)) {
11255 bbr_enter_probe_rtt(bbr, cts, __LINE__);
11257 bbr_set_probebw_gains(bbr, cts, losses);
11263 bbr_check_bbr_for_state(struct tcp_bbr *bbr, uint32_t cts, int32_t line, uint32_t losses)
11267 if ((cts - bbr->r_ctl.rc_rcv_epoch_start) >= bbr_get_rtt(bbr, BBR_RTT_PROP)) {
11268 bbr_set_epoch(bbr, cts, line);
11272 bbr_state_change(bbr, cts, epoch, bbr->rc_is_pkt_epoch_now, losses);
11283 uint32_t cts, lcts;
11330 bbr->r_ctl.rc_rcvtime = cts = tcp_tv_to_usectick(&bbr->rc_tv);
11338 bbr->r_ctl.rc_rcvtime = cts = tcp_tv_to_usectick(&bbr->rc_tv);
11343 bbr->r_ctl.rc_rcvtime = lcts = cts = tcp_get_usecs(&bbr->rc_tv);
11486 if (TSTMP_GT(lcts, cts)) {
11487 bbr->r_ctl.rc_ack_hdwr_delay = lcts - cts;
11500 bbr_log_ack_event(bbr, th, &to, tlen, nsegs, cts, nxt_pkt, m);
11541 tcp_bbr_xmit_timer_commit(bbr, tp, cts);
11543 bbr_set_pktepoch(bbr, cts, __LINE__);
11544 bbr_check_bbr_for_state(bbr, cts, __LINE__, (bbr->r_ctl.rc_lost - lost));
11554 bbr_start_hpts_timer(bbr, tp, cts, 6, 0, 0);
11596 bbr_start_hpts_timer(bbr, tp, cts, 8, bbr->r_ctl.rc_last_delay_val,
11610 bbr_log_doseg_done(bbr, cts, nxt_pkt, did_out);
11651 uint32_t avail, int32_t sb_offset, uint32_t cts)
11820 uint32_t cts;
11873 cts = tcp_tv_to_usectick(&bbr->rc_tv);
11886 tcp_bbr_tso_size_check(bbr, cts);
11936 bbr_timer_cancel(bbr, __LINE__, cts);
11940 if (SEQ_GT(cts, bbr->rc_pacer_started))
11941 delay_calc = cts - bbr->rc_pacer_started;
11982 if (SEQ_GT(cts, bbr->rc_pacer_started))
11983 delay_calc = cts - bbr->rc_pacer_started;
12013 bbr->r_ctl.rc_agg_early, cts, delay_calc, merged_val,
12047 cts, bbr_calc_time(cts, bbr->r_ctl.rc_went_idle_time));
12058 retval = bbr_process_timers(tp, bbr, cts, hpts_calling);
12093 bbr_check_bbr_for_state(bbr, cts, __LINE__, 0);
12141 bbr->r_ctl.rc_resend = bbr_check_recovery_mode(tp, bbr, cts);
12325 len = bbr_what_can_we_send(tp, bbr, sendwin, avail, sb_offset, cts);
12466 bbr_enter_persist(tp, bbr, cts, __LINE__);
12488 bbr_enter_persist(tp, bbr, cts, __LINE__);
12704 slot = bbr_get_pacing_delay(bbr, bbr->r_ctl.rc_bbr_hptsi_gain, tot_len, cts, 0);
12741 bbr_check_bbr_for_state(bbr, cts, __LINE__, 0);
12756 bbr_start_hpts_timer(bbr, tp, cts, 9, slot, tot_len);
12757 bbr_log_type_just_return(bbr, cts, tot_len, hpts_calling, app_limited, p_maxseg, len);
12781 bbr_timer_cancel(bbr, __LINE__, cts);
12812 (bbr_calc_time(cts, bbr->r_ctl.rc_went_idle_time) >= bbr_rtt_probe_time)) {
12818 bbr_log_rtt_shrinks(bbr, cts, 0, 0, __LINE__, BBR_RTTS_WASIDLE, 0);
12819 bbr_set_reduced_rtt(bbr, cts, __LINE__);
13085 bbr_log_enobuf_jmp(bbr, len, cts, __LINE__, len, 0, 0);
13239 bbr_log_enobuf_jmp(bbr, len, cts, __LINE__, len, 0, 0);
13492 bbr_fill_in_logging_data(bbr, &log.u_bbr, cts);
13638 bbr->r_ctl.rc_del_time = cts;
13665 bbr->r_ctl.rc_tlp_rxt_last_time = cts;
13669 cts, mb, &abandon, rsm, 0, sb);
13801 bbr_log_msgsize_fail(bbr, tp, len, maxseg, mtu, csum_flags, tso, cts);
13817 bbr_log_msgsize_fail(bbr, tp, len, maxseg, mtu, 0, tso, cts);
13826 (tot_len + len), cts, 0);
13832 bbr_start_hpts_timer(bbr, tp, cts, 10, slot,
13852 bbr_start_hpts_timer(bbr, tp, cts, 11, slot, 0);
13863 tp->gput_ts = cts;
13897 __LINE__, cts, err);
13905 bbr_setup_less_of_rate(bbr, cts,
13912 tcp_bbr_tso_size_check(bbr, cts);
13918 __LINE__, cts, err);
13943 tcp_bbr_tso_size_check(bbr, cts);
13993 slot = bbr_get_pacing_delay(bbr, bbr->r_ctl.rc_bbr_hptsi_gain, tot_len, cts, 0);
14000 bbr_check_bbr_for_state(bbr, cts, __LINE__, 0);
14006 ((bbr->r_ctl.rc_resend = bbr_check_recovery_mode(tp, bbr, cts)) != NULL))) {
14020 tcp_bbr_tso_size_check(bbr, cts);
14023 bbr_start_hpts_timer(bbr, tp, cts, 12, slot, tot_len);
14112 uint32_t cts;
14124 cts = tcp_get_usecs(&tv);
14126 if (TSTMP_GT(bbr->rc_pacer_started, cts)) {
14127 toval = bbr->rc_pacer_started - cts;
14133 if (TSTMP_GT(bbr->r_ctl.rc_timer_exp, cts)) {
14134 toval = bbr->r_ctl.rc_timer_exp - cts;
14143 bbr_log_hpts_diag(bbr, cts, &diag);
14437 uint32_t cts;
14438 cts = tcp_get_usecs(&bbr->rc_tv);
14439 tcp_bbr_tso_size_check(bbr, cts);