1 /*-
2 * SPDX-License-Identifier: BSD-3-Clause
3 *
4 * Copyright (c) 2001-2007, by Cisco Systems, Inc. All rights reserved.
5 * Copyright (c) 2008-2012, by Randall Stewart. All rights reserved.
6 * Copyright (c) 2008-2012, by Michael Tuexen. All rights reserved.
7 *
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions are met:
10 *
11 * a) Redistributions of source code must retain the above copyright notice,
12 * this list of conditions and the following disclaimer.
13 *
14 * b) Redistributions in binary form must reproduce the above copyright
15 * notice, this list of conditions and the following disclaimer in
16 * the documentation and/or other materials provided with the distribution.
17 *
18 * c) Neither the name of Cisco Systems, Inc. nor the names of its
19 * contributors may be used to endorse or promote products derived
20 * from this software without specific prior written permission.
21 *
22 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
23 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
24 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
25 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
26 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
27 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
28 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
29 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
30 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
31 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
32 * THE POSSIBILITY OF SUCH DAMAGE.
33 */
34
35 #include <sys/cdefs.h>
36 __FBSDID("$FreeBSD: stable/12/sys/netinet/sctp_cc_functions.c 368177 2020-11-30 09:16:51Z tuexen $");
37
38 #include <netinet/sctp_os.h>
39 #include <netinet/sctp_var.h>
40 #include <netinet/sctp_sysctl.h>
41 #include <netinet/sctp_pcb.h>
42 #include <netinet/sctp_header.h>
43 #include <netinet/sctputil.h>
44 #include <netinet/sctp_output.h>
45 #include <netinet/sctp_input.h>
46 #include <netinet/sctp_indata.h>
47 #include <netinet/sctp_uio.h>
48 #include <netinet/sctp_timer.h>
49 #include <netinet/sctp_auth.h>
50 #include <netinet/sctp_asconf.h>
51 #include <netinet/sctp_kdtrace.h>
52
53 #define SHIFT_MPTCP_MULTI_N 40
54 #define SHIFT_MPTCP_MULTI_Z 16
55 #define SHIFT_MPTCP_MULTI 8
56
57 static void
sctp_enforce_cwnd_limit(struct sctp_association * assoc,struct sctp_nets * net)58 sctp_enforce_cwnd_limit(struct sctp_association *assoc, struct sctp_nets *net)
59 {
60 if ((assoc->max_cwnd > 0) &&
61 (net->cwnd > assoc->max_cwnd) &&
62 (net->cwnd > (net->mtu - sizeof(struct sctphdr)))) {
63 net->cwnd = assoc->max_cwnd;
64 if (net->cwnd < (net->mtu - sizeof(struct sctphdr))) {
65 net->cwnd = net->mtu - sizeof(struct sctphdr);
66 }
67 }
68 }
69
70 static void
sctp_set_initial_cc_param(struct sctp_tcb * stcb,struct sctp_nets * net)71 sctp_set_initial_cc_param(struct sctp_tcb *stcb, struct sctp_nets *net)
72 {
73 struct sctp_association *assoc;
74 uint32_t cwnd_in_mtu;
75
76 assoc = &stcb->asoc;
77 cwnd_in_mtu = SCTP_BASE_SYSCTL(sctp_initial_cwnd);
78 if (cwnd_in_mtu == 0) {
79 /* Using 0 means that the value of RFC 4960 is used. */
80 net->cwnd = min((net->mtu * 4), max((2 * net->mtu), SCTP_INITIAL_CWND));
81 } else {
82 /*
83 * We take the minimum of the burst limit and the initial
84 * congestion window.
85 */
86 if ((assoc->max_burst > 0) && (cwnd_in_mtu > assoc->max_burst))
87 cwnd_in_mtu = assoc->max_burst;
88 net->cwnd = (net->mtu - sizeof(struct sctphdr)) * cwnd_in_mtu;
89 }
90 if ((stcb->asoc.sctp_cmt_on_off == SCTP_CMT_RPV1) ||
91 (stcb->asoc.sctp_cmt_on_off == SCTP_CMT_RPV2)) {
92 /* In case of resource pooling initialize appropriately */
93 net->cwnd /= assoc->numnets;
94 if (net->cwnd < (net->mtu - sizeof(struct sctphdr))) {
95 net->cwnd = net->mtu - sizeof(struct sctphdr);
96 }
97 }
98 sctp_enforce_cwnd_limit(assoc, net);
99 net->ssthresh = assoc->peers_rwnd;
100 SDT_PROBE5(sctp, cwnd, net, init,
101 stcb->asoc.my_vtag, ((stcb->sctp_ep->sctp_lport << 16) | (stcb->rport)), net,
102 0, net->cwnd);
103 if (SCTP_BASE_SYSCTL(sctp_logging_level) &
104 (SCTP_CWND_MONITOR_ENABLE | SCTP_CWND_LOGGING_ENABLE)) {
105 sctp_log_cwnd(stcb, net, 0, SCTP_CWND_INITIALIZATION);
106 }
107 }
108
109 static void
sctp_cwnd_update_after_fr(struct sctp_tcb * stcb,struct sctp_association * asoc)110 sctp_cwnd_update_after_fr(struct sctp_tcb *stcb,
111 struct sctp_association *asoc)
112 {
113 struct sctp_nets *net;
114 uint32_t t_ssthresh, t_cwnd;
115 uint64_t t_ucwnd_sbw;
116
117 /* MT FIXME: Don't compute this over and over again */
118 t_ssthresh = 0;
119 t_cwnd = 0;
120 t_ucwnd_sbw = 0;
121 if ((asoc->sctp_cmt_on_off == SCTP_CMT_RPV1) ||
122 (asoc->sctp_cmt_on_off == SCTP_CMT_RPV2)) {
123 TAILQ_FOREACH(net, &asoc->nets, sctp_next) {
124 t_ssthresh += net->ssthresh;
125 t_cwnd += net->cwnd;
126 if (net->lastsa > 0) {
127 t_ucwnd_sbw += (uint64_t)net->cwnd / (uint64_t)net->lastsa;
128 }
129 }
130 if (t_ucwnd_sbw == 0) {
131 t_ucwnd_sbw = 1;
132 }
133 }
134
135 /*-
136 * CMT fast recovery code. Need to debug. ((sctp_cmt_on_off > 0) &&
137 * (net->fast_retran_loss_recovery == 0)))
138 */
139 TAILQ_FOREACH(net, &asoc->nets, sctp_next) {
140 if ((asoc->fast_retran_loss_recovery == 0) ||
141 (asoc->sctp_cmt_on_off > 0)) {
142 /* out of a RFC2582 Fast recovery window? */
143 if (net->net_ack > 0) {
144 /*
145 * per section 7.2.3, are there any
146 * destinations that had a fast retransmit
147 * to them. If so what we need to do is
148 * adjust ssthresh and cwnd.
149 */
150 struct sctp_tmit_chunk *lchk;
151 int old_cwnd = net->cwnd;
152
153 if ((asoc->sctp_cmt_on_off == SCTP_CMT_RPV1) ||
154 (asoc->sctp_cmt_on_off == SCTP_CMT_RPV2)) {
155 if (asoc->sctp_cmt_on_off == SCTP_CMT_RPV1) {
156 net->ssthresh = (uint32_t)(((uint64_t)4 *
157 (uint64_t)net->mtu *
158 (uint64_t)net->ssthresh) /
159 (uint64_t)t_ssthresh);
160
161 }
162 if (asoc->sctp_cmt_on_off == SCTP_CMT_RPV2) {
163 uint32_t srtt;
164
165 srtt = net->lastsa;
166 /*
167 * lastsa>>3; we don't need
168 * to devide ...
169 */
170 if (srtt == 0) {
171 srtt = 1;
172 }
173 /*
174 * Short Version => Equal to
175 * Contel Version MBe
176 */
177 net->ssthresh = (uint32_t)(((uint64_t)4 *
178 (uint64_t)net->mtu *
179 (uint64_t)net->cwnd) /
180 ((uint64_t)srtt *
181 t_ucwnd_sbw));
182 /* INCREASE FACTOR */ ;
183 }
184 if ((net->cwnd > t_cwnd / 2) &&
185 (net->ssthresh < net->cwnd - t_cwnd / 2)) {
186 net->ssthresh = net->cwnd - t_cwnd / 2;
187 }
188 if (net->ssthresh < net->mtu) {
189 net->ssthresh = net->mtu;
190 }
191 } else {
192 net->ssthresh = net->cwnd / 2;
193 if (net->ssthresh < (net->mtu * 2)) {
194 net->ssthresh = 2 * net->mtu;
195 }
196 }
197 net->cwnd = net->ssthresh;
198 sctp_enforce_cwnd_limit(asoc, net);
199 SDT_PROBE5(sctp, cwnd, net, fr,
200 stcb->asoc.my_vtag, ((stcb->sctp_ep->sctp_lport << 16) | (stcb->rport)), net,
201 old_cwnd, net->cwnd);
202 if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_CWND_MONITOR_ENABLE) {
203 sctp_log_cwnd(stcb, net, (net->cwnd - old_cwnd),
204 SCTP_CWND_LOG_FROM_FR);
205 }
206 lchk = TAILQ_FIRST(&asoc->send_queue);
207
208 net->partial_bytes_acked = 0;
209 /* Turn on fast recovery window */
210 asoc->fast_retran_loss_recovery = 1;
211 if (lchk == NULL) {
212 /* Mark end of the window */
213 asoc->fast_recovery_tsn = asoc->sending_seq - 1;
214 } else {
215 asoc->fast_recovery_tsn = lchk->rec.data.tsn - 1;
216 }
217
218 /*
219 * CMT fast recovery -- per destination
220 * recovery variable.
221 */
222 net->fast_retran_loss_recovery = 1;
223
224 if (lchk == NULL) {
225 /* Mark end of the window */
226 net->fast_recovery_tsn = asoc->sending_seq - 1;
227 } else {
228 net->fast_recovery_tsn = lchk->rec.data.tsn - 1;
229 }
230
231 sctp_timer_stop(SCTP_TIMER_TYPE_SEND,
232 stcb->sctp_ep, stcb, net,
233 SCTP_FROM_SCTP_CC_FUNCTIONS + SCTP_LOC_1);
234 sctp_timer_start(SCTP_TIMER_TYPE_SEND,
235 stcb->sctp_ep, stcb, net);
236 }
237 } else if (net->net_ack > 0) {
238 /*
239 * Mark a peg that we WOULD have done a cwnd
240 * reduction but RFC2582 prevented this action.
241 */
242 SCTP_STAT_INCR(sctps_fastretransinrtt);
243 }
244 }
245 }
246
247 /* Defines for instantaneous bw decisions */
248 #define SCTP_INST_LOOSING 1 /* Losing to other flows */
249 #define SCTP_INST_NEUTRAL 2 /* Neutral, no indication */
250 #define SCTP_INST_GAINING 3 /* Gaining, step down possible */
251
252
253 static int
cc_bw_same(struct sctp_tcb * stcb,struct sctp_nets * net,uint64_t nbw,uint64_t rtt_offset,uint64_t vtag,uint8_t inst_ind)254 cc_bw_same(struct sctp_tcb *stcb, struct sctp_nets *net, uint64_t nbw,
255 uint64_t rtt_offset, uint64_t vtag, uint8_t inst_ind)
256 {
257 uint64_t oth, probepoint;
258
259 probepoint = (((uint64_t)net->cwnd) << 32);
260 if (net->rtt > net->cc_mod.rtcc.lbw_rtt + rtt_offset) {
261 /*
262 * rtt increased we don't update bw.. so we don't update the
263 * rtt either.
264 */
265 /* Probe point 5 */
266 probepoint |= ((5 << 16) | 1);
267 SDT_PROBE5(sctp, cwnd, net, rttvar,
268 vtag,
269 ((net->cc_mod.rtcc.lbw << 32) | nbw),
270 ((net->cc_mod.rtcc.lbw_rtt << 32) | net->rtt),
271 net->flight_size,
272 probepoint);
273 if ((net->cc_mod.rtcc.steady_step) && (inst_ind != SCTP_INST_LOOSING)) {
274 if (net->cc_mod.rtcc.last_step_state == 5)
275 net->cc_mod.rtcc.step_cnt++;
276 else
277 net->cc_mod.rtcc.step_cnt = 1;
278 net->cc_mod.rtcc.last_step_state = 5;
279 if ((net->cc_mod.rtcc.step_cnt == net->cc_mod.rtcc.steady_step) ||
280 ((net->cc_mod.rtcc.step_cnt > net->cc_mod.rtcc.steady_step) &&
281 ((net->cc_mod.rtcc.step_cnt % net->cc_mod.rtcc.steady_step) == 0))) {
282 /* Try a step down */
283 oth = net->cc_mod.rtcc.vol_reduce;
284 oth <<= 16;
285 oth |= net->cc_mod.rtcc.step_cnt;
286 oth <<= 16;
287 oth |= net->cc_mod.rtcc.last_step_state;
288 SDT_PROBE5(sctp, cwnd, net, rttstep,
289 vtag,
290 ((net->cc_mod.rtcc.lbw << 32) | nbw),
291 ((net->cc_mod.rtcc.lbw_rtt << 32) | net->rtt),
292 oth,
293 probepoint);
294 if (net->cwnd > (4 * net->mtu)) {
295 net->cwnd -= net->mtu;
296 net->cc_mod.rtcc.vol_reduce++;
297 } else {
298 net->cc_mod.rtcc.step_cnt = 0;
299 }
300 }
301 }
302 return (1);
303 }
304 if (net->rtt < net->cc_mod.rtcc.lbw_rtt - rtt_offset) {
305 /*
306 * rtt decreased, there could be more room. we update both
307 * the bw and the rtt here to lock this in as a good step
308 * down.
309 */
310 /* Probe point 6 */
311 probepoint |= ((6 << 16) | 0);
312 SDT_PROBE5(sctp, cwnd, net, rttvar,
313 vtag,
314 ((net->cc_mod.rtcc.lbw << 32) | nbw),
315 ((net->cc_mod.rtcc.lbw_rtt << 32) | net->rtt),
316 net->flight_size,
317 probepoint);
318 if (net->cc_mod.rtcc.steady_step) {
319 oth = net->cc_mod.rtcc.vol_reduce;
320 oth <<= 16;
321 oth |= net->cc_mod.rtcc.step_cnt;
322 oth <<= 16;
323 oth |= net->cc_mod.rtcc.last_step_state;
324 SDT_PROBE5(sctp, cwnd, net, rttstep,
325 vtag,
326 ((net->cc_mod.rtcc.lbw << 32) | nbw),
327 ((net->cc_mod.rtcc.lbw_rtt << 32) | net->rtt),
328 oth,
329 probepoint);
330 if ((net->cc_mod.rtcc.last_step_state == 5) &&
331 (net->cc_mod.rtcc.step_cnt > net->cc_mod.rtcc.steady_step)) {
332 /* Step down worked */
333 net->cc_mod.rtcc.step_cnt = 0;
334 return (1);
335 } else {
336 net->cc_mod.rtcc.last_step_state = 6;
337 net->cc_mod.rtcc.step_cnt = 0;
338 }
339 }
340 net->cc_mod.rtcc.lbw = nbw;
341 net->cc_mod.rtcc.lbw_rtt = net->rtt;
342 net->cc_mod.rtcc.cwnd_at_bw_set = net->cwnd;
343 if (inst_ind == SCTP_INST_GAINING)
344 return (1);
345 else if (inst_ind == SCTP_INST_NEUTRAL)
346 return (1);
347 else
348 return (0);
349 }
350 /*
351 * Ok bw and rtt remained the same .. no update to any
352 */
353 /* Probe point 7 */
354 probepoint |= ((7 << 16) | net->cc_mod.rtcc.ret_from_eq);
355 SDT_PROBE5(sctp, cwnd, net, rttvar,
356 vtag,
357 ((net->cc_mod.rtcc.lbw << 32) | nbw),
358 ((net->cc_mod.rtcc.lbw_rtt << 32) | net->rtt),
359 net->flight_size,
360 probepoint);
361 if ((net->cc_mod.rtcc.steady_step) && (inst_ind != SCTP_INST_LOOSING)) {
362 if (net->cc_mod.rtcc.last_step_state == 5)
363 net->cc_mod.rtcc.step_cnt++;
364 else
365 net->cc_mod.rtcc.step_cnt = 1;
366 net->cc_mod.rtcc.last_step_state = 5;
367 if ((net->cc_mod.rtcc.step_cnt == net->cc_mod.rtcc.steady_step) ||
368 ((net->cc_mod.rtcc.step_cnt > net->cc_mod.rtcc.steady_step) &&
369 ((net->cc_mod.rtcc.step_cnt % net->cc_mod.rtcc.steady_step) == 0))) {
370 /* Try a step down */
371 if (net->cwnd > (4 * net->mtu)) {
372 net->cwnd -= net->mtu;
373 net->cc_mod.rtcc.vol_reduce++;
374 return (1);
375 } else {
376 net->cc_mod.rtcc.step_cnt = 0;
377 }
378 }
379 }
380 if (inst_ind == SCTP_INST_GAINING)
381 return (1);
382 else if (inst_ind == SCTP_INST_NEUTRAL)
383 return (1);
384 else
385 return ((int)net->cc_mod.rtcc.ret_from_eq);
386 }
387
388 static int
cc_bw_decrease(struct sctp_tcb * stcb,struct sctp_nets * net,uint64_t nbw,uint64_t rtt_offset,uint64_t vtag,uint8_t inst_ind)389 cc_bw_decrease(struct sctp_tcb *stcb, struct sctp_nets *net, uint64_t nbw, uint64_t rtt_offset,
390 uint64_t vtag, uint8_t inst_ind)
391 {
392 uint64_t oth, probepoint;
393
394 /* Bandwidth decreased. */
395 probepoint = (((uint64_t)net->cwnd) << 32);
396 if (net->rtt > net->cc_mod.rtcc.lbw_rtt + rtt_offset) {
397 /* rtt increased */
398 /* Did we add more */
399 if ((net->cwnd > net->cc_mod.rtcc.cwnd_at_bw_set) &&
400 (inst_ind != SCTP_INST_LOOSING)) {
401 /* We caused it maybe.. back off? */
402 /* PROBE POINT 1 */
403 probepoint |= ((1 << 16) | 1);
404 SDT_PROBE5(sctp, cwnd, net, rttvar,
405 vtag,
406 ((net->cc_mod.rtcc.lbw << 32) | nbw),
407 ((net->cc_mod.rtcc.lbw_rtt << 32) | net->rtt),
408 net->flight_size,
409 probepoint);
410 if (net->cc_mod.rtcc.ret_from_eq) {
411 /*
412 * Switch over to CA if we are less
413 * aggressive
414 */
415 net->ssthresh = net->cwnd - 1;
416 net->partial_bytes_acked = 0;
417 }
418 return (1);
419 }
420 /* Probe point 2 */
421 probepoint |= ((2 << 16) | 0);
422 SDT_PROBE5(sctp, cwnd, net, rttvar,
423 vtag,
424 ((net->cc_mod.rtcc.lbw << 32) | nbw),
425 ((net->cc_mod.rtcc.lbw_rtt << 32) | net->rtt),
426 net->flight_size,
427 probepoint);
428 /* Someone else - fight for more? */
429 if (net->cc_mod.rtcc.steady_step) {
430 oth = net->cc_mod.rtcc.vol_reduce;
431 oth <<= 16;
432 oth |= net->cc_mod.rtcc.step_cnt;
433 oth <<= 16;
434 oth |= net->cc_mod.rtcc.last_step_state;
435 SDT_PROBE5(sctp, cwnd, net, rttstep,
436 vtag,
437 ((net->cc_mod.rtcc.lbw << 32) | nbw),
438 ((net->cc_mod.rtcc.lbw_rtt << 32) | net->rtt),
439 oth,
440 probepoint);
441 /*
442 * Did we voluntarily give up some? if so take one
443 * back please
444 */
445 if ((net->cc_mod.rtcc.vol_reduce) &&
446 (inst_ind != SCTP_INST_GAINING)) {
447 net->cwnd += net->mtu;
448 sctp_enforce_cwnd_limit(&stcb->asoc, net);
449 net->cc_mod.rtcc.vol_reduce--;
450 }
451 net->cc_mod.rtcc.last_step_state = 2;
452 net->cc_mod.rtcc.step_cnt = 0;
453 }
454 goto out_decision;
455 } else if (net->rtt < net->cc_mod.rtcc.lbw_rtt - rtt_offset) {
456 /* bw & rtt decreased */
457 /* Probe point 3 */
458 probepoint |= ((3 << 16) | 0);
459 SDT_PROBE5(sctp, cwnd, net, rttvar,
460 vtag,
461 ((net->cc_mod.rtcc.lbw << 32) | nbw),
462 ((net->cc_mod.rtcc.lbw_rtt << 32) | net->rtt),
463 net->flight_size,
464 probepoint);
465 if (net->cc_mod.rtcc.steady_step) {
466 oth = net->cc_mod.rtcc.vol_reduce;
467 oth <<= 16;
468 oth |= net->cc_mod.rtcc.step_cnt;
469 oth <<= 16;
470 oth |= net->cc_mod.rtcc.last_step_state;
471 SDT_PROBE5(sctp, cwnd, net, rttstep,
472 vtag,
473 ((net->cc_mod.rtcc.lbw << 32) | nbw),
474 ((net->cc_mod.rtcc.lbw_rtt << 32) | net->rtt),
475 oth,
476 probepoint);
477 if ((net->cc_mod.rtcc.vol_reduce) &&
478 (inst_ind != SCTP_INST_GAINING)) {
479 net->cwnd += net->mtu;
480 sctp_enforce_cwnd_limit(&stcb->asoc, net);
481 net->cc_mod.rtcc.vol_reduce--;
482 }
483 net->cc_mod.rtcc.last_step_state = 3;
484 net->cc_mod.rtcc.step_cnt = 0;
485 }
486 goto out_decision;
487 }
488 /* The bw decreased but rtt stayed the same */
489 /* Probe point 4 */
490 probepoint |= ((4 << 16) | 0);
491 SDT_PROBE5(sctp, cwnd, net, rttvar,
492 vtag,
493 ((net->cc_mod.rtcc.lbw << 32) | nbw),
494 ((net->cc_mod.rtcc.lbw_rtt << 32) | net->rtt),
495 net->flight_size,
496 probepoint);
497 if (net->cc_mod.rtcc.steady_step) {
498 oth = net->cc_mod.rtcc.vol_reduce;
499 oth <<= 16;
500 oth |= net->cc_mod.rtcc.step_cnt;
501 oth <<= 16;
502 oth |= net->cc_mod.rtcc.last_step_state;
503 SDT_PROBE5(sctp, cwnd, net, rttstep,
504 vtag,
505 ((net->cc_mod.rtcc.lbw << 32) | nbw),
506 ((net->cc_mod.rtcc.lbw_rtt << 32) | net->rtt),
507 oth,
508 probepoint);
509 if ((net->cc_mod.rtcc.vol_reduce) &&
510 (inst_ind != SCTP_INST_GAINING)) {
511 net->cwnd += net->mtu;
512 sctp_enforce_cwnd_limit(&stcb->asoc, net);
513 net->cc_mod.rtcc.vol_reduce--;
514 }
515 net->cc_mod.rtcc.last_step_state = 4;
516 net->cc_mod.rtcc.step_cnt = 0;
517 }
518 out_decision:
519 net->cc_mod.rtcc.lbw = nbw;
520 net->cc_mod.rtcc.lbw_rtt = net->rtt;
521 net->cc_mod.rtcc.cwnd_at_bw_set = net->cwnd;
522 if (inst_ind == SCTP_INST_GAINING) {
523 return (1);
524 } else {
525 return (0);
526 }
527 }
528
529 static int
cc_bw_increase(struct sctp_tcb * stcb,struct sctp_nets * net,uint64_t nbw,uint64_t vtag)530 cc_bw_increase(struct sctp_tcb *stcb, struct sctp_nets *net, uint64_t nbw, uint64_t vtag)
531 {
532 uint64_t oth, probepoint;
533
534 /*
535 * BW increased, so update and return 0, since all actions in our
536 * table say to do the normal CC update. Note that we pay no
537 * attention to the inst_ind since our overall sum is increasing.
538 */
539 /* PROBE POINT 0 */
540 probepoint = (((uint64_t)net->cwnd) << 32);
541 SDT_PROBE5(sctp, cwnd, net, rttvar,
542 vtag,
543 ((net->cc_mod.rtcc.lbw << 32) | nbw),
544 ((net->cc_mod.rtcc.lbw_rtt << 32) | net->rtt),
545 net->flight_size,
546 probepoint);
547 if (net->cc_mod.rtcc.steady_step) {
548 oth = net->cc_mod.rtcc.vol_reduce;
549 oth <<= 16;
550 oth |= net->cc_mod.rtcc.step_cnt;
551 oth <<= 16;
552 oth |= net->cc_mod.rtcc.last_step_state;
553 SDT_PROBE5(sctp, cwnd, net, rttstep,
554 vtag,
555 ((net->cc_mod.rtcc.lbw << 32) | nbw),
556 ((net->cc_mod.rtcc.lbw_rtt << 32) | net->rtt),
557 oth,
558 probepoint);
559 net->cc_mod.rtcc.last_step_state = 0;
560 net->cc_mod.rtcc.step_cnt = 0;
561 net->cc_mod.rtcc.vol_reduce = 0;
562 }
563 net->cc_mod.rtcc.lbw = nbw;
564 net->cc_mod.rtcc.lbw_rtt = net->rtt;
565 net->cc_mod.rtcc.cwnd_at_bw_set = net->cwnd;
566 return (0);
567 }
568
569 /* RTCC Algorithm to limit growth of cwnd, return
570 * true if you want to NOT allow cwnd growth
571 */
572 static int
cc_bw_limit(struct sctp_tcb * stcb,struct sctp_nets * net,uint64_t nbw)573 cc_bw_limit(struct sctp_tcb *stcb, struct sctp_nets *net, uint64_t nbw)
574 {
575 uint64_t bw_offset, rtt_offset;
576 uint64_t probepoint, rtt, vtag;
577 uint64_t bytes_for_this_rtt, inst_bw;
578 uint64_t div, inst_off;
579 int bw_shift;
580 uint8_t inst_ind;
581 int ret;
582
583 /*-
584 * Here we need to see if we want
585 * to limit cwnd growth due to increase
586 * in overall rtt but no increase in bw.
587 * We use the following table to figure
588 * out what we should do. When we return
589 * 0, cc update goes on as planned. If we
590 * return 1, then no cc update happens and cwnd
591 * stays where it is at.
592 * ----------------------------------
593 * BW | RTT | Action
594 * *********************************
595 * INC | INC | return 0
596 * ----------------------------------
597 * INC | SAME | return 0
598 * ----------------------------------
599 * INC | DECR | return 0
600 * ----------------------------------
601 * SAME | INC | return 1
602 * ----------------------------------
603 * SAME | SAME | return 1
604 * ----------------------------------
605 * SAME | DECR | return 0
606 * ----------------------------------
607 * DECR | INC | return 0 or 1 based on if we caused.
608 * ----------------------------------
609 * DECR | SAME | return 0
610 * ----------------------------------
611 * DECR | DECR | return 0
612 * ----------------------------------
613 *
614 * We are a bit fuzz on what an increase or
615 * decrease is. For BW it is the same if
616 * it did not change within 1/64th. For
617 * RTT it stayed the same if it did not
618 * change within 1/32nd
619 */
620 bw_shift = SCTP_BASE_SYSCTL(sctp_rttvar_bw);
621 rtt = stcb->asoc.my_vtag;
622 vtag = (rtt << 32) | (((uint32_t)(stcb->sctp_ep->sctp_lport)) << 16) | (stcb->rport);
623 probepoint = (((uint64_t)net->cwnd) << 32);
624 rtt = net->rtt;
625 if (net->cc_mod.rtcc.rtt_set_this_sack) {
626 net->cc_mod.rtcc.rtt_set_this_sack = 0;
627 bytes_for_this_rtt = net->cc_mod.rtcc.bw_bytes - net->cc_mod.rtcc.bw_bytes_at_last_rttc;
628 net->cc_mod.rtcc.bw_bytes_at_last_rttc = net->cc_mod.rtcc.bw_bytes;
629 if (net->rtt) {
630 div = net->rtt / 1000;
631 if (div) {
632 inst_bw = bytes_for_this_rtt / div;
633 inst_off = inst_bw >> bw_shift;
634 if (inst_bw > nbw)
635 inst_ind = SCTP_INST_GAINING;
636 else if ((inst_bw + inst_off) < nbw)
637 inst_ind = SCTP_INST_LOOSING;
638 else
639 inst_ind = SCTP_INST_NEUTRAL;
640 probepoint |= ((0xb << 16) | inst_ind);
641 } else {
642 inst_ind = net->cc_mod.rtcc.last_inst_ind;
643 inst_bw = bytes_for_this_rtt / (uint64_t)(net->rtt);
644 /* Can't determine do not change */
645 probepoint |= ((0xc << 16) | inst_ind);
646 }
647 } else {
648 inst_ind = net->cc_mod.rtcc.last_inst_ind;
649 inst_bw = bytes_for_this_rtt;
650 /* Can't determine do not change */
651 probepoint |= ((0xd << 16) | inst_ind);
652 }
653 SDT_PROBE5(sctp, cwnd, net, rttvar,
654 vtag,
655 ((nbw << 32) | inst_bw),
656 ((net->cc_mod.rtcc.lbw_rtt << 32) | rtt),
657 net->flight_size,
658 probepoint);
659 } else {
660 /* No rtt measurement, use last one */
661 inst_ind = net->cc_mod.rtcc.last_inst_ind;
662 }
663 bw_offset = net->cc_mod.rtcc.lbw >> bw_shift;
664 if (nbw > net->cc_mod.rtcc.lbw + bw_offset) {
665 ret = cc_bw_increase(stcb, net, nbw, vtag);
666 goto out;
667 }
668 rtt_offset = net->cc_mod.rtcc.lbw_rtt >> SCTP_BASE_SYSCTL(sctp_rttvar_rtt);
669 if (nbw < net->cc_mod.rtcc.lbw - bw_offset) {
670 ret = cc_bw_decrease(stcb, net, nbw, rtt_offset, vtag, inst_ind);
671 goto out;
672 }
673 /*
674 * If we reach here then we are in a situation where the bw stayed
675 * the same.
676 */
677 ret = cc_bw_same(stcb, net, nbw, rtt_offset, vtag, inst_ind);
678 out:
679 net->cc_mod.rtcc.last_inst_ind = inst_ind;
680 return (ret);
681 }
682
683 static void
sctp_cwnd_update_after_sack_common(struct sctp_tcb * stcb,struct sctp_association * asoc,int accum_moved,int reneged_all SCTP_UNUSED,int will_exit,int use_rtcc)684 sctp_cwnd_update_after_sack_common(struct sctp_tcb *stcb,
685 struct sctp_association *asoc,
686 int accum_moved, int reneged_all SCTP_UNUSED, int will_exit, int use_rtcc)
687 {
688 struct sctp_nets *net;
689 int old_cwnd;
690 uint32_t t_ssthresh, t_cwnd, incr;
691 uint64_t t_ucwnd_sbw;
692 uint64_t t_path_mptcp;
693 uint64_t mptcp_like_alpha;
694 uint32_t srtt;
695 uint64_t max_path;
696
697 /* MT FIXME: Don't compute this over and over again */
698 t_ssthresh = 0;
699 t_cwnd = 0;
700 t_ucwnd_sbw = 0;
701 t_path_mptcp = 0;
702 mptcp_like_alpha = 1;
703 if ((stcb->asoc.sctp_cmt_on_off == SCTP_CMT_RPV1) ||
704 (stcb->asoc.sctp_cmt_on_off == SCTP_CMT_RPV2) ||
705 (stcb->asoc.sctp_cmt_on_off == SCTP_CMT_MPTCP)) {
706 max_path = 0;
707 TAILQ_FOREACH(net, &stcb->asoc.nets, sctp_next) {
708 t_ssthresh += net->ssthresh;
709 t_cwnd += net->cwnd;
710 /* lastsa>>3; we don't need to devide ... */
711 srtt = net->lastsa;
712 if (srtt > 0) {
713 uint64_t tmp;
714
715 t_ucwnd_sbw += (uint64_t)net->cwnd / (uint64_t)srtt;
716 t_path_mptcp += (((uint64_t)net->cwnd) << SHIFT_MPTCP_MULTI_Z) /
717 (((uint64_t)net->mtu) * (uint64_t)srtt);
718 tmp = (((uint64_t)net->cwnd) << SHIFT_MPTCP_MULTI_N) /
719 ((uint64_t)net->mtu * (uint64_t)(srtt * srtt));
720 if (tmp > max_path) {
721 max_path = tmp;
722 }
723 }
724 }
725 if (t_path_mptcp > 0) {
726 mptcp_like_alpha = max_path / (t_path_mptcp * t_path_mptcp);
727 } else {
728 mptcp_like_alpha = 1;
729 }
730 }
731 if (t_ssthresh == 0) {
732 t_ssthresh = 1;
733 }
734 if (t_ucwnd_sbw == 0) {
735 t_ucwnd_sbw = 1;
736 }
737 /******************************/
738 /* update cwnd and Early FR */
739 /******************************/
740 TAILQ_FOREACH(net, &asoc->nets, sctp_next) {
741
742 #ifdef JANA_CMT_FAST_RECOVERY
743 /*
744 * CMT fast recovery code. Need to debug.
745 */
746 if (net->fast_retran_loss_recovery && net->new_pseudo_cumack) {
747 if (SCTP_TSN_GE(asoc->last_acked_seq, net->fast_recovery_tsn) ||
748 SCTP_TSN_GE(net->pseudo_cumack, net->fast_recovery_tsn)) {
749 net->will_exit_fast_recovery = 1;
750 }
751 }
752 #endif
753 /* if nothing was acked on this destination skip it */
754 if (net->net_ack == 0) {
755 if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_CWND_LOGGING_ENABLE) {
756 sctp_log_cwnd(stcb, net, 0, SCTP_CWND_LOG_FROM_SACK);
757 }
758 continue;
759 }
760 #ifdef JANA_CMT_FAST_RECOVERY
761 /*
762 * CMT fast recovery code
763 */
764 /*
765 * if (sctp_cmt_on_off > 0 && net->fast_retran_loss_recovery
766 * && net->will_exit_fast_recovery == 0) { @@@ Do something
767 * } else if (sctp_cmt_on_off == 0 &&
768 * asoc->fast_retran_loss_recovery && will_exit == 0) {
769 */
770 #endif
771
772 if (asoc->fast_retran_loss_recovery &&
773 (will_exit == 0) &&
774 (asoc->sctp_cmt_on_off == 0)) {
775 /*
776 * If we are in loss recovery we skip any cwnd
777 * update
778 */
779 return;
780 }
781 /*
782 * Did any measurements go on for this network?
783 */
784 if (use_rtcc && (net->cc_mod.rtcc.tls_needs_set > 0)) {
785 uint64_t nbw;
786
787 /*
788 * At this point our bw_bytes has been updated by
789 * incoming sack information.
790 *
791 * But our bw may not yet be set.
792 *
793 */
794 if ((net->cc_mod.rtcc.new_tot_time / 1000) > 0) {
795 nbw = net->cc_mod.rtcc.bw_bytes / (net->cc_mod.rtcc.new_tot_time / 1000);
796 } else {
797 nbw = net->cc_mod.rtcc.bw_bytes;
798 }
799 if (net->cc_mod.rtcc.lbw) {
800 if (cc_bw_limit(stcb, net, nbw)) {
801 /* Hold here, no update */
802 continue;
803 }
804 } else {
805 uint64_t vtag, probepoint;
806
807 probepoint = (((uint64_t)net->cwnd) << 32);
808 probepoint |= ((0xa << 16) | 0);
809 vtag = (net->rtt << 32) |
810 (((uint32_t)(stcb->sctp_ep->sctp_lport)) << 16) |
811 (stcb->rport);
812
813 SDT_PROBE5(sctp, cwnd, net, rttvar,
814 vtag,
815 nbw,
816 ((net->cc_mod.rtcc.lbw_rtt << 32) | net->rtt),
817 net->flight_size,
818 probepoint);
819 net->cc_mod.rtcc.lbw = nbw;
820 net->cc_mod.rtcc.lbw_rtt = net->rtt;
821 if (net->cc_mod.rtcc.rtt_set_this_sack) {
822 net->cc_mod.rtcc.rtt_set_this_sack = 0;
823 net->cc_mod.rtcc.bw_bytes_at_last_rttc = net->cc_mod.rtcc.bw_bytes;
824 }
825 }
826 }
827 /*
828 * CMT: CUC algorithm. Update cwnd if pseudo-cumack has
829 * moved.
830 */
831 if (accum_moved ||
832 ((asoc->sctp_cmt_on_off > 0) && net->new_pseudo_cumack)) {
833 /* If the cumulative ack moved we can proceed */
834 if (net->cwnd <= net->ssthresh) {
835 /* We are in slow start */
836 if (net->flight_size + net->net_ack >= net->cwnd) {
837 uint32_t limit;
838
839 old_cwnd = net->cwnd;
840 switch (asoc->sctp_cmt_on_off) {
841 case SCTP_CMT_RPV1:
842 limit = (uint32_t)(((uint64_t)net->mtu *
843 (uint64_t)SCTP_BASE_SYSCTL(sctp_L2_abc_variable) *
844 (uint64_t)net->ssthresh) /
845 (uint64_t)t_ssthresh);
846 incr = (uint32_t)(((uint64_t)net->net_ack *
847 (uint64_t)net->ssthresh) /
848 (uint64_t)t_ssthresh);
849 if (incr > limit) {
850 incr = limit;
851 }
852 if (incr == 0) {
853 incr = 1;
854 }
855 break;
856 case SCTP_CMT_RPV2:
857 /*
858 * lastsa>>3; we don't need
859 * to divide ...
860 */
861 srtt = net->lastsa;
862 if (srtt == 0) {
863 srtt = 1;
864 }
865 limit = (uint32_t)(((uint64_t)net->mtu *
866 (uint64_t)SCTP_BASE_SYSCTL(sctp_L2_abc_variable) *
867 (uint64_t)net->cwnd) /
868 ((uint64_t)srtt * t_ucwnd_sbw));
869 /* INCREASE FACTOR */
870 incr = (uint32_t)(((uint64_t)net->net_ack *
871 (uint64_t)net->cwnd) /
872 ((uint64_t)srtt * t_ucwnd_sbw));
873 /* INCREASE FACTOR */
874 if (incr > limit) {
875 incr = limit;
876 }
877 if (incr == 0) {
878 incr = 1;
879 }
880 break;
881 case SCTP_CMT_MPTCP:
882 limit = (uint32_t)(((uint64_t)net->mtu *
883 mptcp_like_alpha *
884 (uint64_t)SCTP_BASE_SYSCTL(sctp_L2_abc_variable)) >>
885 SHIFT_MPTCP_MULTI);
886 incr = (uint32_t)(((uint64_t)net->net_ack *
887 mptcp_like_alpha) >>
888 SHIFT_MPTCP_MULTI);
889 if (incr > limit) {
890 incr = limit;
891 }
892 if (incr > net->net_ack) {
893 incr = net->net_ack;
894 }
895 if (incr > net->mtu) {
896 incr = net->mtu;
897 }
898 break;
899 default:
900 incr = net->net_ack;
901 if (incr > net->mtu * SCTP_BASE_SYSCTL(sctp_L2_abc_variable)) {
902 incr = net->mtu * SCTP_BASE_SYSCTL(sctp_L2_abc_variable);
903 }
904 break;
905 }
906 net->cwnd += incr;
907 sctp_enforce_cwnd_limit(asoc, net);
908 if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_CWND_MONITOR_ENABLE) {
909 sctp_log_cwnd(stcb, net, incr,
910 SCTP_CWND_LOG_FROM_SS);
911 }
912 SDT_PROBE5(sctp, cwnd, net, ack,
913 stcb->asoc.my_vtag,
914 ((stcb->sctp_ep->sctp_lport << 16) | (stcb->rport)),
915 net,
916 old_cwnd, net->cwnd);
917 } else {
918 if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_CWND_LOGGING_ENABLE) {
919 sctp_log_cwnd(stcb, net, net->net_ack,
920 SCTP_CWND_LOG_NOADV_SS);
921 }
922 }
923 } else {
924 /* We are in congestion avoidance */
925 /*
926 * Add to pba
927 */
928 net->partial_bytes_acked += net->net_ack;
929
930 if ((net->flight_size + net->net_ack >= net->cwnd) &&
931 (net->partial_bytes_acked >= net->cwnd)) {
932 net->partial_bytes_acked -= net->cwnd;
933 old_cwnd = net->cwnd;
934 switch (asoc->sctp_cmt_on_off) {
935 case SCTP_CMT_RPV1:
936 incr = (uint32_t)(((uint64_t)net->mtu *
937 (uint64_t)net->ssthresh) /
938 (uint64_t)t_ssthresh);
939 if (incr == 0) {
940 incr = 1;
941 }
942 break;
943 case SCTP_CMT_RPV2:
944 /*
945 * lastsa>>3; we don't need
946 * to divide ...
947 */
948 srtt = net->lastsa;
949 if (srtt == 0) {
950 srtt = 1;
951 }
952 incr = (uint32_t)((uint64_t)net->mtu *
953 (uint64_t)net->cwnd /
954 ((uint64_t)srtt *
955 t_ucwnd_sbw));
956 /* INCREASE FACTOR */
957 if (incr == 0) {
958 incr = 1;
959 }
960 break;
961 case SCTP_CMT_MPTCP:
962 incr = (uint32_t)((mptcp_like_alpha *
963 (uint64_t)net->cwnd) >>
964 SHIFT_MPTCP_MULTI);
965 if (incr > net->mtu) {
966 incr = net->mtu;
967 }
968 break;
969 default:
970 incr = net->mtu;
971 break;
972 }
973 net->cwnd += incr;
974 sctp_enforce_cwnd_limit(asoc, net);
975 SDT_PROBE5(sctp, cwnd, net, ack,
976 stcb->asoc.my_vtag,
977 ((stcb->sctp_ep->sctp_lport << 16) | (stcb->rport)),
978 net,
979 old_cwnd, net->cwnd);
980 if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_CWND_MONITOR_ENABLE) {
981 sctp_log_cwnd(stcb, net, net->mtu,
982 SCTP_CWND_LOG_FROM_CA);
983 }
984 } else {
985 if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_CWND_LOGGING_ENABLE) {
986 sctp_log_cwnd(stcb, net, net->net_ack,
987 SCTP_CWND_LOG_NOADV_CA);
988 }
989 }
990 }
991 } else {
992 if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_CWND_LOGGING_ENABLE) {
993 sctp_log_cwnd(stcb, net, net->mtu,
994 SCTP_CWND_LOG_NO_CUMACK);
995 }
996 }
997 }
998 }
999
1000 static void
sctp_cwnd_update_exit_pf_common(struct sctp_tcb * stcb,struct sctp_nets * net)1001 sctp_cwnd_update_exit_pf_common(struct sctp_tcb *stcb, struct sctp_nets *net)
1002 {
1003 int old_cwnd;
1004
1005 old_cwnd = net->cwnd;
1006 net->cwnd = net->mtu;
1007 SDT_PROBE5(sctp, cwnd, net, ack,
1008 stcb->asoc.my_vtag, ((stcb->sctp_ep->sctp_lport << 16) | (stcb->rport)), net,
1009 old_cwnd, net->cwnd);
1010 SCTPDBG(SCTP_DEBUG_INDATA1, "Destination %p moved from PF to reachable with cwnd %d.\n",
1011 (void *)net, net->cwnd);
1012 }
1013
1014
1015 static void
sctp_cwnd_update_after_timeout(struct sctp_tcb * stcb,struct sctp_nets * net)1016 sctp_cwnd_update_after_timeout(struct sctp_tcb *stcb, struct sctp_nets *net)
1017 {
1018 int old_cwnd = net->cwnd;
1019 uint32_t t_ssthresh, t_cwnd;
1020 uint64_t t_ucwnd_sbw;
1021
1022 /* MT FIXME: Don't compute this over and over again */
1023 t_ssthresh = 0;
1024 t_cwnd = 0;
1025 if ((stcb->asoc.sctp_cmt_on_off == SCTP_CMT_RPV1) ||
1026 (stcb->asoc.sctp_cmt_on_off == SCTP_CMT_RPV2)) {
1027 struct sctp_nets *lnet;
1028 uint32_t srtt;
1029
1030 t_ucwnd_sbw = 0;
1031 TAILQ_FOREACH(lnet, &stcb->asoc.nets, sctp_next) {
1032 t_ssthresh += lnet->ssthresh;
1033 t_cwnd += lnet->cwnd;
1034 srtt = lnet->lastsa;
1035 /* lastsa>>3; we don't need to divide ... */
1036 if (srtt > 0) {
1037 t_ucwnd_sbw += (uint64_t)lnet->cwnd / (uint64_t)srtt;
1038 }
1039 }
1040 if (t_ssthresh < 1) {
1041 t_ssthresh = 1;
1042 }
1043 if (t_ucwnd_sbw < 1) {
1044 t_ucwnd_sbw = 1;
1045 }
1046 if (stcb->asoc.sctp_cmt_on_off == SCTP_CMT_RPV1) {
1047 net->ssthresh = (uint32_t)(((uint64_t)4 *
1048 (uint64_t)net->mtu *
1049 (uint64_t)net->ssthresh) /
1050 (uint64_t)t_ssthresh);
1051 } else {
1052 uint64_t cc_delta;
1053
1054 srtt = net->lastsa;
1055 /* lastsa>>3; we don't need to divide ... */
1056 if (srtt == 0) {
1057 srtt = 1;
1058 }
1059 cc_delta = t_ucwnd_sbw * (uint64_t)srtt / 2;
1060 if (cc_delta < t_cwnd) {
1061 net->ssthresh = (uint32_t)((uint64_t)t_cwnd - cc_delta);
1062 } else {
1063 net->ssthresh = net->mtu;
1064 }
1065 }
1066 if ((net->cwnd > t_cwnd / 2) &&
1067 (net->ssthresh < net->cwnd - t_cwnd / 2)) {
1068 net->ssthresh = net->cwnd - t_cwnd / 2;
1069 }
1070 if (net->ssthresh < net->mtu) {
1071 net->ssthresh = net->mtu;
1072 }
1073 } else {
1074 net->ssthresh = max(net->cwnd / 2, 4 * net->mtu);
1075 }
1076 net->cwnd = net->mtu;
1077 net->partial_bytes_acked = 0;
1078 SDT_PROBE5(sctp, cwnd, net, to,
1079 stcb->asoc.my_vtag,
1080 ((stcb->sctp_ep->sctp_lport << 16) | (stcb->rport)),
1081 net,
1082 old_cwnd, net->cwnd);
1083 if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_CWND_MONITOR_ENABLE) {
1084 sctp_log_cwnd(stcb, net, net->cwnd - old_cwnd, SCTP_CWND_LOG_FROM_RTX);
1085 }
1086 }
1087
1088 static void
sctp_cwnd_update_after_ecn_echo_common(struct sctp_tcb * stcb,struct sctp_nets * net,int in_window,int num_pkt_lost,int use_rtcc)1089 sctp_cwnd_update_after_ecn_echo_common(struct sctp_tcb *stcb, struct sctp_nets *net,
1090 int in_window, int num_pkt_lost, int use_rtcc)
1091 {
1092 int old_cwnd = net->cwnd;
1093
1094 if ((use_rtcc) && (net->lan_type == SCTP_LAN_LOCAL) && (net->cc_mod.rtcc.use_dccc_ecn)) {
1095 /* Data center Congestion Control */
1096 if (in_window == 0) {
1097 /*
1098 * Go to CA with the cwnd at the point we sent the
1099 * TSN that was marked with a CE.
1100 */
1101 if (net->ecn_prev_cwnd < net->cwnd) {
1102 /* Restore to prev cwnd */
1103 net->cwnd = net->ecn_prev_cwnd - (net->mtu * num_pkt_lost);
1104 } else {
1105 /* Just cut in 1/2 */
1106 net->cwnd /= 2;
1107 }
1108 /* Drop to CA */
1109 net->ssthresh = net->cwnd - (num_pkt_lost * net->mtu);
1110 if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_CWND_MONITOR_ENABLE) {
1111 sctp_log_cwnd(stcb, net, (net->cwnd - old_cwnd), SCTP_CWND_LOG_FROM_SAT);
1112 }
1113 } else {
1114 /*
1115 * Further tuning down required over the drastic
1116 * original cut
1117 */
1118 net->ssthresh -= (net->mtu * num_pkt_lost);
1119 net->cwnd -= (net->mtu * num_pkt_lost);
1120 if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_CWND_MONITOR_ENABLE) {
1121 sctp_log_cwnd(stcb, net, (net->cwnd - old_cwnd), SCTP_CWND_LOG_FROM_SAT);
1122 }
1123
1124 }
1125 SCTP_STAT_INCR(sctps_ecnereducedcwnd);
1126 } else {
1127 if (in_window == 0) {
1128 SCTP_STAT_INCR(sctps_ecnereducedcwnd);
1129 net->ssthresh = net->cwnd / 2;
1130 if (net->ssthresh < net->mtu) {
1131 net->ssthresh = net->mtu;
1132 /*
1133 * here back off the timer as well, to slow
1134 * us down
1135 */
1136 net->RTO <<= 1;
1137 }
1138 net->cwnd = net->ssthresh;
1139 SDT_PROBE5(sctp, cwnd, net, ecn,
1140 stcb->asoc.my_vtag,
1141 ((stcb->sctp_ep->sctp_lport << 16) | (stcb->rport)),
1142 net,
1143 old_cwnd, net->cwnd);
1144 if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_CWND_MONITOR_ENABLE) {
1145 sctp_log_cwnd(stcb, net, (net->cwnd - old_cwnd), SCTP_CWND_LOG_FROM_SAT);
1146 }
1147 }
1148 }
1149
1150 }
1151
1152 static void
sctp_cwnd_update_after_packet_dropped(struct sctp_tcb * stcb,struct sctp_nets * net,struct sctp_pktdrop_chunk * cp,uint32_t * bottle_bw,uint32_t * on_queue)1153 sctp_cwnd_update_after_packet_dropped(struct sctp_tcb *stcb,
1154 struct sctp_nets *net, struct sctp_pktdrop_chunk *cp,
1155 uint32_t *bottle_bw, uint32_t *on_queue)
1156 {
1157 uint32_t bw_avail;
1158 unsigned int incr;
1159 int old_cwnd = net->cwnd;
1160
1161 /* get bottle neck bw */
1162 *bottle_bw = ntohl(cp->bottle_bw);
1163 /* and whats on queue */
1164 *on_queue = ntohl(cp->current_onq);
1165 /*
1166 * adjust the on-queue if our flight is more it could be that the
1167 * router has not yet gotten data "in-flight" to it
1168 */
1169 if (*on_queue < net->flight_size) {
1170 *on_queue = net->flight_size;
1171 }
1172 /* rtt is measured in micro seconds, bottle_bw in bytes per second */
1173 bw_avail = (uint32_t)(((uint64_t)(*bottle_bw) * net->rtt) / (uint64_t)1000000);
1174 if (bw_avail > *bottle_bw) {
1175 /*
1176 * Cap the growth to no more than the bottle neck. This can
1177 * happen as RTT slides up due to queues. It also means if
1178 * you have more than a 1 second RTT with a empty queue you
1179 * will be limited to the bottle_bw per second no matter if
1180 * other points have 1/2 the RTT and you could get more
1181 * out...
1182 */
1183 bw_avail = *bottle_bw;
1184 }
1185 if (*on_queue > bw_avail) {
1186 /*
1187 * No room for anything else don't allow anything else to be
1188 * "added to the fire".
1189 */
1190 int seg_inflight, seg_onqueue, my_portion;
1191
1192 net->partial_bytes_acked = 0;
1193 /* how much are we over queue size? */
1194 incr = *on_queue - bw_avail;
1195 if (stcb->asoc.seen_a_sack_this_pkt) {
1196 /*
1197 * undo any cwnd adjustment that the sack might have
1198 * made
1199 */
1200 net->cwnd = net->prev_cwnd;
1201 }
1202 /* Now how much of that is mine? */
1203 seg_inflight = net->flight_size / net->mtu;
1204 seg_onqueue = *on_queue / net->mtu;
1205 my_portion = (incr * seg_inflight) / seg_onqueue;
1206
1207 /* Have I made an adjustment already */
1208 if (net->cwnd > net->flight_size) {
1209 /*
1210 * for this flight I made an adjustment we need to
1211 * decrease the portion by a share our previous
1212 * adjustment.
1213 */
1214 int diff_adj;
1215
1216 diff_adj = net->cwnd - net->flight_size;
1217 if (diff_adj > my_portion)
1218 my_portion = 0;
1219 else
1220 my_portion -= diff_adj;
1221 }
1222 /*
1223 * back down to the previous cwnd (assume we have had a sack
1224 * before this packet). minus what ever portion of the
1225 * overage is my fault.
1226 */
1227 net->cwnd -= my_portion;
1228
1229 /* we will NOT back down more than 1 MTU */
1230 if (net->cwnd <= net->mtu) {
1231 net->cwnd = net->mtu;
1232 }
1233 /* force into CA */
1234 net->ssthresh = net->cwnd - 1;
1235 } else {
1236 /*
1237 * Take 1/4 of the space left or max burst up .. whichever
1238 * is less.
1239 */
1240 incr = (bw_avail - *on_queue) >> 2;
1241 if ((stcb->asoc.max_burst > 0) &&
1242 (stcb->asoc.max_burst * net->mtu < incr)) {
1243 incr = stcb->asoc.max_burst * net->mtu;
1244 }
1245 net->cwnd += incr;
1246 }
1247 if (net->cwnd > bw_avail) {
1248 /* We can't exceed the pipe size */
1249 net->cwnd = bw_avail;
1250 }
1251 if (net->cwnd < net->mtu) {
1252 /* We always have 1 MTU */
1253 net->cwnd = net->mtu;
1254 }
1255 sctp_enforce_cwnd_limit(&stcb->asoc, net);
1256 if (net->cwnd - old_cwnd != 0) {
1257 /* log only changes */
1258 SDT_PROBE5(sctp, cwnd, net, pd,
1259 stcb->asoc.my_vtag,
1260 ((stcb->sctp_ep->sctp_lport << 16) | (stcb->rport)),
1261 net,
1262 old_cwnd, net->cwnd);
1263 if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_CWND_MONITOR_ENABLE) {
1264 sctp_log_cwnd(stcb, net, (net->cwnd - old_cwnd),
1265 SCTP_CWND_LOG_FROM_SAT);
1266 }
1267 }
1268 }
1269
1270 static void
sctp_cwnd_update_after_output(struct sctp_tcb * stcb,struct sctp_nets * net,int burst_limit)1271 sctp_cwnd_update_after_output(struct sctp_tcb *stcb,
1272 struct sctp_nets *net, int burst_limit)
1273 {
1274 int old_cwnd = net->cwnd;
1275
1276 if (net->ssthresh < net->cwnd)
1277 net->ssthresh = net->cwnd;
1278 if (burst_limit) {
1279 net->cwnd = (net->flight_size + (burst_limit * net->mtu));
1280 sctp_enforce_cwnd_limit(&stcb->asoc, net);
1281 SDT_PROBE5(sctp, cwnd, net, bl,
1282 stcb->asoc.my_vtag,
1283 ((stcb->sctp_ep->sctp_lport << 16) | (stcb->rport)),
1284 net,
1285 old_cwnd, net->cwnd);
1286 if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_CWND_MONITOR_ENABLE) {
1287 sctp_log_cwnd(stcb, net, (net->cwnd - old_cwnd), SCTP_CWND_LOG_FROM_BRST);
1288 }
1289 }
1290 }
1291
1292 static void
sctp_cwnd_update_after_sack(struct sctp_tcb * stcb,struct sctp_association * asoc,int accum_moved,int reneged_all,int will_exit)1293 sctp_cwnd_update_after_sack(struct sctp_tcb *stcb,
1294 struct sctp_association *asoc,
1295 int accum_moved, int reneged_all, int will_exit)
1296 {
1297 /* Passing a zero argument in last disables the rtcc algorithm */
1298 sctp_cwnd_update_after_sack_common(stcb, asoc, accum_moved, reneged_all, will_exit, 0);
1299 }
1300
1301 static void
sctp_cwnd_update_after_ecn_echo(struct sctp_tcb * stcb,struct sctp_nets * net,int in_window,int num_pkt_lost)1302 sctp_cwnd_update_after_ecn_echo(struct sctp_tcb *stcb, struct sctp_nets *net,
1303 int in_window, int num_pkt_lost)
1304 {
1305 /* Passing a zero argument in last disables the rtcc algorithm */
1306 sctp_cwnd_update_after_ecn_echo_common(stcb, net, in_window, num_pkt_lost, 0);
1307 }
1308
1309 /* Here starts the RTCCVAR type CC invented by RRS which
1310 * is a slight mod to RFC2581. We reuse a common routine or
1311 * two since these algorithms are so close and need to
1312 * remain the same.
1313 */
1314 static void
sctp_cwnd_update_rtcc_after_ecn_echo(struct sctp_tcb * stcb,struct sctp_nets * net,int in_window,int num_pkt_lost)1315 sctp_cwnd_update_rtcc_after_ecn_echo(struct sctp_tcb *stcb, struct sctp_nets *net,
1316 int in_window, int num_pkt_lost)
1317 {
1318 sctp_cwnd_update_after_ecn_echo_common(stcb, net, in_window, num_pkt_lost, 1);
1319 }
1320
1321 static void
sctp_cwnd_update_rtcc_tsn_acknowledged(struct sctp_nets * net,struct sctp_tmit_chunk * tp1)1322 sctp_cwnd_update_rtcc_tsn_acknowledged(struct sctp_nets *net,
1323 struct sctp_tmit_chunk *tp1)
1324 {
1325 net->cc_mod.rtcc.bw_bytes += tp1->send_size;
1326 }
1327
1328 static void
sctp_cwnd_prepare_rtcc_net_for_sack(struct sctp_tcb * stcb SCTP_UNUSED,struct sctp_nets * net)1329 sctp_cwnd_prepare_rtcc_net_for_sack(struct sctp_tcb *stcb SCTP_UNUSED,
1330 struct sctp_nets *net)
1331 {
1332 if (net->cc_mod.rtcc.tls_needs_set > 0) {
1333 /* We had a bw measurment going on */
1334 struct timeval ltls;
1335
1336 SCTP_GETPTIME_TIMEVAL(<ls);
1337 timevalsub(<ls, &net->cc_mod.rtcc.tls);
1338 net->cc_mod.rtcc.new_tot_time = (ltls.tv_sec * 1000000) + ltls.tv_usec;
1339 }
1340 }
1341
1342 static void
sctp_cwnd_new_rtcc_transmission_begins(struct sctp_tcb * stcb,struct sctp_nets * net)1343 sctp_cwnd_new_rtcc_transmission_begins(struct sctp_tcb *stcb,
1344 struct sctp_nets *net)
1345 {
1346 uint64_t vtag, probepoint;
1347
1348 if (net->cc_mod.rtcc.lbw) {
1349 /* Clear the old bw.. we went to 0 in-flight */
1350 vtag = (net->rtt << 32) | (((uint32_t)(stcb->sctp_ep->sctp_lport)) << 16) |
1351 (stcb->rport);
1352 probepoint = (((uint64_t)net->cwnd) << 32);
1353 /* Probe point 8 */
1354 probepoint |= ((8 << 16) | 0);
1355 SDT_PROBE5(sctp, cwnd, net, rttvar,
1356 vtag,
1357 ((net->cc_mod.rtcc.lbw << 32) | 0),
1358 ((net->cc_mod.rtcc.lbw_rtt << 32) | net->rtt),
1359 net->flight_size,
1360 probepoint);
1361 net->cc_mod.rtcc.lbw_rtt = 0;
1362 net->cc_mod.rtcc.cwnd_at_bw_set = 0;
1363 net->cc_mod.rtcc.lbw = 0;
1364 net->cc_mod.rtcc.bw_bytes_at_last_rttc = 0;
1365 net->cc_mod.rtcc.vol_reduce = 0;
1366 net->cc_mod.rtcc.bw_tot_time = 0;
1367 net->cc_mod.rtcc.bw_bytes = 0;
1368 net->cc_mod.rtcc.tls_needs_set = 0;
1369 if (net->cc_mod.rtcc.steady_step) {
1370 net->cc_mod.rtcc.vol_reduce = 0;
1371 net->cc_mod.rtcc.step_cnt = 0;
1372 net->cc_mod.rtcc.last_step_state = 0;
1373 }
1374 if (net->cc_mod.rtcc.ret_from_eq) {
1375 /* less aggressive one - reset cwnd too */
1376 uint32_t cwnd_in_mtu, cwnd;
1377
1378 cwnd_in_mtu = SCTP_BASE_SYSCTL(sctp_initial_cwnd);
1379 if (cwnd_in_mtu == 0) {
1380 /*
1381 * Using 0 means that the value of RFC 4960
1382 * is used.
1383 */
1384 cwnd = min((net->mtu * 4), max((2 * net->mtu), SCTP_INITIAL_CWND));
1385 } else {
1386 /*
1387 * We take the minimum of the burst limit
1388 * and the initial congestion window.
1389 */
1390 if ((stcb->asoc.max_burst > 0) && (cwnd_in_mtu > stcb->asoc.max_burst))
1391 cwnd_in_mtu = stcb->asoc.max_burst;
1392 cwnd = (net->mtu - sizeof(struct sctphdr)) * cwnd_in_mtu;
1393 }
1394 if (net->cwnd > cwnd) {
1395 /*
1396 * Only set if we are not a timeout (i.e.
1397 * down to 1 mtu)
1398 */
1399 net->cwnd = cwnd;
1400 }
1401 }
1402 }
1403 }
1404
1405 static void
sctp_set_rtcc_initial_cc_param(struct sctp_tcb * stcb,struct sctp_nets * net)1406 sctp_set_rtcc_initial_cc_param(struct sctp_tcb *stcb,
1407 struct sctp_nets *net)
1408 {
1409 uint64_t vtag, probepoint;
1410
1411 sctp_set_initial_cc_param(stcb, net);
1412 stcb->asoc.use_precise_time = 1;
1413 probepoint = (((uint64_t)net->cwnd) << 32);
1414 probepoint |= ((9 << 16) | 0);
1415 vtag = (net->rtt << 32) |
1416 (((uint32_t)(stcb->sctp_ep->sctp_lport)) << 16) |
1417 (stcb->rport);
1418 SDT_PROBE5(sctp, cwnd, net, rttvar,
1419 vtag,
1420 0,
1421 0,
1422 0,
1423 probepoint);
1424 net->cc_mod.rtcc.lbw_rtt = 0;
1425 net->cc_mod.rtcc.cwnd_at_bw_set = 0;
1426 net->cc_mod.rtcc.vol_reduce = 0;
1427 net->cc_mod.rtcc.lbw = 0;
1428 net->cc_mod.rtcc.vol_reduce = 0;
1429 net->cc_mod.rtcc.bw_bytes_at_last_rttc = 0;
1430 net->cc_mod.rtcc.bw_tot_time = 0;
1431 net->cc_mod.rtcc.bw_bytes = 0;
1432 net->cc_mod.rtcc.tls_needs_set = 0;
1433 net->cc_mod.rtcc.ret_from_eq = SCTP_BASE_SYSCTL(sctp_rttvar_eqret);
1434 net->cc_mod.rtcc.steady_step = SCTP_BASE_SYSCTL(sctp_steady_step);
1435 net->cc_mod.rtcc.use_dccc_ecn = SCTP_BASE_SYSCTL(sctp_use_dccc_ecn);
1436 net->cc_mod.rtcc.step_cnt = 0;
1437 net->cc_mod.rtcc.last_step_state = 0;
1438
1439 }
1440
1441 static int
sctp_cwnd_rtcc_socket_option(struct sctp_tcb * stcb,int setorget,struct sctp_cc_option * cc_opt)1442 sctp_cwnd_rtcc_socket_option(struct sctp_tcb *stcb, int setorget,
1443 struct sctp_cc_option *cc_opt)
1444 {
1445 struct sctp_nets *net;
1446
1447 if (setorget == 1) {
1448 /* a set */
1449 if (cc_opt->option == SCTP_CC_OPT_RTCC_SETMODE) {
1450 if ((cc_opt->aid_value.assoc_value != 0) &&
1451 (cc_opt->aid_value.assoc_value != 1)) {
1452 return (EINVAL);
1453 }
1454 TAILQ_FOREACH(net, &stcb->asoc.nets, sctp_next) {
1455 net->cc_mod.rtcc.ret_from_eq = cc_opt->aid_value.assoc_value;
1456 }
1457 } else if (cc_opt->option == SCTP_CC_OPT_USE_DCCC_ECN) {
1458 if ((cc_opt->aid_value.assoc_value != 0) &&
1459 (cc_opt->aid_value.assoc_value != 1)) {
1460 return (EINVAL);
1461 }
1462 TAILQ_FOREACH(net, &stcb->asoc.nets, sctp_next) {
1463 net->cc_mod.rtcc.use_dccc_ecn = cc_opt->aid_value.assoc_value;
1464 }
1465 } else if (cc_opt->option == SCTP_CC_OPT_STEADY_STEP) {
1466 TAILQ_FOREACH(net, &stcb->asoc.nets, sctp_next) {
1467 net->cc_mod.rtcc.steady_step = cc_opt->aid_value.assoc_value;
1468 }
1469 } else {
1470 return (EINVAL);
1471 }
1472 } else {
1473 /* a get */
1474 if (cc_opt->option == SCTP_CC_OPT_RTCC_SETMODE) {
1475 net = TAILQ_FIRST(&stcb->asoc.nets);
1476 if (net == NULL) {
1477 return (EFAULT);
1478 }
1479 cc_opt->aid_value.assoc_value = net->cc_mod.rtcc.ret_from_eq;
1480 } else if (cc_opt->option == SCTP_CC_OPT_USE_DCCC_ECN) {
1481 net = TAILQ_FIRST(&stcb->asoc.nets);
1482 if (net == NULL) {
1483 return (EFAULT);
1484 }
1485 cc_opt->aid_value.assoc_value = net->cc_mod.rtcc.use_dccc_ecn;
1486 } else if (cc_opt->option == SCTP_CC_OPT_STEADY_STEP) {
1487 net = TAILQ_FIRST(&stcb->asoc.nets);
1488 if (net == NULL) {
1489 return (EFAULT);
1490 }
1491 cc_opt->aid_value.assoc_value = net->cc_mod.rtcc.steady_step;
1492 } else {
1493 return (EINVAL);
1494 }
1495 }
1496 return (0);
1497 }
1498
1499 static void
sctp_cwnd_update_rtcc_packet_transmitted(struct sctp_tcb * stcb SCTP_UNUSED,struct sctp_nets * net)1500 sctp_cwnd_update_rtcc_packet_transmitted(struct sctp_tcb *stcb SCTP_UNUSED,
1501 struct sctp_nets *net)
1502 {
1503 if (net->cc_mod.rtcc.tls_needs_set == 0) {
1504 SCTP_GETPTIME_TIMEVAL(&net->cc_mod.rtcc.tls);
1505 net->cc_mod.rtcc.tls_needs_set = 2;
1506 }
1507 }
1508
1509 static void
sctp_cwnd_update_rtcc_after_sack(struct sctp_tcb * stcb,struct sctp_association * asoc,int accum_moved,int reneged_all,int will_exit)1510 sctp_cwnd_update_rtcc_after_sack(struct sctp_tcb *stcb,
1511 struct sctp_association *asoc,
1512 int accum_moved, int reneged_all, int will_exit)
1513 {
1514 /* Passing a one argument at the last enables the rtcc algorithm */
1515 sctp_cwnd_update_after_sack_common(stcb, asoc, accum_moved, reneged_all, will_exit, 1);
1516 }
1517
1518 static void
sctp_rtt_rtcc_calculated(struct sctp_tcb * stcb SCTP_UNUSED,struct sctp_nets * net,struct timeval * now SCTP_UNUSED)1519 sctp_rtt_rtcc_calculated(struct sctp_tcb *stcb SCTP_UNUSED,
1520 struct sctp_nets *net,
1521 struct timeval *now SCTP_UNUSED)
1522 {
1523 net->cc_mod.rtcc.rtt_set_this_sack = 1;
1524 }
1525
1526 /* Here starts Sally Floyds HS-TCP */
1527
1528 struct sctp_hs_raise_drop {
1529 int32_t cwnd;
1530 int8_t increase;
1531 int8_t drop_percent;
1532 };
1533
1534 #define SCTP_HS_TABLE_SIZE 73
1535
1536 static const struct sctp_hs_raise_drop sctp_cwnd_adjust[SCTP_HS_TABLE_SIZE] = {
1537 {38, 1, 50}, /* 0 */
1538 {118, 2, 44}, /* 1 */
1539 {221, 3, 41}, /* 2 */
1540 {347, 4, 38}, /* 3 */
1541 {495, 5, 37}, /* 4 */
1542 {663, 6, 35}, /* 5 */
1543 {851, 7, 34}, /* 6 */
1544 {1058, 8, 33}, /* 7 */
1545 {1284, 9, 32}, /* 8 */
1546 {1529, 10, 31}, /* 9 */
1547 {1793, 11, 30}, /* 10 */
1548 {2076, 12, 29}, /* 11 */
1549 {2378, 13, 28}, /* 12 */
1550 {2699, 14, 28}, /* 13 */
1551 {3039, 15, 27}, /* 14 */
1552 {3399, 16, 27}, /* 15 */
1553 {3778, 17, 26}, /* 16 */
1554 {4177, 18, 26}, /* 17 */
1555 {4596, 19, 25}, /* 18 */
1556 {5036, 20, 25}, /* 19 */
1557 {5497, 21, 24}, /* 20 */
1558 {5979, 22, 24}, /* 21 */
1559 {6483, 23, 23}, /* 22 */
1560 {7009, 24, 23}, /* 23 */
1561 {7558, 25, 22}, /* 24 */
1562 {8130, 26, 22}, /* 25 */
1563 {8726, 27, 22}, /* 26 */
1564 {9346, 28, 21}, /* 27 */
1565 {9991, 29, 21}, /* 28 */
1566 {10661, 30, 21}, /* 29 */
1567 {11358, 31, 20}, /* 30 */
1568 {12082, 32, 20}, /* 31 */
1569 {12834, 33, 20}, /* 32 */
1570 {13614, 34, 19}, /* 33 */
1571 {14424, 35, 19}, /* 34 */
1572 {15265, 36, 19}, /* 35 */
1573 {16137, 37, 19}, /* 36 */
1574 {17042, 38, 18}, /* 37 */
1575 {17981, 39, 18}, /* 38 */
1576 {18955, 40, 18}, /* 39 */
1577 {19965, 41, 17}, /* 40 */
1578 {21013, 42, 17}, /* 41 */
1579 {22101, 43, 17}, /* 42 */
1580 {23230, 44, 17}, /* 43 */
1581 {24402, 45, 16}, /* 44 */
1582 {25618, 46, 16}, /* 45 */
1583 {26881, 47, 16}, /* 46 */
1584 {28193, 48, 16}, /* 47 */
1585 {29557, 49, 15}, /* 48 */
1586 {30975, 50, 15}, /* 49 */
1587 {32450, 51, 15}, /* 50 */
1588 {33986, 52, 15}, /* 51 */
1589 {35586, 53, 14}, /* 52 */
1590 {37253, 54, 14}, /* 53 */
1591 {38992, 55, 14}, /* 54 */
1592 {40808, 56, 14}, /* 55 */
1593 {42707, 57, 13}, /* 56 */
1594 {44694, 58, 13}, /* 57 */
1595 {46776, 59, 13}, /* 58 */
1596 {48961, 60, 13}, /* 59 */
1597 {51258, 61, 13}, /* 60 */
1598 {53677, 62, 12}, /* 61 */
1599 {56230, 63, 12}, /* 62 */
1600 {58932, 64, 12}, /* 63 */
1601 {61799, 65, 12}, /* 64 */
1602 {64851, 66, 11}, /* 65 */
1603 {68113, 67, 11}, /* 66 */
1604 {71617, 68, 11}, /* 67 */
1605 {75401, 69, 10}, /* 68 */
1606 {79517, 70, 10}, /* 69 */
1607 {84035, 71, 10}, /* 70 */
1608 {89053, 72, 10}, /* 71 */
1609 {94717, 73, 9} /* 72 */
1610 };
1611
1612 static void
sctp_hs_cwnd_increase(struct sctp_tcb * stcb,struct sctp_nets * net)1613 sctp_hs_cwnd_increase(struct sctp_tcb *stcb, struct sctp_nets *net)
1614 {
1615 int cur_val, i, indx, incr;
1616 int old_cwnd = net->cwnd;
1617
1618 cur_val = net->cwnd >> 10;
1619 indx = SCTP_HS_TABLE_SIZE - 1;
1620
1621 if (cur_val < sctp_cwnd_adjust[0].cwnd) {
1622 /* normal mode */
1623 if (net->net_ack > net->mtu) {
1624 net->cwnd += net->mtu;
1625 } else {
1626 net->cwnd += net->net_ack;
1627 }
1628 } else {
1629 for (i = net->last_hs_used; i < SCTP_HS_TABLE_SIZE; i++) {
1630 if (cur_val < sctp_cwnd_adjust[i].cwnd) {
1631 indx = i;
1632 break;
1633 }
1634 }
1635 net->last_hs_used = indx;
1636 incr = (((int32_t)sctp_cwnd_adjust[indx].increase) << 10);
1637 net->cwnd += incr;
1638 }
1639 sctp_enforce_cwnd_limit(&stcb->asoc, net);
1640 if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_CWND_MONITOR_ENABLE) {
1641 sctp_log_cwnd(stcb, net, (net->cwnd - old_cwnd), SCTP_CWND_LOG_FROM_SS);
1642 }
1643 }
1644
1645 static void
sctp_hs_cwnd_decrease(struct sctp_tcb * stcb,struct sctp_nets * net)1646 sctp_hs_cwnd_decrease(struct sctp_tcb *stcb, struct sctp_nets *net)
1647 {
1648 int cur_val, i, indx;
1649 int old_cwnd = net->cwnd;
1650
1651 cur_val = net->cwnd >> 10;
1652 if (cur_val < sctp_cwnd_adjust[0].cwnd) {
1653 /* normal mode */
1654 net->ssthresh = net->cwnd / 2;
1655 if (net->ssthresh < (net->mtu * 2)) {
1656 net->ssthresh = 2 * net->mtu;
1657 }
1658 net->cwnd = net->ssthresh;
1659 } else {
1660 /* drop by the proper amount */
1661 net->ssthresh = net->cwnd - (int)((net->cwnd / 100) *
1662 (int32_t)sctp_cwnd_adjust[net->last_hs_used].drop_percent);
1663 net->cwnd = net->ssthresh;
1664 /* now where are we */
1665 indx = net->last_hs_used;
1666 cur_val = net->cwnd >> 10;
1667 /* reset where we are in the table */
1668 if (cur_val < sctp_cwnd_adjust[0].cwnd) {
1669 /* feel out of hs */
1670 net->last_hs_used = 0;
1671 } else {
1672 for (i = indx; i >= 1; i--) {
1673 if (cur_val > sctp_cwnd_adjust[i - 1].cwnd) {
1674 break;
1675 }
1676 }
1677 net->last_hs_used = indx;
1678 }
1679 }
1680 sctp_enforce_cwnd_limit(&stcb->asoc, net);
1681 if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_CWND_MONITOR_ENABLE) {
1682 sctp_log_cwnd(stcb, net, (net->cwnd - old_cwnd), SCTP_CWND_LOG_FROM_FR);
1683 }
1684 }
1685
1686 static void
sctp_hs_cwnd_update_after_fr(struct sctp_tcb * stcb,struct sctp_association * asoc)1687 sctp_hs_cwnd_update_after_fr(struct sctp_tcb *stcb,
1688 struct sctp_association *asoc)
1689 {
1690 struct sctp_nets *net;
1691
1692 /*
1693 * CMT fast recovery code. Need to debug. ((sctp_cmt_on_off > 0) &&
1694 * (net->fast_retran_loss_recovery == 0)))
1695 */
1696 TAILQ_FOREACH(net, &asoc->nets, sctp_next) {
1697 if ((asoc->fast_retran_loss_recovery == 0) ||
1698 (asoc->sctp_cmt_on_off > 0)) {
1699 /* out of a RFC2582 Fast recovery window? */
1700 if (net->net_ack > 0) {
1701 /*
1702 * per section 7.2.3, are there any
1703 * destinations that had a fast retransmit
1704 * to them. If so what we need to do is
1705 * adjust ssthresh and cwnd.
1706 */
1707 struct sctp_tmit_chunk *lchk;
1708
1709 sctp_hs_cwnd_decrease(stcb, net);
1710
1711 lchk = TAILQ_FIRST(&asoc->send_queue);
1712
1713 net->partial_bytes_acked = 0;
1714 /* Turn on fast recovery window */
1715 asoc->fast_retran_loss_recovery = 1;
1716 if (lchk == NULL) {
1717 /* Mark end of the window */
1718 asoc->fast_recovery_tsn = asoc->sending_seq - 1;
1719 } else {
1720 asoc->fast_recovery_tsn = lchk->rec.data.tsn - 1;
1721 }
1722
1723 /*
1724 * CMT fast recovery -- per destination
1725 * recovery variable.
1726 */
1727 net->fast_retran_loss_recovery = 1;
1728
1729 if (lchk == NULL) {
1730 /* Mark end of the window */
1731 net->fast_recovery_tsn = asoc->sending_seq - 1;
1732 } else {
1733 net->fast_recovery_tsn = lchk->rec.data.tsn - 1;
1734 }
1735
1736 sctp_timer_stop(SCTP_TIMER_TYPE_SEND,
1737 stcb->sctp_ep, stcb, net,
1738 SCTP_FROM_SCTP_CC_FUNCTIONS + SCTP_LOC_2);
1739 sctp_timer_start(SCTP_TIMER_TYPE_SEND,
1740 stcb->sctp_ep, stcb, net);
1741 }
1742 } else if (net->net_ack > 0) {
1743 /*
1744 * Mark a peg that we WOULD have done a cwnd
1745 * reduction but RFC2582 prevented this action.
1746 */
1747 SCTP_STAT_INCR(sctps_fastretransinrtt);
1748 }
1749 }
1750 }
1751
1752 static void
sctp_hs_cwnd_update_after_sack(struct sctp_tcb * stcb,struct sctp_association * asoc,int accum_moved,int reneged_all SCTP_UNUSED,int will_exit)1753 sctp_hs_cwnd_update_after_sack(struct sctp_tcb *stcb,
1754 struct sctp_association *asoc,
1755 int accum_moved, int reneged_all SCTP_UNUSED, int will_exit)
1756 {
1757 struct sctp_nets *net;
1758
1759 /******************************/
1760 /* update cwnd and Early FR */
1761 /******************************/
1762 TAILQ_FOREACH(net, &asoc->nets, sctp_next) {
1763
1764 #ifdef JANA_CMT_FAST_RECOVERY
1765 /*
1766 * CMT fast recovery code. Need to debug.
1767 */
1768 if (net->fast_retran_loss_recovery && net->new_pseudo_cumack) {
1769 if (SCTP_TSN_GE(asoc->last_acked_seq, net->fast_recovery_tsn) ||
1770 SCTP_TSN_GE(net->pseudo_cumack, net->fast_recovery_tsn)) {
1771 net->will_exit_fast_recovery = 1;
1772 }
1773 }
1774 #endif
1775 /* if nothing was acked on this destination skip it */
1776 if (net->net_ack == 0) {
1777 if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_CWND_LOGGING_ENABLE) {
1778 sctp_log_cwnd(stcb, net, 0, SCTP_CWND_LOG_FROM_SACK);
1779 }
1780 continue;
1781 }
1782 #ifdef JANA_CMT_FAST_RECOVERY
1783 /*
1784 * CMT fast recovery code
1785 */
1786 /*
1787 * if (sctp_cmt_on_off > 0 && net->fast_retran_loss_recovery
1788 * && net->will_exit_fast_recovery == 0) { @@@ Do something
1789 * } else if (sctp_cmt_on_off == 0 &&
1790 * asoc->fast_retran_loss_recovery && will_exit == 0) {
1791 */
1792 #endif
1793
1794 if (asoc->fast_retran_loss_recovery &&
1795 (will_exit == 0) &&
1796 (asoc->sctp_cmt_on_off == 0)) {
1797 /*
1798 * If we are in loss recovery we skip any cwnd
1799 * update
1800 */
1801 return;
1802 }
1803 /*
1804 * CMT: CUC algorithm. Update cwnd if pseudo-cumack has
1805 * moved.
1806 */
1807 if (accum_moved ||
1808 ((asoc->sctp_cmt_on_off > 0) && net->new_pseudo_cumack)) {
1809 /* If the cumulative ack moved we can proceed */
1810 if (net->cwnd <= net->ssthresh) {
1811 /* We are in slow start */
1812 if (net->flight_size + net->net_ack >= net->cwnd) {
1813 sctp_hs_cwnd_increase(stcb, net);
1814 } else {
1815 if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_CWND_LOGGING_ENABLE) {
1816 sctp_log_cwnd(stcb, net, net->net_ack,
1817 SCTP_CWND_LOG_NOADV_SS);
1818 }
1819 }
1820 } else {
1821 /* We are in congestion avoidance */
1822 net->partial_bytes_acked += net->net_ack;
1823 if ((net->flight_size + net->net_ack >= net->cwnd) &&
1824 (net->partial_bytes_acked >= net->cwnd)) {
1825 net->partial_bytes_acked -= net->cwnd;
1826 net->cwnd += net->mtu;
1827 sctp_enforce_cwnd_limit(asoc, net);
1828 if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_CWND_MONITOR_ENABLE) {
1829 sctp_log_cwnd(stcb, net, net->mtu,
1830 SCTP_CWND_LOG_FROM_CA);
1831 }
1832 } else {
1833 if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_CWND_LOGGING_ENABLE) {
1834 sctp_log_cwnd(stcb, net, net->net_ack,
1835 SCTP_CWND_LOG_NOADV_CA);
1836 }
1837 }
1838 }
1839 } else {
1840 if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_CWND_LOGGING_ENABLE) {
1841 sctp_log_cwnd(stcb, net, net->mtu,
1842 SCTP_CWND_LOG_NO_CUMACK);
1843 }
1844 }
1845 }
1846 }
1847
1848
1849 /*
1850 * H-TCP congestion control. The algorithm is detailed in:
1851 * R.N.Shorten, D.J.Leith:
1852 * "H-TCP: TCP for high-speed and long-distance networks"
1853 * Proc. PFLDnet, Argonne, 2004.
1854 * http://www.hamilton.ie/net/htcp3.pdf
1855 */
1856
1857
1858 static int use_rtt_scaling = 1;
1859 static int use_bandwidth_switch = 1;
1860
1861 static inline int
between(uint32_t seq1,uint32_t seq2,uint32_t seq3)1862 between(uint32_t seq1, uint32_t seq2, uint32_t seq3)
1863 {
1864 return (seq3 - seq2 >= seq1 - seq2);
1865 }
1866
1867 static inline uint32_t
htcp_cong_time(struct htcp * ca)1868 htcp_cong_time(struct htcp *ca)
1869 {
1870 return (sctp_get_tick_count() - ca->last_cong);
1871 }
1872
1873 static inline uint32_t
htcp_ccount(struct htcp * ca)1874 htcp_ccount(struct htcp *ca)
1875 {
1876 return (ca->minRTT == 0 ? htcp_cong_time(ca) : htcp_cong_time(ca) / ca->minRTT);
1877 }
1878
1879 static inline void
htcp_reset(struct htcp * ca)1880 htcp_reset(struct htcp *ca)
1881 {
1882 ca->undo_last_cong = ca->last_cong;
1883 ca->undo_maxRTT = ca->maxRTT;
1884 ca->undo_old_maxB = ca->old_maxB;
1885 ca->last_cong = sctp_get_tick_count();
1886 }
1887
1888 #ifdef SCTP_NOT_USED
1889
1890 static uint32_t
htcp_cwnd_undo(struct sctp_tcb * stcb,struct sctp_nets * net)1891 htcp_cwnd_undo(struct sctp_tcb *stcb, struct sctp_nets *net)
1892 {
1893 net->cc_mod.htcp_ca.last_cong = net->cc_mod.htcp_ca.undo_last_cong;
1894 net->cc_mod.htcp_ca.maxRTT = net->cc_mod.htcp_ca.undo_maxRTT;
1895 net->cc_mod.htcp_ca.old_maxB = net->cc_mod.htcp_ca.undo_old_maxB;
1896 return (max(net->cwnd, ((net->ssthresh / net->mtu << 7) / net->cc_mod.htcp_ca.beta) * net->mtu));
1897 }
1898
1899 #endif
1900
1901 static inline void
measure_rtt(struct sctp_nets * net)1902 measure_rtt(struct sctp_nets *net)
1903 {
1904 uint32_t srtt = net->lastsa >> SCTP_RTT_SHIFT;
1905
1906 /* keep track of minimum RTT seen so far, minRTT is zero at first */
1907 if (net->cc_mod.htcp_ca.minRTT > srtt || !net->cc_mod.htcp_ca.minRTT)
1908 net->cc_mod.htcp_ca.minRTT = srtt;
1909
1910 /* max RTT */
1911 if (net->fast_retran_ip == 0 && net->ssthresh < 0xFFFF && htcp_ccount(&net->cc_mod.htcp_ca) > 3) {
1912 if (net->cc_mod.htcp_ca.maxRTT < net->cc_mod.htcp_ca.minRTT)
1913 net->cc_mod.htcp_ca.maxRTT = net->cc_mod.htcp_ca.minRTT;
1914 if (net->cc_mod.htcp_ca.maxRTT < srtt && srtt <= net->cc_mod.htcp_ca.maxRTT + sctp_msecs_to_ticks(20))
1915 net->cc_mod.htcp_ca.maxRTT = srtt;
1916 }
1917 }
1918
1919 static void
measure_achieved_throughput(struct sctp_nets * net)1920 measure_achieved_throughput(struct sctp_nets *net)
1921 {
1922 uint32_t now = sctp_get_tick_count();
1923
1924 if (net->fast_retran_ip == 0)
1925 net->cc_mod.htcp_ca.bytes_acked = net->net_ack;
1926
1927 if (!use_bandwidth_switch)
1928 return;
1929
1930 /* achieved throughput calculations */
1931 /* JRS - not 100% sure of this statement */
1932 if (net->fast_retran_ip == 1) {
1933 net->cc_mod.htcp_ca.bytecount = 0;
1934 net->cc_mod.htcp_ca.lasttime = now;
1935 return;
1936 }
1937
1938 net->cc_mod.htcp_ca.bytecount += net->net_ack;
1939 if ((net->cc_mod.htcp_ca.bytecount >= net->cwnd - (((net->cc_mod.htcp_ca.alpha >> 7) ? (net->cc_mod.htcp_ca.alpha >> 7) : 1) * net->mtu)) &&
1940 (now - net->cc_mod.htcp_ca.lasttime >= net->cc_mod.htcp_ca.minRTT) &&
1941 (net->cc_mod.htcp_ca.minRTT > 0)) {
1942 uint32_t cur_Bi = net->cc_mod.htcp_ca.bytecount / net->mtu * hz / (now - net->cc_mod.htcp_ca.lasttime);
1943
1944 if (htcp_ccount(&net->cc_mod.htcp_ca) <= 3) {
1945 /* just after backoff */
1946 net->cc_mod.htcp_ca.minB = net->cc_mod.htcp_ca.maxB = net->cc_mod.htcp_ca.Bi = cur_Bi;
1947 } else {
1948 net->cc_mod.htcp_ca.Bi = (3 * net->cc_mod.htcp_ca.Bi + cur_Bi) / 4;
1949 if (net->cc_mod.htcp_ca.Bi > net->cc_mod.htcp_ca.maxB)
1950 net->cc_mod.htcp_ca.maxB = net->cc_mod.htcp_ca.Bi;
1951 if (net->cc_mod.htcp_ca.minB > net->cc_mod.htcp_ca.maxB)
1952 net->cc_mod.htcp_ca.minB = net->cc_mod.htcp_ca.maxB;
1953 }
1954 net->cc_mod.htcp_ca.bytecount = 0;
1955 net->cc_mod.htcp_ca.lasttime = now;
1956 }
1957 }
1958
1959 static inline void
htcp_beta_update(struct htcp * ca,uint32_t minRTT,uint32_t maxRTT)1960 htcp_beta_update(struct htcp *ca, uint32_t minRTT, uint32_t maxRTT)
1961 {
1962 if (use_bandwidth_switch) {
1963 uint32_t maxB = ca->maxB;
1964 uint32_t old_maxB = ca->old_maxB;
1965
1966 ca->old_maxB = ca->maxB;
1967
1968 if (!between(5 * maxB, 4 * old_maxB, 6 * old_maxB)) {
1969 ca->beta = BETA_MIN;
1970 ca->modeswitch = 0;
1971 return;
1972 }
1973 }
1974
1975 if (ca->modeswitch && minRTT > sctp_msecs_to_ticks(10) && maxRTT) {
1976 ca->beta = (minRTT << 7) / maxRTT;
1977 if (ca->beta < BETA_MIN)
1978 ca->beta = BETA_MIN;
1979 else if (ca->beta > BETA_MAX)
1980 ca->beta = BETA_MAX;
1981 } else {
1982 ca->beta = BETA_MIN;
1983 ca->modeswitch = 1;
1984 }
1985 }
1986
1987 static inline void
htcp_alpha_update(struct htcp * ca)1988 htcp_alpha_update(struct htcp *ca)
1989 {
1990 uint32_t minRTT = ca->minRTT;
1991 uint32_t factor = 1;
1992 uint32_t diff = htcp_cong_time(ca);
1993
1994 if (diff > (uint32_t)hz) {
1995 diff -= hz;
1996 factor = 1 + (10 * diff + ((diff / 2) * (diff / 2) / hz)) / hz;
1997 }
1998
1999 if (use_rtt_scaling && minRTT) {
2000 uint32_t scale = (hz << 3) / (10 * minRTT);
2001
2002 scale = min(max(scale, 1U << 2), 10U << 3); /* clamping ratio to
2003 * interval [0.5,10]<<3 */
2004 factor = (factor << 3) / scale;
2005 if (factor != 0)
2006 factor = 1;
2007 }
2008
2009 ca->alpha = 2 * factor * ((1 << 7) - ca->beta);
2010 if (ca->alpha != 0)
2011 ca->alpha = ALPHA_BASE;
2012 }
2013
2014 /* After we have the rtt data to calculate beta, we'd still prefer to wait one
2015 * rtt before we adjust our beta to ensure we are working from a consistent
2016 * data.
2017 *
2018 * This function should be called when we hit a congestion event since only at
2019 * that point do we really have a real sense of maxRTT (the queues en route
2020 * were getting just too full now).
2021 */
2022 static void
htcp_param_update(struct sctp_nets * net)2023 htcp_param_update(struct sctp_nets *net)
2024 {
2025 uint32_t minRTT = net->cc_mod.htcp_ca.minRTT;
2026 uint32_t maxRTT = net->cc_mod.htcp_ca.maxRTT;
2027
2028 htcp_beta_update(&net->cc_mod.htcp_ca, minRTT, maxRTT);
2029 htcp_alpha_update(&net->cc_mod.htcp_ca);
2030
2031 /*
2032 * add slowly fading memory for maxRTT to accommodate routing
2033 * changes etc
2034 */
2035 if (minRTT > 0 && maxRTT > minRTT)
2036 net->cc_mod.htcp_ca.maxRTT = minRTT + ((maxRTT - minRTT) * 95) / 100;
2037 }
2038
2039 static uint32_t
htcp_recalc_ssthresh(struct sctp_nets * net)2040 htcp_recalc_ssthresh(struct sctp_nets *net)
2041 {
2042 htcp_param_update(net);
2043 return (max(((net->cwnd / net->mtu * net->cc_mod.htcp_ca.beta) >> 7) * net->mtu, 2U * net->mtu));
2044 }
2045
2046 static void
htcp_cong_avoid(struct sctp_tcb * stcb,struct sctp_nets * net)2047 htcp_cong_avoid(struct sctp_tcb *stcb, struct sctp_nets *net)
2048 {
2049 /*-
2050 * How to handle these functions?
2051 * if (!tcp_is_cwnd_limited(sk, in_flight)) RRS - good question.
2052 * return;
2053 */
2054 if (net->cwnd <= net->ssthresh) {
2055 /* We are in slow start */
2056 if (net->flight_size + net->net_ack >= net->cwnd) {
2057 if (net->net_ack > (net->mtu * SCTP_BASE_SYSCTL(sctp_L2_abc_variable))) {
2058 net->cwnd += (net->mtu * SCTP_BASE_SYSCTL(sctp_L2_abc_variable));
2059 if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_CWND_MONITOR_ENABLE) {
2060 sctp_log_cwnd(stcb, net, net->mtu,
2061 SCTP_CWND_LOG_FROM_SS);
2062 }
2063
2064 } else {
2065 net->cwnd += net->net_ack;
2066 if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_CWND_MONITOR_ENABLE) {
2067 sctp_log_cwnd(stcb, net, net->net_ack,
2068 SCTP_CWND_LOG_FROM_SS);
2069 }
2070
2071 }
2072 sctp_enforce_cwnd_limit(&stcb->asoc, net);
2073 } else {
2074 if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_CWND_LOGGING_ENABLE) {
2075 sctp_log_cwnd(stcb, net, net->net_ack,
2076 SCTP_CWND_LOG_NOADV_SS);
2077 }
2078 }
2079 } else {
2080 measure_rtt(net);
2081
2082 /*
2083 * In dangerous area, increase slowly. In theory this is
2084 * net->cwnd += alpha / net->cwnd
2085 */
2086 /* What is snd_cwnd_cnt?? */
2087 if (((net->partial_bytes_acked / net->mtu * net->cc_mod.htcp_ca.alpha) >> 7) * net->mtu >= net->cwnd) {
2088 /*-
2089 * Does SCTP have a cwnd clamp?
2090 * if (net->snd_cwnd < net->snd_cwnd_clamp) - Nope (RRS).
2091 */
2092 net->cwnd += net->mtu;
2093 net->partial_bytes_acked = 0;
2094 sctp_enforce_cwnd_limit(&stcb->asoc, net);
2095 htcp_alpha_update(&net->cc_mod.htcp_ca);
2096 if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_CWND_MONITOR_ENABLE) {
2097 sctp_log_cwnd(stcb, net, net->mtu,
2098 SCTP_CWND_LOG_FROM_CA);
2099 }
2100 } else {
2101 net->partial_bytes_acked += net->net_ack;
2102 if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_CWND_LOGGING_ENABLE) {
2103 sctp_log_cwnd(stcb, net, net->net_ack,
2104 SCTP_CWND_LOG_NOADV_CA);
2105 }
2106 }
2107
2108 net->cc_mod.htcp_ca.bytes_acked = net->mtu;
2109 }
2110 }
2111
2112 #ifdef SCTP_NOT_USED
2113 /* Lower bound on congestion window. */
2114 static uint32_t
htcp_min_cwnd(struct sctp_tcb * stcb,struct sctp_nets * net)2115 htcp_min_cwnd(struct sctp_tcb *stcb, struct sctp_nets *net)
2116 {
2117 return (net->ssthresh);
2118 }
2119 #endif
2120
2121 static void
htcp_init(struct sctp_nets * net)2122 htcp_init(struct sctp_nets *net)
2123 {
2124 memset(&net->cc_mod.htcp_ca, 0, sizeof(struct htcp));
2125 net->cc_mod.htcp_ca.alpha = ALPHA_BASE;
2126 net->cc_mod.htcp_ca.beta = BETA_MIN;
2127 net->cc_mod.htcp_ca.bytes_acked = net->mtu;
2128 net->cc_mod.htcp_ca.last_cong = sctp_get_tick_count();
2129 }
2130
2131 static void
sctp_htcp_set_initial_cc_param(struct sctp_tcb * stcb,struct sctp_nets * net)2132 sctp_htcp_set_initial_cc_param(struct sctp_tcb *stcb, struct sctp_nets *net)
2133 {
2134 /*
2135 * We take the max of the burst limit times a MTU or the
2136 * INITIAL_CWND. We then limit this to 4 MTU's of sending.
2137 */
2138 net->cwnd = min((net->mtu * 4), max((2 * net->mtu), SCTP_INITIAL_CWND));
2139 net->ssthresh = stcb->asoc.peers_rwnd;
2140 sctp_enforce_cwnd_limit(&stcb->asoc, net);
2141 htcp_init(net);
2142
2143 if (SCTP_BASE_SYSCTL(sctp_logging_level) & (SCTP_CWND_MONITOR_ENABLE | SCTP_CWND_LOGGING_ENABLE)) {
2144 sctp_log_cwnd(stcb, net, 0, SCTP_CWND_INITIALIZATION);
2145 }
2146 }
2147
2148 static void
sctp_htcp_cwnd_update_after_sack(struct sctp_tcb * stcb,struct sctp_association * asoc,int accum_moved,int reneged_all SCTP_UNUSED,int will_exit)2149 sctp_htcp_cwnd_update_after_sack(struct sctp_tcb *stcb,
2150 struct sctp_association *asoc,
2151 int accum_moved, int reneged_all SCTP_UNUSED, int will_exit)
2152 {
2153 struct sctp_nets *net;
2154
2155 /******************************/
2156 /* update cwnd and Early FR */
2157 /******************************/
2158 TAILQ_FOREACH(net, &asoc->nets, sctp_next) {
2159
2160 #ifdef JANA_CMT_FAST_RECOVERY
2161 /*
2162 * CMT fast recovery code. Need to debug.
2163 */
2164 if (net->fast_retran_loss_recovery && net->new_pseudo_cumack) {
2165 if (SCTP_TSN_GE(asoc->last_acked_seq, net->fast_recovery_tsn) ||
2166 SCTP_TSN_GE(net->pseudo_cumack, net->fast_recovery_tsn)) {
2167 net->will_exit_fast_recovery = 1;
2168 }
2169 }
2170 #endif
2171 /* if nothing was acked on this destination skip it */
2172 if (net->net_ack == 0) {
2173 if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_CWND_LOGGING_ENABLE) {
2174 sctp_log_cwnd(stcb, net, 0, SCTP_CWND_LOG_FROM_SACK);
2175 }
2176 continue;
2177 }
2178 #ifdef JANA_CMT_FAST_RECOVERY
2179 /*
2180 * CMT fast recovery code
2181 */
2182 /*
2183 * if (sctp_cmt_on_off > 0 && net->fast_retran_loss_recovery
2184 * && net->will_exit_fast_recovery == 0) { @@@ Do something
2185 * } else if (sctp_cmt_on_off == 0 &&
2186 * asoc->fast_retran_loss_recovery && will_exit == 0) {
2187 */
2188 #endif
2189
2190 if (asoc->fast_retran_loss_recovery &&
2191 will_exit == 0 &&
2192 (asoc->sctp_cmt_on_off == 0)) {
2193 /*
2194 * If we are in loss recovery we skip any cwnd
2195 * update
2196 */
2197 return;
2198 }
2199 /*
2200 * CMT: CUC algorithm. Update cwnd if pseudo-cumack has
2201 * moved.
2202 */
2203 if (accum_moved ||
2204 ((asoc->sctp_cmt_on_off > 0) && net->new_pseudo_cumack)) {
2205 htcp_cong_avoid(stcb, net);
2206 measure_achieved_throughput(net);
2207 } else {
2208 if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_CWND_LOGGING_ENABLE) {
2209 sctp_log_cwnd(stcb, net, net->mtu,
2210 SCTP_CWND_LOG_NO_CUMACK);
2211 }
2212 }
2213 }
2214 }
2215
2216 static void
sctp_htcp_cwnd_update_after_fr(struct sctp_tcb * stcb,struct sctp_association * asoc)2217 sctp_htcp_cwnd_update_after_fr(struct sctp_tcb *stcb,
2218 struct sctp_association *asoc)
2219 {
2220 struct sctp_nets *net;
2221
2222 /*
2223 * CMT fast recovery code. Need to debug. ((sctp_cmt_on_off > 0) &&
2224 * (net->fast_retran_loss_recovery == 0)))
2225 */
2226 TAILQ_FOREACH(net, &asoc->nets, sctp_next) {
2227 if ((asoc->fast_retran_loss_recovery == 0) ||
2228 (asoc->sctp_cmt_on_off > 0)) {
2229 /* out of a RFC2582 Fast recovery window? */
2230 if (net->net_ack > 0) {
2231 /*
2232 * per section 7.2.3, are there any
2233 * destinations that had a fast retransmit
2234 * to them. If so what we need to do is
2235 * adjust ssthresh and cwnd.
2236 */
2237 struct sctp_tmit_chunk *lchk;
2238 int old_cwnd = net->cwnd;
2239
2240 /* JRS - reset as if state were changed */
2241 htcp_reset(&net->cc_mod.htcp_ca);
2242 net->ssthresh = htcp_recalc_ssthresh(net);
2243 net->cwnd = net->ssthresh;
2244 sctp_enforce_cwnd_limit(asoc, net);
2245 if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_CWND_MONITOR_ENABLE) {
2246 sctp_log_cwnd(stcb, net, (net->cwnd - old_cwnd),
2247 SCTP_CWND_LOG_FROM_FR);
2248 }
2249 lchk = TAILQ_FIRST(&asoc->send_queue);
2250
2251 net->partial_bytes_acked = 0;
2252 /* Turn on fast recovery window */
2253 asoc->fast_retran_loss_recovery = 1;
2254 if (lchk == NULL) {
2255 /* Mark end of the window */
2256 asoc->fast_recovery_tsn = asoc->sending_seq - 1;
2257 } else {
2258 asoc->fast_recovery_tsn = lchk->rec.data.tsn - 1;
2259 }
2260
2261 /*
2262 * CMT fast recovery -- per destination
2263 * recovery variable.
2264 */
2265 net->fast_retran_loss_recovery = 1;
2266
2267 if (lchk == NULL) {
2268 /* Mark end of the window */
2269 net->fast_recovery_tsn = asoc->sending_seq - 1;
2270 } else {
2271 net->fast_recovery_tsn = lchk->rec.data.tsn - 1;
2272 }
2273
2274 sctp_timer_stop(SCTP_TIMER_TYPE_SEND,
2275 stcb->sctp_ep, stcb, net,
2276 SCTP_FROM_SCTP_CC_FUNCTIONS + SCTP_LOC_3);
2277 sctp_timer_start(SCTP_TIMER_TYPE_SEND,
2278 stcb->sctp_ep, stcb, net);
2279 }
2280 } else if (net->net_ack > 0) {
2281 /*
2282 * Mark a peg that we WOULD have done a cwnd
2283 * reduction but RFC2582 prevented this action.
2284 */
2285 SCTP_STAT_INCR(sctps_fastretransinrtt);
2286 }
2287 }
2288 }
2289
2290 static void
sctp_htcp_cwnd_update_after_timeout(struct sctp_tcb * stcb,struct sctp_nets * net)2291 sctp_htcp_cwnd_update_after_timeout(struct sctp_tcb *stcb,
2292 struct sctp_nets *net)
2293 {
2294 int old_cwnd = net->cwnd;
2295
2296 /* JRS - reset as if the state were being changed to timeout */
2297 htcp_reset(&net->cc_mod.htcp_ca);
2298 net->ssthresh = htcp_recalc_ssthresh(net);
2299 net->cwnd = net->mtu;
2300 net->partial_bytes_acked = 0;
2301 if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_CWND_MONITOR_ENABLE) {
2302 sctp_log_cwnd(stcb, net, net->cwnd - old_cwnd, SCTP_CWND_LOG_FROM_RTX);
2303 }
2304 }
2305
2306 static void
sctp_htcp_cwnd_update_after_ecn_echo(struct sctp_tcb * stcb,struct sctp_nets * net,int in_window,int num_pkt_lost SCTP_UNUSED)2307 sctp_htcp_cwnd_update_after_ecn_echo(struct sctp_tcb *stcb,
2308 struct sctp_nets *net, int in_window, int num_pkt_lost SCTP_UNUSED)
2309 {
2310 int old_cwnd;
2311
2312 old_cwnd = net->cwnd;
2313
2314 /* JRS - reset hctp as if state changed */
2315 if (in_window == 0) {
2316 htcp_reset(&net->cc_mod.htcp_ca);
2317 SCTP_STAT_INCR(sctps_ecnereducedcwnd);
2318 net->ssthresh = htcp_recalc_ssthresh(net);
2319 if (net->ssthresh < net->mtu) {
2320 net->ssthresh = net->mtu;
2321 /* here back off the timer as well, to slow us down */
2322 net->RTO <<= 1;
2323 }
2324 net->cwnd = net->ssthresh;
2325 sctp_enforce_cwnd_limit(&stcb->asoc, net);
2326 if (SCTP_BASE_SYSCTL(sctp_logging_level) & SCTP_CWND_MONITOR_ENABLE) {
2327 sctp_log_cwnd(stcb, net, (net->cwnd - old_cwnd), SCTP_CWND_LOG_FROM_SAT);
2328 }
2329 }
2330 }
2331
2332 const struct sctp_cc_functions sctp_cc_functions[] = {
2333 {
2334 .sctp_set_initial_cc_param = sctp_set_initial_cc_param,
2335 .sctp_cwnd_update_after_sack = sctp_cwnd_update_after_sack,
2336 .sctp_cwnd_update_exit_pf = sctp_cwnd_update_exit_pf_common,
2337 .sctp_cwnd_update_after_fr = sctp_cwnd_update_after_fr,
2338 .sctp_cwnd_update_after_timeout = sctp_cwnd_update_after_timeout,
2339 .sctp_cwnd_update_after_ecn_echo = sctp_cwnd_update_after_ecn_echo,
2340 .sctp_cwnd_update_after_packet_dropped = sctp_cwnd_update_after_packet_dropped,
2341 .sctp_cwnd_update_after_output = sctp_cwnd_update_after_output,
2342 },
2343 {
2344 .sctp_set_initial_cc_param = sctp_set_initial_cc_param,
2345 .sctp_cwnd_update_after_sack = sctp_hs_cwnd_update_after_sack,
2346 .sctp_cwnd_update_exit_pf = sctp_cwnd_update_exit_pf_common,
2347 .sctp_cwnd_update_after_fr = sctp_hs_cwnd_update_after_fr,
2348 .sctp_cwnd_update_after_timeout = sctp_cwnd_update_after_timeout,
2349 .sctp_cwnd_update_after_ecn_echo = sctp_cwnd_update_after_ecn_echo,
2350 .sctp_cwnd_update_after_packet_dropped = sctp_cwnd_update_after_packet_dropped,
2351 .sctp_cwnd_update_after_output = sctp_cwnd_update_after_output,
2352 },
2353 {
2354 .sctp_set_initial_cc_param = sctp_htcp_set_initial_cc_param,
2355 .sctp_cwnd_update_after_sack = sctp_htcp_cwnd_update_after_sack,
2356 .sctp_cwnd_update_exit_pf = sctp_cwnd_update_exit_pf_common,
2357 .sctp_cwnd_update_after_fr = sctp_htcp_cwnd_update_after_fr,
2358 .sctp_cwnd_update_after_timeout = sctp_htcp_cwnd_update_after_timeout,
2359 .sctp_cwnd_update_after_ecn_echo = sctp_htcp_cwnd_update_after_ecn_echo,
2360 .sctp_cwnd_update_after_packet_dropped = sctp_cwnd_update_after_packet_dropped,
2361 .sctp_cwnd_update_after_output = sctp_cwnd_update_after_output,
2362 },
2363 {
2364 .sctp_set_initial_cc_param = sctp_set_rtcc_initial_cc_param,
2365 .sctp_cwnd_update_after_sack = sctp_cwnd_update_rtcc_after_sack,
2366 .sctp_cwnd_update_exit_pf = sctp_cwnd_update_exit_pf_common,
2367 .sctp_cwnd_update_after_fr = sctp_cwnd_update_after_fr,
2368 .sctp_cwnd_update_after_timeout = sctp_cwnd_update_after_timeout,
2369 .sctp_cwnd_update_after_ecn_echo = sctp_cwnd_update_rtcc_after_ecn_echo,
2370 .sctp_cwnd_update_after_packet_dropped = sctp_cwnd_update_after_packet_dropped,
2371 .sctp_cwnd_update_after_output = sctp_cwnd_update_after_output,
2372 .sctp_cwnd_update_packet_transmitted = sctp_cwnd_update_rtcc_packet_transmitted,
2373 .sctp_cwnd_update_tsn_acknowledged = sctp_cwnd_update_rtcc_tsn_acknowledged,
2374 .sctp_cwnd_new_transmission_begins = sctp_cwnd_new_rtcc_transmission_begins,
2375 .sctp_cwnd_prepare_net_for_sack = sctp_cwnd_prepare_rtcc_net_for_sack,
2376 .sctp_cwnd_socket_option = sctp_cwnd_rtcc_socket_option,
2377 .sctp_rtt_calculated = sctp_rtt_rtcc_calculated
2378 }
2379 };
2380