1 /*- 2 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD 3 * 4 * Copyright (c) 2007-2008 5 * Swinburne University of Technology, Melbourne, Australia. 6 * Copyright (c) 2009-2010 Lawrence Stewart <lstewart@freebsd.org> 7 * Copyright (c) 2010 The FreeBSD Foundation 8 * All rights reserved. 9 * 10 * This software was developed at the Centre for Advanced Internet 11 * Architectures, Swinburne University of Technology, by Lawrence Stewart and 12 * James Healy, made possible in part by a grant from the Cisco University 13 * Research Program Fund at Community Foundation Silicon Valley. 14 * 15 * Portions of this software were developed at the Centre for Advanced 16 * Internet Architectures, Swinburne University of Technology, Melbourne, 17 * Australia by David Hayes under sponsorship from the FreeBSD Foundation. 18 * 19 * Redistribution and use in source and binary forms, with or without 20 * modification, are permitted provided that the following conditions 21 * are met: 22 * 1. Redistributions of source code must retain the above copyright 23 * notice, this list of conditions and the following disclaimer. 24 * 2. Redistributions in binary form must reproduce the above copyright 25 * notice, this list of conditions and the following disclaimer in the 26 * documentation and/or other materials provided with the distribution. 27 * 28 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 29 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 30 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 31 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 32 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 33 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 34 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 35 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 36 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 37 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 38 * SUCH DAMAGE. 39 */ 40 41 /* 42 * This software was first released in 2007 by James Healy and Lawrence Stewart 43 * whilst working on the NewTCP research project at Swinburne University of 44 * Technology's Centre for Advanced Internet Architectures, Melbourne, 45 * Australia, which was made possible in part by a grant from the Cisco 46 * University Research Program Fund at Community Foundation Silicon Valley. 47 * More details are available at: 48 * http://caia.swin.edu.au/urp/newtcp/ 49 */ 50 51 #include <sys/cdefs.h> 52 __FBSDID("$FreeBSD$"); 53 #include <opt_cc.h> 54 #include <sys/param.h> 55 #include <sys/kernel.h> 56 #include <sys/libkern.h> 57 #include <sys/lock.h> 58 #include <sys/malloc.h> 59 #include <sys/module.h> 60 #include <sys/mutex.h> 61 #include <sys/queue.h> 62 #include <sys/rwlock.h> 63 #include <sys/sbuf.h> 64 #include <sys/socket.h> 65 #include <sys/socketvar.h> 66 #include <sys/sysctl.h> 67 68 #include <net/vnet.h> 69 70 #include <netinet/in.h> 71 #include <netinet/in_pcb.h> 72 #include <netinet/tcp.h> 73 #include <netinet/tcp_seq.h> 74 #include <netinet/tcp_var.h> 75 #include <netinet/tcp_log_buf.h> 76 #include <netinet/tcp_hpts.h> 77 #include <netinet/cc/cc.h> 78 #include <netinet/cc/cc_module.h> 79 80 /* 81 * Have a sane default if no CC_DEFAULT is specified in the kernel config file. 82 */ 83 #ifndef CC_DEFAULT 84 #define CC_DEFAULT "newreno" 85 #endif 86 87 uint32_t hystart_minrtt_thresh = 4000; 88 uint32_t hystart_maxrtt_thresh = 16000; 89 uint32_t hystart_n_rttsamples = 8; 90 uint32_t hystart_css_growth_div = 4; 91 uint32_t hystart_css_rounds = 5; 92 uint32_t hystart_bblogs = 0; 93 94 MALLOC_DEFINE(M_CC_MEM, "CC Mem", "Congestion Control State memory"); 95 96 /* 97 * List of available cc algorithms on the current system. First element 98 * is used as the system default CC algorithm. 99 */ 100 struct cc_head cc_list = STAILQ_HEAD_INITIALIZER(cc_list); 101 102 /* Protects the cc_list TAILQ. */ 103 struct rwlock cc_list_lock; 104 105 VNET_DEFINE(struct cc_algo *, default_cc_ptr) = NULL; 106 107 VNET_DEFINE(uint32_t, newreno_beta) = 50; 108 #define V_newreno_beta VNET(newreno_beta) 109 110 /* 111 * Sysctl handler to show and change the default CC algorithm. 112 */ 113 static int 114 cc_default_algo(SYSCTL_HANDLER_ARGS) 115 { 116 char default_cc[TCP_CA_NAME_MAX]; 117 struct cc_algo *funcs; 118 int error; 119 120 /* Get the current default: */ 121 CC_LIST_RLOCK(); 122 if (CC_DEFAULT_ALGO() != NULL) 123 strlcpy(default_cc, CC_DEFAULT_ALGO()->name, sizeof(default_cc)); 124 else 125 memset(default_cc, 0, TCP_CA_NAME_MAX); 126 CC_LIST_RUNLOCK(); 127 128 error = sysctl_handle_string(oidp, default_cc, sizeof(default_cc), req); 129 130 /* Check for error or no change */ 131 if (error != 0 || req->newptr == NULL) 132 goto done; 133 134 error = ESRCH; 135 /* Find algo with specified name and set it to default. */ 136 CC_LIST_RLOCK(); 137 STAILQ_FOREACH(funcs, &cc_list, entries) { 138 if (strncmp(default_cc, funcs->name, sizeof(default_cc))) 139 continue; 140 V_default_cc_ptr = funcs; 141 error = 0; 142 break; 143 } 144 CC_LIST_RUNLOCK(); 145 done: 146 return (error); 147 } 148 149 /* 150 * Sysctl handler to display the list of available CC algorithms. 151 */ 152 static int 153 cc_list_available(SYSCTL_HANDLER_ARGS) 154 { 155 struct cc_algo *algo; 156 struct sbuf *s; 157 int err, first, nalgos; 158 159 err = nalgos = 0; 160 first = 1; 161 162 CC_LIST_RLOCK(); 163 STAILQ_FOREACH(algo, &cc_list, entries) { 164 nalgos++; 165 } 166 CC_LIST_RUNLOCK(); 167 if (nalgos == 0) { 168 return (ENOENT); 169 } 170 s = sbuf_new(NULL, NULL, nalgos * TCP_CA_NAME_MAX, SBUF_FIXEDLEN); 171 172 if (s == NULL) 173 return (ENOMEM); 174 175 /* 176 * It is theoretically possible for the CC list to have grown in size 177 * since the call to sbuf_new() and therefore for the sbuf to be too 178 * small. If this were to happen (incredibly unlikely), the sbuf will 179 * reach an overflow condition, sbuf_printf() will return an error and 180 * the sysctl will fail gracefully. 181 */ 182 CC_LIST_RLOCK(); 183 STAILQ_FOREACH(algo, &cc_list, entries) { 184 err = sbuf_printf(s, first ? "%s" : ", %s", algo->name); 185 if (err) { 186 /* Sbuf overflow condition. */ 187 err = EOVERFLOW; 188 break; 189 } 190 first = 0; 191 } 192 CC_LIST_RUNLOCK(); 193 194 if (!err) { 195 sbuf_finish(s); 196 err = sysctl_handle_string(oidp, sbuf_data(s), 0, req); 197 } 198 199 sbuf_delete(s); 200 return (err); 201 } 202 203 /* 204 * Return the number of times a proposed removal_cc is 205 * being used as the default. 206 */ 207 static int 208 cc_check_default(struct cc_algo *remove_cc) 209 { 210 int cnt = 0; 211 VNET_ITERATOR_DECL(vnet_iter); 212 213 CC_LIST_LOCK_ASSERT(); 214 215 VNET_LIST_RLOCK_NOSLEEP(); 216 VNET_FOREACH(vnet_iter) { 217 CURVNET_SET(vnet_iter); 218 if ((CC_DEFAULT_ALGO() != NULL) && 219 strncmp(CC_DEFAULT_ALGO()->name, 220 remove_cc->name, 221 TCP_CA_NAME_MAX) == 0) { 222 cnt++; 223 } 224 CURVNET_RESTORE(); 225 } 226 VNET_LIST_RUNLOCK_NOSLEEP(); 227 return (cnt); 228 } 229 230 /* 231 * Initialise CC subsystem on system boot. 232 */ 233 static void 234 cc_init(void) 235 { 236 CC_LIST_LOCK_INIT(); 237 STAILQ_INIT(&cc_list); 238 } 239 240 /* 241 * Returns non-zero on success, 0 on failure. 242 */ 243 int 244 cc_deregister_algo(struct cc_algo *remove_cc) 245 { 246 struct cc_algo *funcs, *tmpfuncs; 247 int err; 248 249 err = ENOENT; 250 251 /* Remove algo from cc_list so that new connections can't use it. */ 252 CC_LIST_WLOCK(); 253 STAILQ_FOREACH_SAFE(funcs, &cc_list, entries, tmpfuncs) { 254 if (funcs == remove_cc) { 255 if (cc_check_default(remove_cc)) { 256 CC_LIST_WUNLOCK(); 257 return(EBUSY); 258 } 259 break; 260 } 261 } 262 remove_cc->flags |= CC_MODULE_BEING_REMOVED; 263 CC_LIST_WUNLOCK(); 264 err = tcp_ccalgounload(remove_cc); 265 /* 266 * Now back through and we either remove the temp flag 267 * or pull the registration. 268 */ 269 CC_LIST_WLOCK(); 270 STAILQ_FOREACH_SAFE(funcs, &cc_list, entries, tmpfuncs) { 271 if (funcs == remove_cc) { 272 if (err == 0) 273 STAILQ_REMOVE(&cc_list, funcs, cc_algo, entries); 274 else 275 funcs->flags &= ~CC_MODULE_BEING_REMOVED; 276 break; 277 } 278 } 279 CC_LIST_WUNLOCK(); 280 return (err); 281 } 282 283 /* 284 * Returns 0 on success, non-zero on failure. 285 */ 286 int 287 cc_register_algo(struct cc_algo *add_cc) 288 { 289 struct cc_algo *funcs; 290 int err; 291 292 err = 0; 293 294 /* 295 * Iterate over list of registered CC algorithms and make sure 296 * we're not trying to add a duplicate. 297 */ 298 CC_LIST_WLOCK(); 299 STAILQ_FOREACH(funcs, &cc_list, entries) { 300 if (funcs == add_cc || 301 strncmp(funcs->name, add_cc->name, 302 TCP_CA_NAME_MAX) == 0) { 303 err = EEXIST; 304 break; 305 } 306 } 307 /* 308 * The first loaded congestion control module will become 309 * the default until we find the "CC_DEFAULT" defined in 310 * the config (if we do). 311 */ 312 if (!err) { 313 STAILQ_INSERT_TAIL(&cc_list, add_cc, entries); 314 if (strcmp(add_cc->name, CC_DEFAULT) == 0) { 315 V_default_cc_ptr = add_cc; 316 } else if (V_default_cc_ptr == NULL) { 317 V_default_cc_ptr = add_cc; 318 } 319 } 320 CC_LIST_WUNLOCK(); 321 322 return (err); 323 } 324 325 static void 326 vnet_cc_sysinit(void *arg) 327 { 328 struct cc_algo *cc; 329 330 if (IS_DEFAULT_VNET(curvnet)) 331 return; 332 333 CURVNET_SET(vnet0); 334 cc = V_default_cc_ptr; 335 CURVNET_RESTORE(); 336 337 V_default_cc_ptr = cc; 338 } 339 VNET_SYSINIT(vnet_cc_sysinit, SI_SUB_PROTO_IFATTACHDOMAIN, SI_ORDER_ANY, 340 vnet_cc_sysinit, NULL); 341 342 /* 343 * Perform any necessary tasks before we exit congestion recovery. 344 */ 345 void 346 newreno_cc_post_recovery(struct cc_var *ccv) 347 { 348 int pipe; 349 350 if (IN_FASTRECOVERY(CCV(ccv, t_flags))) { 351 /* 352 * Fast recovery will conclude after returning from this 353 * function. Window inflation should have left us with 354 * approximately snd_ssthresh outstanding data. But in case we 355 * would be inclined to send a burst, better to do it via the 356 * slow start mechanism. 357 * 358 * XXXLAS: Find a way to do this without needing curack 359 */ 360 if (V_tcp_do_newsack) 361 pipe = tcp_compute_pipe(ccv->ccvc.tcp); 362 else 363 pipe = CCV(ccv, snd_max) - ccv->curack; 364 if (pipe < CCV(ccv, snd_ssthresh)) 365 /* 366 * Ensure that cwnd does not collapse to 1 MSS under 367 * adverse conditions. Implements RFC6582 368 */ 369 CCV(ccv, snd_cwnd) = max(pipe, CCV(ccv, t_maxseg)) + 370 CCV(ccv, t_maxseg); 371 else 372 CCV(ccv, snd_cwnd) = CCV(ccv, snd_ssthresh); 373 } 374 } 375 376 void 377 newreno_cc_after_idle(struct cc_var *ccv) 378 { 379 uint32_t rw; 380 /* 381 * If we've been idle for more than one retransmit timeout the old 382 * congestion window is no longer current and we have to reduce it to 383 * the restart window before we can transmit again. 384 * 385 * The restart window is the initial window or the last CWND, whichever 386 * is smaller. 387 * 388 * This is done to prevent us from flooding the path with a full CWND at 389 * wirespeed, overloading router and switch buffers along the way. 390 * 391 * See RFC5681 Section 4.1. "Restarting Idle Connections". 392 * 393 * In addition, per RFC2861 Section 2, the ssthresh is set to the 394 * maximum of the former ssthresh or 3/4 of the old cwnd, to 395 * not exit slow-start prematurely. 396 */ 397 rw = tcp_compute_initwnd(tcp_maxseg(ccv->ccvc.tcp)); 398 399 CCV(ccv, snd_ssthresh) = max(CCV(ccv, snd_ssthresh), 400 CCV(ccv, snd_cwnd)-(CCV(ccv, snd_cwnd)>>2)); 401 402 CCV(ccv, snd_cwnd) = min(rw, CCV(ccv, snd_cwnd)); 403 } 404 405 /* 406 * Perform any necessary tasks before we enter congestion recovery. 407 */ 408 void 409 newreno_cc_cong_signal(struct cc_var *ccv, uint32_t type) 410 { 411 uint32_t cwin, factor; 412 u_int mss; 413 414 cwin = CCV(ccv, snd_cwnd); 415 mss = tcp_fixed_maxseg(ccv->ccvc.tcp); 416 /* 417 * Other TCP congestion controls use newreno_cong_signal(), but 418 * with their own private cc_data. Make sure the cc_data is used 419 * correctly. 420 */ 421 factor = V_newreno_beta; 422 423 /* Catch algos which mistakenly leak private signal types. */ 424 KASSERT((type & CC_SIGPRIVMASK) == 0, 425 ("%s: congestion signal type 0x%08x is private\n", __func__, type)); 426 427 cwin = max(((uint64_t)cwin * (uint64_t)factor) / (100ULL * (uint64_t)mss), 428 2) * mss; 429 430 switch (type) { 431 case CC_NDUPACK: 432 if (!IN_FASTRECOVERY(CCV(ccv, t_flags))) { 433 if (!IN_CONGRECOVERY(CCV(ccv, t_flags))) 434 CCV(ccv, snd_ssthresh) = cwin; 435 ENTER_RECOVERY(CCV(ccv, t_flags)); 436 } 437 break; 438 case CC_ECN: 439 if (!IN_CONGRECOVERY(CCV(ccv, t_flags))) { 440 CCV(ccv, snd_ssthresh) = cwin; 441 CCV(ccv, snd_cwnd) = cwin; 442 ENTER_CONGRECOVERY(CCV(ccv, t_flags)); 443 } 444 break; 445 case CC_RTO: 446 CCV(ccv, snd_ssthresh) = max(min(CCV(ccv, snd_wnd), 447 CCV(ccv, snd_cwnd)) / 2 / mss, 448 2) * mss; 449 CCV(ccv, snd_cwnd) = mss; 450 break; 451 } 452 } 453 454 void 455 newreno_cc_ack_received(struct cc_var *ccv, uint16_t type) 456 { 457 if (type == CC_ACK && !IN_RECOVERY(CCV(ccv, t_flags)) && 458 (ccv->flags & CCF_CWND_LIMITED)) { 459 u_int cw = CCV(ccv, snd_cwnd); 460 u_int incr = CCV(ccv, t_maxseg); 461 462 /* 463 * Regular in-order ACK, open the congestion window. 464 * Method depends on which congestion control state we're 465 * in (slow start or cong avoid) and if ABC (RFC 3465) is 466 * enabled. 467 * 468 * slow start: cwnd <= ssthresh 469 * cong avoid: cwnd > ssthresh 470 * 471 * slow start and ABC (RFC 3465): 472 * Grow cwnd exponentially by the amount of data 473 * ACKed capping the max increment per ACK to 474 * (abc_l_var * maxseg) bytes. 475 * 476 * slow start without ABC (RFC 5681): 477 * Grow cwnd exponentially by maxseg per ACK. 478 * 479 * cong avoid and ABC (RFC 3465): 480 * Grow cwnd linearly by maxseg per RTT for each 481 * cwnd worth of ACKed data. 482 * 483 * cong avoid without ABC (RFC 5681): 484 * Grow cwnd linearly by approximately maxseg per RTT using 485 * maxseg^2 / cwnd per ACK as the increment. 486 * If cwnd > maxseg^2, fix the cwnd increment at 1 byte to 487 * avoid capping cwnd. 488 */ 489 if (cw > CCV(ccv, snd_ssthresh)) { 490 if (V_tcp_do_rfc3465) { 491 if (ccv->flags & CCF_ABC_SENTAWND) 492 ccv->flags &= ~CCF_ABC_SENTAWND; 493 else 494 incr = 0; 495 } else 496 incr = max((incr * incr / cw), 1); 497 } else if (V_tcp_do_rfc3465) { 498 /* 499 * In slow-start with ABC enabled and no RTO in sight? 500 * (Must not use abc_l_var > 1 if slow starting after 501 * an RTO. On RTO, snd_nxt = snd_una, so the 502 * snd_nxt == snd_max check is sufficient to 503 * handle this). 504 * 505 * XXXLAS: Find a way to signal SS after RTO that 506 * doesn't rely on tcpcb vars. 507 */ 508 uint16_t abc_val; 509 510 if (ccv->flags & CCF_USE_LOCAL_ABC) 511 abc_val = ccv->labc; 512 else 513 abc_val = V_tcp_abc_l_var; 514 if (CCV(ccv, snd_nxt) == CCV(ccv, snd_max)) 515 incr = min(ccv->bytes_this_ack, 516 ccv->nsegs * abc_val * 517 CCV(ccv, t_maxseg)); 518 else 519 incr = min(ccv->bytes_this_ack, CCV(ccv, t_maxseg)); 520 521 } 522 /* ABC is on by default, so incr equals 0 frequently. */ 523 if (incr > 0) 524 CCV(ccv, snd_cwnd) = min(cw + incr, 525 TCP_MAXWIN << CCV(ccv, snd_scale)); 526 } 527 } 528 529 /* 530 * Handles kld related events. Returns 0 on success, non-zero on failure. 531 */ 532 int 533 cc_modevent(module_t mod, int event_type, void *data) 534 { 535 struct cc_algo *algo; 536 int err; 537 538 err = 0; 539 algo = (struct cc_algo *)data; 540 541 switch(event_type) { 542 case MOD_LOAD: 543 if ((algo->cc_data_sz == NULL) && (algo->cb_init != NULL)) { 544 /* 545 * A module must have a cc_data_sz function 546 * even if it has no data it should return 0. 547 */ 548 printf("Module Load Fails, it lacks a cc_data_sz() function but has a cb_init()!\n"); 549 err = EINVAL; 550 break; 551 } 552 if (algo->mod_init != NULL) 553 err = algo->mod_init(); 554 if (!err) 555 err = cc_register_algo(algo); 556 break; 557 558 case MOD_QUIESCE: 559 case MOD_SHUTDOWN: 560 case MOD_UNLOAD: 561 err = cc_deregister_algo(algo); 562 if (!err && algo->mod_destroy != NULL) 563 algo->mod_destroy(); 564 if (err == ENOENT) 565 err = 0; 566 break; 567 568 default: 569 err = EINVAL; 570 break; 571 } 572 573 return (err); 574 } 575 576 SYSINIT(cc, SI_SUB_PROTO_IFATTACHDOMAIN, SI_ORDER_FIRST, cc_init, NULL); 577 578 /* Declare sysctl tree and populate it. */ 579 SYSCTL_NODE(_net_inet_tcp, OID_AUTO, cc, CTLFLAG_RW | CTLFLAG_MPSAFE, NULL, 580 "Congestion control related settings"); 581 582 SYSCTL_PROC(_net_inet_tcp_cc, OID_AUTO, algorithm, 583 CTLFLAG_VNET | CTLTYPE_STRING | CTLFLAG_RW | CTLFLAG_MPSAFE, 584 NULL, 0, cc_default_algo, "A", 585 "Default congestion control algorithm"); 586 587 SYSCTL_PROC(_net_inet_tcp_cc, OID_AUTO, available, 588 CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_MPSAFE, 589 NULL, 0, cc_list_available, "A", 590 "List available congestion control algorithms"); 591 592 SYSCTL_NODE(_net_inet_tcp_cc, OID_AUTO, hystartplusplus, 593 CTLFLAG_RW | CTLFLAG_MPSAFE, NULL, 594 "New Reno related HyStart++ settings"); 595 596 SYSCTL_UINT(_net_inet_tcp_cc_hystartplusplus, OID_AUTO, minrtt_thresh, 597 CTLFLAG_RW, 598 &hystart_minrtt_thresh, 4000, 599 "HyStarts++ minimum RTT thresh used in clamp (in microseconds)"); 600 601 SYSCTL_UINT(_net_inet_tcp_cc_hystartplusplus, OID_AUTO, maxrtt_thresh, 602 CTLFLAG_RW, 603 &hystart_maxrtt_thresh, 16000, 604 "HyStarts++ maximum RTT thresh used in clamp (in microseconds)"); 605 606 SYSCTL_UINT(_net_inet_tcp_cc_hystartplusplus, OID_AUTO, n_rttsamples, 607 CTLFLAG_RW, 608 &hystart_n_rttsamples, 8, 609 "The number of RTT samples that must be seen to consider HyStart++"); 610 611 SYSCTL_UINT(_net_inet_tcp_cc_hystartplusplus, OID_AUTO, css_growth_div, 612 CTLFLAG_RW, 613 &hystart_css_growth_div, 4, 614 "The divisor to the growth when in Hystart++ CSS"); 615 616 SYSCTL_UINT(_net_inet_tcp_cc_hystartplusplus, OID_AUTO, css_rounds, 617 CTLFLAG_RW, 618 &hystart_css_rounds, 5, 619 "The number of rounds HyStart++ lasts in CSS before falling to CA"); 620 621 SYSCTL_UINT(_net_inet_tcp_cc_hystartplusplus, OID_AUTO, bblogs, 622 CTLFLAG_RW, 623 &hystart_bblogs, 0, 624 "Do we enable HyStart++ Black Box logs to be generated if BB logging is on"); 625 626 VNET_DEFINE(int, cc_do_abe) = 0; 627 SYSCTL_INT(_net_inet_tcp_cc, OID_AUTO, abe, CTLFLAG_VNET | CTLFLAG_RW, 628 &VNET_NAME(cc_do_abe), 0, 629 "Enable draft-ietf-tcpm-alternativebackoff-ecn (TCP Alternative Backoff with ECN)"); 630 631 VNET_DEFINE(int, cc_abe_frlossreduce) = 0; 632 SYSCTL_INT(_net_inet_tcp_cc, OID_AUTO, abe_frlossreduce, CTLFLAG_VNET | CTLFLAG_RW, 633 &VNET_NAME(cc_abe_frlossreduce), 0, 634 "Apply standard beta instead of ABE-beta during ECN-signalled congestion " 635 "recovery episodes if loss also needs to be repaired"); 636