Date: Wed, 12 Feb 2020 12:40:06 +0000 (UTC) From: Randall Stewart <rrs@FreeBSD.org> To: src-committers@freebsd.org, svn-src-all@freebsd.org, svn-src-head@freebsd.org Subject: svn commit: r357815 - head/sys/netinet/tcp_stacks Message-ID: <202002121240.01CCe6ir034058@repo.freebsd.org>
next in thread | raw e-mail | index | archive | help
Author: rrs Date: Wed Feb 12 12:40:06 2020 New Revision: 357815 URL: https://svnweb.freebsd.org/changeset/base/357815 Log: Remove all trailing white space from the BBR/Rack fold. Bits left around by emacs (thanks emacs). Modified: head/sys/netinet/tcp_stacks/bbr.c head/sys/netinet/tcp_stacks/rack.c head/sys/netinet/tcp_stacks/rack_bbr_common.c head/sys/netinet/tcp_stacks/rack_bbr_common.h head/sys/netinet/tcp_stacks/sack_filter.c head/sys/netinet/tcp_stacks/tcp_bbr.h head/sys/netinet/tcp_stacks/tcp_rack.h Modified: head/sys/netinet/tcp_stacks/bbr.c ============================================================================== --- head/sys/netinet/tcp_stacks/bbr.c Wed Feb 12 12:36:55 2020 (r357814) +++ head/sys/netinet/tcp_stacks/bbr.c Wed Feb 12 12:40:06 2020 (r357815) @@ -208,7 +208,7 @@ static int32_t bbr_min_measurements_req = 1; /* We nee * to prevent it from being ok * to have no measurements). */ static int32_t bbr_no_pacing_until = 4; - + static int32_t bbr_min_usec_delta = 20000; /* 20,000 usecs */ static int32_t bbr_min_peer_delta = 20; /* 20 units */ static int32_t bbr_delta_percent = 150; /* 15.0 % */ @@ -380,9 +380,9 @@ static int32_t bbr_rto_max_sec = 4; /* 4 seconds */ static int32_t bbr_hptsi_per_second = 1000; /* - * For hptsi under bbr_cross_over connections what is delay + * For hptsi under bbr_cross_over connections what is delay * target 7ms (in usec) combined with a seg_max of 2 - * gets us close to identical google behavior in + * gets us close to identical google behavior in * TSO size selection (possibly more 1MSS sends). */ static int32_t bbr_hptsi_segments_delay_tar = 7000; @@ -596,9 +596,9 @@ activate_rxt: rsm = TAILQ_FIRST(&bbr->r_ctl.rc_tmap); if (rsm) { idx = rsm->r_rtr_cnt - 1; - if (TSTMP_GEQ(rsm->r_tim_lastsent[idx], bbr->r_ctl.rc_tlp_rxt_last_time)) + if (TSTMP_GEQ(rsm->r_tim_lastsent[idx], bbr->r_ctl.rc_tlp_rxt_last_time)) tstmp_touse = rsm->r_tim_lastsent[idx]; - else + else tstmp_touse = bbr->r_ctl.rc_tlp_rxt_last_time; if (TSTMP_GT(tstmp_touse, cts)) time_since_sent = cts - tstmp_touse; @@ -673,9 +673,9 @@ activate_rxt: } time_since_sent = 0; idx = rsm->r_rtr_cnt - 1; - if (TSTMP_GEQ(rsm->r_tim_lastsent[idx], bbr->r_ctl.rc_tlp_rxt_last_time)) + if (TSTMP_GEQ(rsm->r_tim_lastsent[idx], bbr->r_ctl.rc_tlp_rxt_last_time)) tstmp_touse = rsm->r_tim_lastsent[idx]; - else + else tstmp_touse = bbr->r_ctl.rc_tlp_rxt_last_time; if (TSTMP_GT(tstmp_touse, cts)) time_since_sent = cts - tstmp_touse; @@ -695,11 +695,11 @@ activate_rxt: } if ((bbr->rc_tlp_rtx_out == 1) && (rsm->r_start == bbr->r_ctl.rc_last_tlp_seq)) { - /* - * Second retransmit of the same TLP + /* + * Second retransmit of the same TLP * lets not. */ - bbr->rc_tlp_rtx_out = 0; + bbr->rc_tlp_rtx_out = 0; goto activate_rxt; } if (rsm->r_start != bbr->r_ctl.rc_last_tlp_seq) { @@ -766,7 +766,7 @@ bbr_start_hpts_timer(struct tcp_bbr *bbr, struct tcpcb prev_delay = bbr->r_ctl.rc_last_delay_val; if (bbr->r_ctl.rc_last_delay_val && (slot == 0)) { - /* + /* * If a previous pacer delay was in place we * are not coming from the output side (where * we calculate a delay, more likely a timer). @@ -777,7 +777,7 @@ bbr_start_hpts_timer(struct tcp_bbr *bbr, struct tcpcb delay_calc = cts - bbr->rc_pacer_started; if (delay_calc <= slot) slot -= delay_calc; - } + } } /* Do we have early to make up for by pushing out the pacing time? */ if (bbr->r_agg_early_set) { @@ -804,8 +804,8 @@ bbr_start_hpts_timer(struct tcp_bbr *bbr, struct tcpcb if (bbr->rc_in_persist == 0) { delayed_ack = bbr_delack_time; } else { - /* - * We are in persists and have + /* + * We are in persists and have * gotten a new data element. */ if (hpts_timeout > bbr_delack_time) { @@ -816,7 +816,7 @@ bbr_start_hpts_timer(struct tcp_bbr *bbr, struct tcpcb hpts_timeout = bbr_delack_time; } } - } + } if (delayed_ack && ((hpts_timeout == 0) || (delayed_ack < hpts_timeout))) { @@ -910,10 +910,10 @@ bbr_start_hpts_timer(struct tcp_bbr *bbr, struct tcpcb * the do not disturbe even for sack. */ inp->inp_flags2 |= INP_DONT_SACK_QUEUE; - } else + } else inp->inp_flags2 &= ~INP_DONT_SACK_QUEUE; bbr->rc_pacer_started = cts; - + (void)tcp_hpts_insert_diag(tp->t_inpcb, HPTS_USEC_TO_SLOTS(slot), __LINE__, &diag); bbr->rc_timer_first = 0; @@ -923,8 +923,8 @@ bbr_start_hpts_timer(struct tcp_bbr *bbr, struct tcpcb } else if (hpts_timeout) { (void)tcp_hpts_insert_diag(tp->t_inpcb, HPTS_USEC_TO_SLOTS(hpts_timeout), __LINE__, &diag); - /* - * We add the flag here as well if the slot is set, + /* + * We add the flag here as well if the slot is set, * since hpts will call in to clear the queue first before * calling the output routine (which does our timers). * We don't want to set the flag if its just a timer @@ -937,7 +937,7 @@ bbr_start_hpts_timer(struct tcp_bbr *bbr, struct tcpcb bbr->rc_pacer_started = cts; if ((bbr->r_ctl.rc_hpts_flags & PACE_TMR_RACK) && (bbr->rc_cwnd_limited == 0)) { - /* + /* * For a rack timer, don't wake us even * if a sack arrives as long as we are * not cwnd limited. @@ -1048,7 +1048,7 @@ bbr_timer_audit(struct tcpcb *tp, struct tcp_bbr *bbr, * We have outstanding data and * we *do* have a RACK, TLP or RXT * timer running. We won't restart - * anything here since thats probably ok we + * anything here since thats probably ok we * will get called with some timer here shortly. */ return; @@ -2223,7 +2223,7 @@ bbr_log_rtt_sample(struct tcp_bbr *bbr, uint32_t rtt, log.u_bbr.pkts_out = tcp_tv_to_mssectick(&bbr->rc_tv); log.u_bbr.flex6 = tsin; log.u_bbr.flex7 = 0; - log.u_bbr.flex8 = bbr->rc_ack_was_delayed; + log.u_bbr.flex8 = bbr->rc_ack_was_delayed; TCP_LOG_EVENTP(bbr->rc_tp, NULL, &bbr->rc_inp->inp_socket->so_rcv, &bbr->rc_inp->inp_socket->so_snd, @@ -2423,7 +2423,7 @@ bbr_log_startup_event(struct tcp_bbr *bbr, uint32_t ct log.u_bbr.flex1 = flex1; log.u_bbr.flex2 = flex2; log.u_bbr.flex3 = flex3; - log.u_bbr.flex4 = 0; + log.u_bbr.flex4 = 0; log.u_bbr.flex5 = bbr->r_ctl.rc_target_at_state; log.u_bbr.flex6 = bbr->r_ctl.rc_lost_at_startup; log.u_bbr.flex8 = reason; @@ -2693,7 +2693,7 @@ bbr_log_type_bbrupd(struct tcp_bbr *bbr, uint8_t flex8 log.u_bbr.flex8 = flex8; if (bbr->rc_ack_was_delayed) log.u_bbr.epoch = bbr->r_ctl.rc_ack_hdwr_delay; - else + else log.u_bbr.epoch = 0; TCP_LOG_EVENTP(bbr->rc_tp, NULL, &bbr->rc_inp->inp_socket->so_rcv, @@ -2725,7 +2725,7 @@ bbr_log_type_ltbw(struct tcp_bbr *bbr, uint32_t cts, i if (bbr->rc_lt_use_bw == 0) log.u_bbr.epoch = bbr->r_ctl.rc_pkt_epoch - bbr->r_ctl.rc_lt_epoch; else - log.u_bbr.epoch = bbr->r_ctl.rc_pkt_epoch - bbr->r_ctl.rc_lt_epoch_use; + log.u_bbr.epoch = bbr->r_ctl.rc_pkt_epoch - bbr->r_ctl.rc_lt_epoch_use; TCP_LOG_EVENTP(bbr->rc_tp, NULL, &bbr->rc_inp->inp_socket->so_rcv, &bbr->rc_inp->inp_socket->so_snd, @@ -2908,10 +2908,10 @@ bbr_set_pktepoch(struct tcp_bbr *bbr, uint32_t cts, in calclr /= (uint64_t)del; } else { /* Nothing delivered? 100.0% loss */ - calclr = 1000; + calclr = 1000; } bbr->r_ctl.rc_pkt_epoch_loss_rate = (uint32_t)calclr; - if (IN_RECOVERY(bbr->rc_tp->t_flags)) + if (IN_RECOVERY(bbr->rc_tp->t_flags)) bbr->r_ctl.recovery_lr += (uint32_t)calclr; bbr->r_ctl.rc_pkt_epoch++; if (bbr->rc_no_pacing && @@ -2959,8 +2959,8 @@ __bbr_get_bw(struct tcp_bbr *bbr) uint64_t bw, min_bw; uint64_t rtt; int gm_measure_cnt = 1; - - /* + + /* * For startup we make, like google, a * minimum b/w. This is generated from the * IW and the rttProp. We do fall back to srtt @@ -2970,7 +2970,7 @@ __bbr_get_bw(struct tcp_bbr *bbr) */ if (bbr->rc_bbr_state == BBR_STATE_STARTUP) { /* Attempt first to use rttProp */ - rtt = (uint64_t)get_filter_value_small(&bbr->r_ctl.rc_rttprop); + rtt = (uint64_t)get_filter_value_small(&bbr->r_ctl.rc_rttprop); if (rtt && (rtt < 0xffffffff)) { measure: min_bw = (uint64_t)(bbr_initial_cwnd(bbr, bbr->rc_tp)) * @@ -3158,7 +3158,7 @@ static void bbr_randomize_extra_state_time(struct tcp_bbr *bbr) { uint32_t ran, deduct; - + ran = arc4random_uniform(bbr_rand_ot); if (ran) { deduct = bbr->r_ctl.rc_level_state_extra / ran; @@ -3219,8 +3219,8 @@ reset_all: bbr->rc_bbr_state = BBR_STATE_PROBE_BW; bbr_log_type_statechange(bbr, cts, __LINE__); } else { - /* - * This should not happen really + /* + * This should not happen really * unless we remove the startup/drain * restrictions above. */ @@ -3293,7 +3293,7 @@ reset_all: } diff = bbr->r_ctl.rc_pkt_epoch - bbr->r_ctl.rc_lt_epoch; if (diff < bbr_lt_intvl_min_rtts) { - /* + /* * need more samples (we don't * start on a round like linux so * we need 1 more). @@ -3536,20 +3536,20 @@ bbr_get_target_cwnd(struct tcp_bbr *bbr, uint64_t bw, mss = min((bbr->rc_tp->t_maxseg - bbr->rc_last_options), bbr->r_ctl.rc_pace_max_segs); /* Get the base cwnd with gain rounded to a mss */ cwnd = roundup(bbr_get_raw_target_cwnd(bbr, bw, gain), mss); - /* + /* * Add in N (2 default since we do not have a - * fq layer to trap packets in) quanta's per the I-D - * section 4.2.3.2 quanta adjust. + * fq layer to trap packets in) quanta's per the I-D + * section 4.2.3.2 quanta adjust. */ cwnd += (bbr_quanta * bbr->r_ctl.rc_pace_max_segs); if (bbr->rc_use_google) { if((bbr->rc_bbr_state == BBR_STATE_PROBE_BW) && (bbr_state_val(bbr) == BBR_SUB_GAIN)) { - /* + /* * The linux implementation adds * an extra 2 x mss in gain cycle which * is documented no-where except in the code. - * so we add more for Neal undocumented feature + * so we add more for Neal undocumented feature */ cwnd += 2 * mss; } @@ -3605,7 +3605,7 @@ static uint32_t bbr_get_pacing_length(struct tcp_bbr *bbr, uint16_t gain, uint32_t useconds_time, uint64_t bw) { uint64_t divor, res, tim; - + if (useconds_time == 0) return (0); gain = bbr_gain_adjust(bbr, gain); @@ -3642,8 +3642,8 @@ bbr_get_pacing_delay(struct tcp_bbr *bbr, uint16_t gai bw = bbr_get_bw(bbr); if (bbr->rc_use_google) { uint64_t cbw; - - /* + + /* * Reduce the b/w by the google discount * factor 10 = 1%. */ @@ -3721,8 +3721,8 @@ bbr_ack_received(struct tcpcb *tp, struct tcp_bbr *bbr bytes_this_ack += sack_changed; if (bytes_this_ack > prev_acked) { bytes_this_ack -= prev_acked; - /* - * A byte ack'd gives us a full mss + /* + * A byte ack'd gives us a full mss * to be like linux i.e. they count packets. */ if ((bytes_this_ack < maxseg) && bbr->rc_use_google) @@ -3733,7 +3733,7 @@ bbr_ack_received(struct tcpcb *tp, struct tcp_bbr *bbr } cwnd = tp->snd_cwnd; bw = get_filter_value(&bbr->r_ctl.rc_delrate); - if (bw) + if (bw) target_cwnd = bbr_get_target_cwnd(bbr, bw, (uint32_t)bbr->r_ctl.rc_bbr_cwnd_gain); @@ -3741,7 +3741,7 @@ bbr_ack_received(struct tcpcb *tp, struct tcp_bbr *bbr target_cwnd = bbr_initial_cwnd(bbr, bbr->rc_tp); if (IN_RECOVERY(tp->t_flags) && (bbr->bbr_prev_in_rec == 0)) { - /* + /* * We are entering recovery and * thus packet conservation. */ @@ -3770,7 +3770,7 @@ bbr_ack_received(struct tcpcb *tp, struct tcp_bbr *bbr if (TSTMP_GEQ(bbr->r_ctl.rc_rcvtime, bbr->r_ctl.rc_recovery_start)) time_in = bbr->r_ctl.rc_rcvtime - bbr->r_ctl.rc_recovery_start; - else + else time_in = 0; if (time_in >= bbr_get_rtt(bbr, BBR_RTT_PROP)) { @@ -3818,7 +3818,7 @@ bbr_ack_received(struct tcpcb *tp, struct tcp_bbr *bbr meth = 3; cwnd += bytes_this_ack; } else { - /* + /* * Method 4 means we are at target so no gain in * startup and past the initial window. */ @@ -3888,7 +3888,7 @@ bbr_post_recovery(struct tcpcb *tp) uint64_t val, lr2use; uint32_t maxseg, newcwnd, acks_inflight, ratio, cwnd; uint32_t *cwnd_p; - + if (bbr_get_rtt(bbr, BBR_SRTT)) { val = ((uint64_t)bbr_get_rtt(bbr, BBR_RTT_PROP) * (uint64_t)1000); val /= bbr_get_rtt(bbr, BBR_SRTT); @@ -3911,8 +3911,8 @@ bbr_post_recovery(struct tcpcb *tp) (bbr_state_val(bbr) == BBR_SUB_DRAIN)) || ((bbr->rc_bbr_state == BBR_STATE_DRAIN) && bbr_slam_cwnd_in_main_drain)) { - /* - * Here we must poke at the saved cwnd + /* + * Here we must poke at the saved cwnd * as well as the cwnd. */ cwnd = bbr->r_ctl.rc_saved_cwnd; @@ -3954,7 +3954,7 @@ bbr_post_recovery(struct tcpcb *tp) } /* with standard delayed acks how many acks can I expect? */ if (bbr_drop_limit == 0) { - /* + /* * Anticpate how much we will * raise the cwnd based on the acks. */ @@ -4013,8 +4013,8 @@ bbr_cong_signal(struct tcpcb *tp, struct tcphdr *th, u /* Start a new epoch */ bbr_set_pktepoch(bbr, bbr->r_ctl.rc_rcvtime, __LINE__); if (bbr->rc_lt_is_sampling || bbr->rc_lt_use_bw) { - /* - * Move forward the lt epoch + /* + * Move forward the lt epoch * so it won't count the truncated * epoch. */ @@ -4022,7 +4022,7 @@ bbr_cong_signal(struct tcpcb *tp, struct tcphdr *th, u } if (bbr->rc_bbr_state == BBR_STATE_STARTUP) { /* - * Just like the policer detection code + * Just like the policer detection code * if we are in startup we must push * forward the last startup epoch * to hide the truncated PE. @@ -4036,7 +4036,7 @@ bbr_cong_signal(struct tcpcb *tp, struct tcphdr *th, u tcp_bbr_tso_size_check(bbr, bbr->r_ctl.rc_rcvtime); if (bbr->rc_inp->inp_in_hpts && ((bbr->r_ctl.rc_hpts_flags & PACE_TMR_RACK) == 0)) { - /* + /* * When we enter recovery, we need to restart * any timers. This may mean we gain an agg * early, which will be made up for at the last @@ -4358,7 +4358,7 @@ bbr_is_lost(struct tcp_bbr *bbr, struct bbr_sendmap *r { uint32_t thresh; - + thresh = bbr_calc_thresh_rack(bbr, bbr_get_rtt(bbr, BBR_RTT_RACK), cts, rsm); if ((cts - rsm->r_tim_lastsent[(rsm->r_rtr_cnt - 1)]) >= thresh) { @@ -4447,7 +4447,7 @@ bbr_timeout_rack(struct tcpcb *tp, struct tcp_bbr *bbr * settings. */ uint32_t lost; - + if (bbr->rc_all_timers_stopped) { return (1); } @@ -4519,7 +4519,7 @@ static int bbr_sack_mergable(struct bbr_sendmap *at, uint32_t start, uint32_t end) { - /* + /* * Given a sack block defined by * start and end, and a current postion * at. Return 1 if either side of at @@ -4554,7 +4554,7 @@ bbr_sack_mergable(struct bbr_sendmap *at, if ((r_rsm->r_start == end) || (SEQ_LT(start, r_rsm->r_start) && SEQ_GT(end, r_rsm->r_start))) { - /* + /* * map blk |---------| * sack blk |----| * <or> @@ -4572,7 +4572,7 @@ bbr_merge_rsm(struct tcp_bbr *bbr, struct bbr_sendmap *l_rsm, struct bbr_sendmap *r_rsm) { - /* + /* * We are merging two ack'd RSM's, * the l_rsm is on the left (lower seq * values) and the r_rsm is on the right @@ -4604,7 +4604,7 @@ bbr_merge_rsm(struct tcp_bbr *bbr, /* This really should not happen */ bbr->r_ctl.rc_lost_bytes -= r_rsm->r_end - r_rsm->r_start; } - TAILQ_REMOVE(&bbr->r_ctl.rc_map, r_rsm, r_next); + TAILQ_REMOVE(&bbr->r_ctl.rc_map, r_rsm, r_next); if ((r_rsm->r_limit_type == 0) && (l_rsm->r_limit_type != 0)) { /* Transfer the split limit to the map we free */ r_rsm->r_limit_type = l_rsm->r_limit_type; @@ -4711,8 +4711,8 @@ need_retran: goto restore; } } else { - /* - * We must find the last segment + /* + * We must find the last segment * that was acceptable by the client. */ TAILQ_FOREACH_REVERSE(rsm, &bbr->r_ctl.rc_map, bbr_head, r_next) { @@ -4974,7 +4974,7 @@ bbr_remxt_tmr(struct tcpcb *tp) TAILQ_FOREACH(rsm, &bbr->r_ctl.rc_map, r_next) { if (rsm->r_flags & BBR_ACKED) { uint32_t old_flags; - + rsm->r_dupack = 0; if (rsm->r_in_tmap == 0) { /* We must re-add it back to the tlist */ @@ -4996,7 +4996,7 @@ bbr_remxt_tmr(struct tcpcb *tp) } if (bbr_marks_rxt_sack_passed) { /* - * With this option, we will rack out + * With this option, we will rack out * in 1ms increments the rest of the packets. */ rsm->r_flags |= BBR_SACK_PASSED | BBR_MARKED_LOST; @@ -5388,7 +5388,7 @@ static uint32_t bbr_get_earliest_send_outstanding(struct tcp_bbr *bbr, struct bbr_sendmap *u_rsm, uint32_t cts) { struct bbr_sendmap *rsm; - + rsm = TAILQ_FIRST(&bbr->r_ctl.rc_tmap); if ((rsm == NULL) || (u_rsm == rsm)) return (cts); @@ -5414,7 +5414,7 @@ bbr_update_rsm(struct tcpcb *tp, struct tcp_bbr *bbr, if (rsm->r_flags & BBR_MARKED_LOST) { /* We have retransmitted, its no longer lost */ rsm->r_flags &= ~BBR_MARKED_LOST; - bbr->r_ctl.rc_lost_bytes -= rsm->r_end - rsm->r_start; + bbr->r_ctl.rc_lost_bytes -= rsm->r_end - rsm->r_start; } if (rsm->r_flags & BBR_RXT_CLEARED) { /* @@ -5436,7 +5436,7 @@ bbr_update_rsm(struct tcpcb *tp, struct tcp_bbr *bbr, rsm->r_pacing_delay = pacing_time; rsm->r_delivered = bbr->r_ctl.rc_delivered; rsm->r_ts_valid = bbr->rc_ts_valid; - if (bbr->rc_ts_valid) + if (bbr->rc_ts_valid) rsm->r_del_ack_ts = bbr->r_ctl.last_inbound_ts; if (bbr->r_ctl.r_app_limited_until) rsm->r_app_limited = 1; @@ -5556,7 +5556,7 @@ static uint64_t bbr_get_hardware_rate(struct tcp_bbr *bbr) { uint64_t bw; - + bw = bbr_get_bw(bbr); bw *= (uint64_t)bbr_hptsi_gain[BBR_SUB_GAIN]; bw /= (uint64_t)BBR_UNIT; @@ -5592,7 +5592,7 @@ bbr_update_hardware_pacing_rate(struct tcp_bbr *bbr, u { const struct tcp_hwrate_limit_table *nrte; int error, rate = -1; - + if (bbr->r_ctl.crte == NULL) return; if ((bbr->rc_inp->inp_route.ro_rt == NULL) || @@ -5702,12 +5702,12 @@ bbr_adjust_for_hw_pacing(struct tcp_bbr *bbr, uint32_t * time between each segment the * hardware sends rounding up and * derive a bytes from that. We multiply - * that by bbr_hdwr_pace_adjust to get + * that by bbr_hdwr_pace_adjust to get * more bang for our buck. * * The goal is to have the software pacer * waiting no more than an additional - * pacing delay if we can (without the + * pacing delay if we can (without the * compensation i.e. x bbr_hdwr_pace_adjust). */ seg_sz = max(((cur_delay + rlp->time_between)/rlp->time_between), @@ -5724,12 +5724,12 @@ bbr_adjust_for_hw_pacing(struct tcp_bbr *bbr, uint32_t } seg_sz *= maxseg; } else if (delta == 0) { - /* + /* * The highest pacing rate is * above our b/w gained. This means * we probably are going quite fast at * the hardware highest rate. Lets just multiply - * the calculated TSO size by the + * the calculated TSO size by the * multiplier factor (its probably * 4 segments in the default config for * mlx). @@ -5764,7 +5764,7 @@ bbr_adjust_for_hw_pacing(struct tcp_bbr *bbr, uint32_t new_tso = bbr->r_ctl.rc_pace_max_segs; if (new_tso >= (PACE_MAX_IP_BYTES-maxseg)) new_tso = PACE_MAX_IP_BYTES - maxseg; - + if (new_tso != bbr->r_ctl.rc_pace_max_segs) { bbr_log_type_tsosize(bbr, cts, new_tso, 0, bbr->r_ctl.rc_pace_max_segs, maxseg, 0); bbr->r_ctl.rc_pace_max_segs = new_tso; @@ -5778,7 +5778,7 @@ tcp_bbr_tso_size_check(struct tcp_bbr *bbr, uint32_t c uint32_t old_tso = 0, new_tso; uint32_t maxseg, bytes; uint32_t tls_seg=0; - /* + /* * Google/linux uses the following algorithm to determine * the TSO size based on the b/w of the link (from Neal Cardwell email 9/27/18): * @@ -5791,7 +5791,7 @@ tcp_bbr_tso_size_check(struct tcp_bbr *bbr, uint32_t c * min_tso_segs = 2 * tso_segs = max(tso_segs, min_tso_segs) * - * * Note apply a device specific limit (we apply this in the + * * Note apply a device specific limit (we apply this in the * tcp_m_copym). * Note that before the initial measurement is made google bursts out * a full iwnd just like new-reno/cubic. @@ -5824,7 +5824,7 @@ tcp_bbr_tso_size_check(struct tcp_bbr *bbr, uint32_t c * Note the default per-tcb-divisor is 1000 (same as google). * the goal cross over is 30Mbps however. To recreate googles * algorithm you need to set: - * + * * cross-over = 23,168,000 bps * goal-time = 18000 * per-tcb-max = 2 @@ -5898,7 +5898,7 @@ tcp_bbr_tso_size_check(struct tcp_bbr *bbr, uint32_t c new_tso = maxseg; } else if (bbr->rc_use_google) { int min_tso_segs; - + /* Google considers the gain too */ if (bbr->r_ctl.rc_bbr_hptsi_gain != BBR_UNIT) { bw *= bbr->r_ctl.rc_bbr_hptsi_gain; @@ -5984,7 +5984,7 @@ tcp_bbr_tso_size_check(struct tcp_bbr *bbr, uint32_t c } #ifdef KERN_TLS if (tls_seg) { - /* + /* * Lets move the output size * up to 1 or more TLS record sizes. */ @@ -6116,7 +6116,7 @@ again: rsm->r_first_sent_time = bbr_get_earliest_send_outstanding(bbr, rsm, cts); rsm->r_flight_at_send = ctf_flight_size(bbr->rc_tp, (bbr->r_ctl.rc_sacked + bbr->r_ctl.rc_lost_bytes)); - /* + /* * Here we must also add in this rsm since snd_max * is updated after we return from a new send. */ @@ -6274,7 +6274,7 @@ bbr_make_timestamp_determination(struct tcp_bbr *bbr) * And the peer's time between receiving them by doing: * * peer_delta = bbr->r_ctl.last_inbound_ts - bbr->r_ctl.bbr_ts_check_tstmp - * + * * We want to figure out if the timestamp values are in msec, 10msec or usec. * We also may find that we can't use the timestamps if say we see * that the peer_delta indicates that though we may have taken 10ms to @@ -6290,11 +6290,11 @@ bbr_make_timestamp_determination(struct tcp_bbr *bbr) * put a 1 there. If the value is faster then ours, we will disable the * use of timestamps (though we could revist this later if we find it to be not * just an isolated one or two flows)). - * + * * To detect the batching middle boxes we will come up with our compensation and * if with it in place, we find the peer is drastically off (by some margin) in * the smaller direction, then we will assume the worst case and disable use of timestamps. - * + * */ uint64_t delta, peer_delta, delta_up; @@ -6327,7 +6327,7 @@ bbr_make_timestamp_determination(struct tcp_bbr *bbr) /* Very unlikely, the peer without * compensation shows that it saw * the two sends arrive further apart - * then we saw then in micro-seconds. + * then we saw then in micro-seconds. */ if (peer_delta < (delta + ((delta * (uint64_t)1000)/ (uint64_t)bbr_delta_percent))) { /* well it looks like the peer is a micro-second clock. */ @@ -6352,7 +6352,7 @@ bbr_make_timestamp_determination(struct tcp_bbr *bbr) /* Ok if not usec, what about 10usec (though unlikely)? */ delta_up = (peer_delta * 1000 * 10) / (uint64_t)bbr_delta_percent; if (((peer_delta * 10) + delta_up) >= delta) { - bbr->r_ctl.bbr_peer_tsratio = 10; + bbr->r_ctl.bbr_peer_tsratio = 10; bbr_log_tstmp_validation(bbr, peer_delta, delta); return; } @@ -6401,7 +6401,7 @@ tcp_bbr_xmit_timer_commit(struct tcp_bbr *bbr, struct rtt = bbr->r_ctl.cur_rtt; tsin = bbr->r_ctl.ts_in; if (bbr->rc_prtt_set_ts) { - /* + /* * We are to force feed the rttProp filter due * to an entry into PROBE_RTT. This assures * that the times are sync'd between when we @@ -6413,13 +6413,13 @@ tcp_bbr_xmit_timer_commit(struct tcp_bbr *bbr, struct * value to the newest rtt. */ uint32_t rtt_prop; - + bbr->rc_prtt_set_ts = 0; rtt_prop = get_filter_value_small(&bbr->r_ctl.rc_rttprop); if (rtt > rtt_prop) filter_increase_by_small(&bbr->r_ctl.rc_rttprop, (rtt - rtt_prop), cts); else - apply_filter_min_small(&bbr->r_ctl.rc_rttprop, rtt, cts); + apply_filter_min_small(&bbr->r_ctl.rc_rttprop, rtt, cts); } if (bbr->rc_ack_was_delayed) rtt += bbr->r_ctl.rc_ack_hdwr_delay; @@ -6453,8 +6453,8 @@ tcp_bbr_xmit_timer_commit(struct tcp_bbr *bbr, struct bbr->r_ctl.bbr_ts_check_our_cts = bbr->r_ctl.cur_rtt_send_time; } } else { - /* - * We have to have consecutive acks + /* + * We have to have consecutive acks * reset any "filled" state to none. */ bbr->rc_ts_data_set = 0; @@ -6573,7 +6573,7 @@ bbr_earlier_retran(struct tcpcb *tp, struct tcp_bbr *b */ return; } - + if (rsm->r_flags & BBR_WAS_SACKPASS) { /* * We retransmitted based on a sack and the earlier @@ -6586,7 +6586,7 @@ bbr_earlier_retran(struct tcpcb *tp, struct tcp_bbr *b if (rsm->r_flags & BBR_MARKED_LOST) { bbr->r_ctl.rc_lost -= rsm->r_end - rsm->r_start; bbr->r_ctl.rc_lost_bytes -= rsm->r_end - rsm->r_start; - rsm->r_flags &= ~BBR_MARKED_LOST; + rsm->r_flags &= ~BBR_MARKED_LOST; if (SEQ_GT(bbr->r_ctl.rc_lt_lost, bbr->r_ctl.rc_lost)) /* LT sampling also needs adjustment */ bbr->r_ctl.rc_lt_lost = bbr->r_ctl.rc_lost; @@ -6607,8 +6607,8 @@ bbr_set_reduced_rtt(struct tcp_bbr *bbr, uint32_t cts, if (bbr_can_force_probertt && (TSTMP_GT(cts, bbr->r_ctl.last_in_probertt)) && ((cts - bbr->r_ctl.last_in_probertt) > bbr->r_ctl.rc_probertt_int)) { - /* - * We should enter probe-rtt its been too long + /* + * We should enter probe-rtt its been too long * since we have been there. */ bbr_enter_probe_rtt(bbr, cts, __LINE__); @@ -6666,7 +6666,7 @@ bbr_nf_measurement(struct tcp_bbr *bbr, struct bbr_sen tim = (uint64_t)(bbr->r_ctl.rc_del_time - rsm->r_del_time); else tim = 1; - /* + /* * Now that we have processed the tim (skipping the sample * or possibly updating the time, go ahead and * calculate the cdr. @@ -6681,7 +6681,7 @@ bbr_nf_measurement(struct tcp_bbr *bbr, struct bbr_sen } upper = (bw >> 32) & 0x00000000ffffffff; lower = bw & 0x00000000ffffffff; - /* + /* * If we are using this b/w shove it in now so we * can see in the trace viewer if it gets over-ridden. */ @@ -6783,7 +6783,7 @@ bbr_google_measurement(struct tcp_bbr *bbr, struct bbr tim = (uint64_t)(bbr->r_ctl.rc_del_time - rsm->r_del_time); else tim = 1; - /* + /* * Now that we have processed the tim (skipping the sample * or possibly updating the time, go ahead and * calculate the cdr. @@ -6800,7 +6800,7 @@ bbr_google_measurement(struct tcp_bbr *bbr, struct bbr } upper = (bw >> 32) & 0x00000000ffffffff; lower = bw & 0x00000000ffffffff; - /* + /* * If we are using this b/w shove it in now so we * can see in the trace viewer if it gets over-ridden. */ @@ -6900,7 +6900,7 @@ bbr_update_bbr_info(struct tcp_bbr *bbr, struct bbr_se else bbr->rc_ack_is_cumack = 0; old_rttprop = bbr_get_rtt(bbr, BBR_RTT_PROP); - /* + /* * Note the following code differs to the original * BBR spec. It calls for <= not <. However after a * long discussion in email with Neal, he acknowledged @@ -6932,7 +6932,7 @@ bbr_update_bbr_info(struct tcp_bbr *bbr, struct bbr_se } if ((bbr->rc_use_google == 0) && (match == BBR_RTT_BY_TIMESTAMP)) { - /* + /* * We don't do b/w update with * these since they are not really * reliable. @@ -7137,7 +7137,7 @@ bbr_log_sack_passed(struct tcpcb *tp, continue; } if (nrsm->r_flags & BBR_SACK_PASSED) { - /* + /* * We found one that is already marked * passed, we have been here before and * so all others below this are marked. @@ -7240,7 +7240,7 @@ do_rest_ofb: /* * Need to split this in two pieces the before and after. */ - if (bbr_sack_mergable(rsm, start, end)) + if (bbr_sack_mergable(rsm, start, end)) nrsm = bbr_alloc_full_limit(bbr); else nrsm = bbr_alloc_limit(bbr, BBR_LIMIT_TYPE_SPLIT); @@ -7310,7 +7310,7 @@ do_rest_ofb: goto out; } /* Ok we need to split off this one at the tail */ - if (bbr_sack_mergable(rsm, start, end)) + if (bbr_sack_mergable(rsm, start, end)) nrsm = bbr_alloc_full_limit(bbr); else nrsm = bbr_alloc_limit(bbr, BBR_LIMIT_TYPE_SPLIT); @@ -7360,7 +7360,7 @@ do_rest_ofb: } out: if (rsm && (rsm->r_flags & BBR_ACKED)) { - /* + /* * Now can we merge this newly acked * block with either the previous or * next block? @@ -7462,7 +7462,7 @@ bbr_log_syn(struct tcpcb *tp, struct tcpopt *to) struct tcp_bbr *bbr; struct bbr_sendmap *rsm; uint32_t cts; - + bbr = (struct tcp_bbr *)tp->t_fb_ptr; cts = bbr->r_ctl.rc_rcvtime; rsm = TAILQ_FIRST(&bbr->r_ctl.rc_map); @@ -7526,7 +7526,7 @@ bbr_log_ack(struct tcpcb *tp, struct tcpopt *to, struc acked = th_ack - tp->snd_una; bbr_log_progress_event(bbr, tp, ticks, PROGRESS_UPDATE, __LINE__); bbr->rc_tp->t_acktime = ticks; - } else + } else acked = 0; if (SEQ_LEQ(th_ack, tp->snd_una)) { /* Only sent here for sack processing */ @@ -7601,7 +7601,7 @@ more: /* None here to ack */ goto proc_sack; } - /* + /* * Clear the dup ack counter, it will * either be freed or if there is some * remaining we need to start it at zero. @@ -7686,8 +7686,8 @@ more: } if ((rsm->r_flags & BBR_MARKED_LOST) && ((rsm->r_flags & BBR_ACKED) == 0)) { - /* - * It was marked lost and partly ack'd now + /* + * It was marked lost and partly ack'd now * for the first time. We lower the rc_lost_bytes * and still leave it MARKED. */ @@ -8030,7 +8030,7 @@ nothing_left: } sack_filter_clear(&bbr->r_ctl.bbr_sf, tp->snd_una); bbr_log_ack_clear(bbr, bbr->r_ctl.rc_rcvtime); - /* + /* * We invalidate the last ack here since we * don't want to transfer forward the time * for our sum's calculations. @@ -8092,11 +8092,11 @@ bbr_restart_after_idle(struct tcp_bbr *bbr, uint32_t c * Note that if idle time does not exceed our * threshold, we do nothing continuing the state * transitions we were last walking through. - */ + */ if (idle_time >= bbr_idle_restart_threshold) { if (bbr->rc_use_idle_restart) { bbr->rc_bbr_state = BBR_STATE_IDLE_EXIT; - /* + /* * Set our target using BBR_UNIT, so * we increase at a dramatic rate but * we stop when we get the pipe @@ -8127,7 +8127,7 @@ bbr_exit_persist(struct tcpcb *tp, struct tcp_bbr *bbr bbr->rc_hit_state_1 = 0; tp->t_flags &= ~TF_FORCEDATA; bbr->r_ctl.rc_del_time = cts; - /* + /* * We invalidate the last ack here since we * don't want to transfer forward the time * for our sum's calculations. @@ -8167,7 +8167,7 @@ bbr_exit_persist(struct tcpcb *tp, struct tcp_bbr *bbr bbr->r_ctl.rc_bbr_state_time = cts; if ((bbr->rc_bbr_state == BBR_STATE_PROBE_BW) || (bbr->rc_bbr_state == BBR_STATE_PROBE_RTT)) { - /* + /* * If we are going back to probe-bw * or probe_rtt, we may need to possibly * do a fast restart. @@ -8181,7 +8181,7 @@ bbr_collapsed_window(struct tcp_bbr *bbr) { /* * Now we must walk the - * send map and divide the + * send map and divide the * ones left stranded. These * guys can't cause us to abort * the connection and are really @@ -8192,7 +8192,7 @@ bbr_collapsed_window(struct tcp_bbr *bbr) * the win and acked that data. We would * get into an ack war, the simplier * method then of just pretending we - * did not send those segments something + * did not send those segments something * won't work. */ struct bbr_sendmap *rsm, *nrsm; @@ -8219,8 +8219,8 @@ bbr_collapsed_window(struct tcp_bbr *bbr) /* Nothing to do strange */ return; } - /* - * Now can we split? + /* + * Now can we split? * * We don't want to split if splitting * would generate too many small segments @@ -8271,7 +8271,7 @@ bbr_collapsed_window(struct tcp_bbr *bbr) nrsm->r_in_tmap = 1; } } else { - /* + /* * Split not allowed just start here just * use this guy. */ @@ -8294,7 +8294,7 @@ bbr_un_collapse_window(struct tcp_bbr *bbr) { struct bbr_sendmap *rsm; int cleared = 0; - + TAILQ_FOREACH_REVERSE(rsm, &bbr->r_ctl.rc_map, bbr_head, r_next) { if (rsm->r_flags & BBR_RWND_COLLAPSED) { /* Clear the flag */ @@ -8843,7 +8843,7 @@ bbr_fastack(struct mbuf *m, struct tcphdr *th, struct /* Ok if we reach here, we can process a fast-ack */ nsegs = max(1, m->m_pkthdr.lro_nsegs); sack_changed = bbr_log_ack(tp, to, th, &prev_acked); - /* + /* * We never detect loss in fast ack [we can't * have a sack and can't be in recovery so * we always pass 0 (nothing detected)]. @@ -8959,7 +8959,7 @@ bbr_fastack(struct mbuf *m, struct tcphdr *th, struct } sack_filter_clear(&bbr->r_ctl.bbr_sf, tp->snd_una); bbr_log_ack_clear(bbr, bbr->r_ctl.rc_rcvtime); - /* + /* * We invalidate the last ack here since we * don't want to transfer forward the time * for our sum's calculations. @@ -9060,19 +9060,19 @@ bbr_do_syn_sent(struct mbuf *m, struct tcphdr *th, str tp->t_flags |= TF_ACKNOW; } if (SEQ_GT(th->th_ack, tp->iss)) { - /* + /* * The SYN is acked * handle it specially. */ bbr_log_syn(tp, to); } if (SEQ_GT(th->th_ack, tp->snd_una)) { - /* - * We advance snd_una for the + /* + * We advance snd_una for the * fast open case. If th_ack is - * acknowledging data beyond + * acknowledging data beyond * snd_una we can't just call - * ack-processing since the + * ack-processing since the * data stream in our send-map * will start at snd_una + 1 (one * beyond the SYN). If its just @@ -9133,7 +9133,7 @@ bbr_do_syn_sent(struct mbuf *m, struct tcphdr *th, str if (thflags & TH_ACK) { if ((to->to_flags & TOF_TS) != 0) { uint32_t t, rtt; - + t = tcp_tv_to_mssectick(&bbr->rc_tv); if (TSTMP_GEQ(t, to->to_tsecr)) { rtt = t - to->to_tsecr; @@ -9316,7 +9316,7 @@ bbr_do_syn_recv(struct mbuf *m, struct tcphdr *th, str if (thflags & TH_ACK) bbr_log_syn(tp, to); if (IS_FASTOPEN(tp->t_flags) && tp->t_tfo_pending) { - + tcp_fastopen_decrement_counter(tp->t_tfo_pending); tp->t_tfo_pending = NULL; /* @@ -10260,7 +10260,7 @@ bbr_init(struct tcpcb *tp) bbr->rc_use_ts_limit = 1; else bbr->rc_use_ts_limit = 0; - if (bbr_ts_can_raise) *** DIFF OUTPUT TRUNCATED AT 1000 LINES ***
Want to link to this message? Use this URL: <https://mail-archive.FreeBSD.org/cgi/mid.cgi?202002121240.01CCe6ir034058>