1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 22 /* 23 * Copyright (c) 2017 by Delphix. All rights reserved. 24 */ 25 26 /* 27 * The TCP congestion control algorithm extracted from the pre-framework 28 * implementation of TCP congestion control. 29 */ 30 31 #include <sys/errno.h> 32 #include <inet/tcp.h> 33 #include <inet/tcp_impl.h> 34 #include <inet/cc.h> 35 #include <inet/cc/cc_module.h> 36 37 static void sunreno_ack_received(struct cc_var *ccv, uint16_t type); 38 static void sunreno_after_idle(struct cc_var *ccv); 39 static void sunreno_cong_signal(struct cc_var *ccv, uint32_t type); 40 static void sunreno_post_recovery(struct cc_var *ccv); 41 42 #define CC_SUNRENO_ALGO_NAME "sunreno" 43 44 static struct modlmisc cc_sunreno_modlmisc = { 45 &mod_miscops, 46 "SUNReno Congestion Control" 47 }; 48 49 static struct modlinkage cc_sunreno_modlinkage = { 50 MODREV_1, 51 &cc_sunreno_modlmisc, 52 NULL 53 }; 54 55 struct cc_algo sunreno_cc_algo = { 56 .name = CC_SUNRENO_ALGO_NAME, 57 .ack_received = sunreno_ack_received, 58 .after_idle = sunreno_after_idle, 59 .cong_signal = sunreno_cong_signal, 60 .post_recovery = sunreno_post_recovery, 61 }; 62 63 int 64 _init(void) 65 { 66 int err; 67 68 if ((err = cc_register_algo(&sunreno_cc_algo)) == 0) { 69 if ((err = mod_install(&cc_sunreno_modlinkage)) != 0) 70 (void) cc_deregister_algo(&sunreno_cc_algo); 71 } 72 return (err); 73 } 74 75 int 76 _fini(void) 77 { 78 return (EBUSY); 79 } 80 81 int 82 _info(struct modinfo *modinfop) 83 { 84 return (mod_info(&cc_sunreno_modlinkage, modinfop)); 85 } 86 87 static void 88 sunreno_ack_received(struct cc_var *ccv, uint16_t type) 89 { 90 uint32_t add; 91 uint32_t cwnd; 92 int mss; 93 94 if (type == CC_ACK && !IN_RECOVERY(ccv->flags)) { 95 mss = CCV(ccv, tcp_mss); 96 cwnd = CCV(ccv, tcp_cwnd); 97 add = mss; 98 99 if (cwnd >= CCV(ccv, tcp_cwnd_ssthresh)) { 100 /* 101 * This is to prevent an increase of less than 1 MSS of 102 * tcp_cwnd. With partial increase, tcp_wput_data() 103 * may send out tinygrams in order to preserve mblk 104 * boundaries. 105 * 106 * By initializing tcp_cwnd_cnt to new tcp_cwnd and 107 * decrementing it by 1 MSS for every ACKs, tcp_cwnd is 108 * increased by 1 MSS for every RTTs. 109 */ 110 if (CCV(ccv, tcp_cwnd_cnt) <= 0) { 111 CCV(ccv, tcp_cwnd_cnt) = cwnd + add; 112 } else { 113 CCV(ccv, tcp_cwnd_cnt) -= add; 114 add = 0; 115 } 116 } 117 CCV(ccv, tcp_cwnd) = MIN(cwnd + add, CCV(ccv, tcp_cwnd_max)); 118 } 119 } 120 121 static void 122 sunreno_after_idle(struct cc_var *ccv) 123 { 124 int32_t num_sack_blk = 0; 125 int mss; 126 127 if (CCV(ccv, tcp_snd_sack_ok) && CCV(ccv, tcp_num_sack_blk) > 0) { 128 int32_t opt_len; 129 130 num_sack_blk = MIN(CCV(ccv, tcp_max_sack_blk), 131 CCV(ccv, tcp_num_sack_blk)); 132 opt_len = num_sack_blk * sizeof (sack_blk_t) + TCPOPT_NOP_LEN * 133 2 + TCPOPT_HEADER_LEN; 134 mss = CCV(ccv, tcp_mss) - opt_len; 135 } else { 136 mss = CCV(ccv, tcp_mss); 137 } 138 139 TCP_SET_INIT_CWND(CCV_PROTO(ccv), mss, 140 CCSV(ccv, tcps_slow_start_after_idle)); 141 } 142 143 /* 144 * Perform any necessary tasks before we enter congestion recovery. 145 */ 146 static void 147 sunreno_cong_signal(struct cc_var *ccv, uint32_t type) 148 { 149 int npkt; 150 int mss; 151 152 /* Catch algos which mistakenly leak private signal types. */ 153 ASSERT((type & CC_SIGPRIVMASK) == 0); 154 155 mss = CCV(ccv, tcp_mss); 156 npkt = ((CCV(ccv, tcp_snxt) - CCV(ccv, tcp_suna)) >> 1) / mss; 157 158 switch (type) { 159 case CC_NDUPACK: 160 if (!IN_FASTRECOVERY(ccv->flags)) { 161 if (!IN_CONGRECOVERY(ccv->flags)) { 162 CCV(ccv, tcp_cwnd_ssthresh) = MAX(npkt, 2) * 163 mss; 164 CCV(ccv, tcp_cwnd) = (npkt + 165 CCV(ccv, tcp_dupack_cnt)) * mss; 166 } 167 ENTER_RECOVERY(ccv->flags); 168 } 169 break; 170 case CC_ECN: 171 if (!IN_CONGRECOVERY(ccv->flags) && !CCV(ccv, tcp_cwr)) { 172 CCV(ccv, tcp_cwnd_ssthresh) = MAX(npkt, 2) * mss; 173 CCV(ccv, tcp_cwnd) = npkt * mss; 174 if (CCV(ccv, tcp_cwnd) == 0) { 175 /* 176 * This makes sure that when the ACK comes 177 * back, we will increase tcp_cwnd by 1 MSS. 178 */ 179 CCV(ccv, tcp_cwnd_cnt) = 0; 180 } 181 ENTER_CONGRECOVERY(ccv->flags); 182 } 183 break; 184 case CC_RTO: 185 /* 186 * After retransmission, we need to do slow start. Set the 187 * ssthresh to one half of current effective window and cwnd to 188 * one MSS. Also reset tcp_cwnd_cnt. 189 * 190 * Note that if tcp_ssthresh is reduced because of ECN, do not 191 * reduce it again unless it is already one window of data away 192 * (tcp_cwr should then be cleared) or this is a timeout for a 193 * retransmitted segment. 194 */ 195 if (!CCV(ccv, tcp_cwr) || CCV(ccv, tcp_rexmit)) { 196 if (CCV(ccv, tcp_timer_backoff) != 0) 197 npkt = CCV(ccv, tcp_cwnd_ssthresh) / 2 / mss; 198 CCV(ccv, tcp_cwnd_ssthresh) = MAX(npkt, 2) * mss; 199 } 200 CCV(ccv, tcp_cwnd) = mss; 201 CCV(ccv, tcp_cwnd_cnt) = 0; 202 break; 203 } 204 } 205 206 /* 207 * Perform any necessary tasks before we exit congestion recovery. 208 */ 209 static void 210 sunreno_post_recovery(struct cc_var *ccv) 211 { 212 /* 213 * Restore the congestion window back to ssthresh as per RFC 5681 214 * section 3.2. 215 */ 216 if (IN_FASTRECOVERY(ccv->flags)) { 217 if (CCV(ccv, tcp_cwnd) > CCV(ccv, tcp_cwnd_ssthresh)) { 218 CCV(ccv, tcp_cwnd) = CCV(ccv, tcp_cwnd_ssthresh); 219 } 220 } 221 CCV(ccv, tcp_cwnd_cnt) = 0; 222 } 223