Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1 | /* SCTP kernel reference Implementation |
| 2 | * Copyright (c) 1999-2000 Cisco, Inc. |
| 3 | * Copyright (c) 1999-2001 Motorola, Inc. |
| 4 | * Copyright (c) 2001-2003 International Business Machines Corp. |
| 5 | * Copyright (c) 2001 Intel Corp. |
| 6 | * Copyright (c) 2001 La Monte H.P. Yarroll |
| 7 | * |
| 8 | * This file is part of the SCTP kernel reference Implementation |
| 9 | * |
| 10 | * This module provides the abstraction for an SCTP tranport representing |
| 11 | * a remote transport address. For local transport addresses, we just use |
| 12 | * union sctp_addr. |
| 13 | * |
| 14 | * The SCTP reference implementation is free software; |
| 15 | * you can redistribute it and/or modify it under the terms of |
| 16 | * the GNU General Public License as published by |
| 17 | * the Free Software Foundation; either version 2, or (at your option) |
| 18 | * any later version. |
| 19 | * |
| 20 | * The SCTP reference implementation is distributed in the hope that it |
| 21 | * will be useful, but WITHOUT ANY WARRANTY; without even the implied |
| 22 | * ************************ |
| 23 | * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. |
| 24 | * See the GNU General Public License for more details. |
| 25 | * |
| 26 | * You should have received a copy of the GNU General Public License |
| 27 | * along with GNU CC; see the file COPYING. If not, write to |
| 28 | * the Free Software Foundation, 59 Temple Place - Suite 330, |
| 29 | * Boston, MA 02111-1307, USA. |
| 30 | * |
| 31 | * Please send any bug reports or fixes you make to the |
| 32 | * email address(es): |
| 33 | * lksctp developers <lksctp-developers@lists.sourceforge.net> |
| 34 | * |
| 35 | * Or submit a bug report through the following website: |
| 36 | * http://www.sf.net/projects/lksctp |
| 37 | * |
| 38 | * Written or modified by: |
| 39 | * La Monte H.P. Yarroll <piggy@acm.org> |
| 40 | * Karl Knutson <karl@athena.chicago.il.us> |
| 41 | * Jon Grimm <jgrimm@us.ibm.com> |
| 42 | * Xingang Guo <xingang.guo@intel.com> |
| 43 | * Hui Huang <hui.huang@nokia.com> |
| 44 | * Sridhar Samudrala <sri@us.ibm.com> |
| 45 | * Ardelle Fan <ardelle.fan@intel.com> |
| 46 | * |
| 47 | * Any bugs reported given to us we will try to fix... any fixes shared will |
| 48 | * be incorporated into the next SCTP release. |
| 49 | */ |
| 50 | |
| 51 | #include <linux/types.h> |
Sridhar Samudrala | ad8fec1 | 2006-07-21 14:48:50 -0700 | [diff] [blame] | 52 | #include <linux/random.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 53 | #include <net/sctp/sctp.h> |
| 54 | #include <net/sctp/sm.h> |
| 55 | |
| 56 | /* 1st Level Abstractions. */ |
| 57 | |
| 58 | /* Initialize a new transport from provided memory. */ |
| 59 | static struct sctp_transport *sctp_transport_init(struct sctp_transport *peer, |
| 60 | const union sctp_addr *addr, |
Al Viro | dd0fc66 | 2005-10-07 07:46:04 +0100 | [diff] [blame] | 61 | gfp_t gfp) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 62 | { |
| 63 | /* Copy in the address. */ |
Al Viro | 09ef7fe | 2006-11-20 17:04:10 -0800 | [diff] [blame] | 64 | peer->ipaddr_h = *addr; |
Al Viro | 2a6fd78 | 2006-11-20 17:04:42 -0800 | [diff] [blame^] | 65 | flip_to_n(&peer->ipaddr, &peer->ipaddr_h); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 66 | peer->af_specific = sctp_get_af_specific(addr->sa.sa_family); |
| 67 | peer->asoc = NULL; |
| 68 | |
| 69 | peer->dst = NULL; |
Al Viro | 2a6fd78 | 2006-11-20 17:04:42 -0800 | [diff] [blame^] | 70 | memset(&peer->saddr, 0, sizeof(union sctp_addr)); |
Al Viro | 09ef7fe | 2006-11-20 17:04:10 -0800 | [diff] [blame] | 71 | memset(&peer->saddr_h, 0, sizeof(union sctp_addr)); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 72 | |
| 73 | /* From 6.3.1 RTO Calculation: |
| 74 | * |
| 75 | * C1) Until an RTT measurement has been made for a packet sent to the |
| 76 | * given destination transport address, set RTO to the protocol |
| 77 | * parameter 'RTO.Initial'. |
| 78 | */ |
| 79 | peer->rtt = 0; |
Vladislav Yasevich | 3fd091e | 2006-08-22 13:29:17 -0700 | [diff] [blame] | 80 | peer->rto = msecs_to_jiffies(sctp_rto_initial); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 81 | peer->rttvar = 0; |
| 82 | peer->srtt = 0; |
| 83 | peer->rto_pending = 0; |
| 84 | |
| 85 | peer->last_time_heard = jiffies; |
| 86 | peer->last_time_used = jiffies; |
| 87 | peer->last_time_ecne_reduced = jiffies; |
| 88 | |
Frank Filz | 3f7a87d | 2005-06-20 13:14:57 -0700 | [diff] [blame] | 89 | peer->init_sent_count = 0; |
| 90 | |
Frank Filz | 52ccb8e | 2005-12-22 11:36:46 -0800 | [diff] [blame] | 91 | peer->param_flags = SPP_HB_DISABLE | |
| 92 | SPP_PMTUD_ENABLE | |
| 93 | SPP_SACKDELAY_ENABLE; |
| 94 | peer->hbinterval = 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 95 | |
| 96 | /* Initialize the default path max_retrans. */ |
Frank Filz | 52ccb8e | 2005-12-22 11:36:46 -0800 | [diff] [blame] | 97 | peer->pathmaxrxt = sctp_max_retrans_path; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 98 | peer->error_count = 0; |
| 99 | |
| 100 | INIT_LIST_HEAD(&peer->transmitted); |
| 101 | INIT_LIST_HEAD(&peer->send_ready); |
| 102 | INIT_LIST_HEAD(&peer->transports); |
| 103 | |
| 104 | /* Set up the retransmission timer. */ |
| 105 | init_timer(&peer->T3_rtx_timer); |
| 106 | peer->T3_rtx_timer.function = sctp_generate_t3_rtx_event; |
| 107 | peer->T3_rtx_timer.data = (unsigned long)peer; |
| 108 | |
| 109 | /* Set up the heartbeat timer. */ |
| 110 | init_timer(&peer->hb_timer); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 111 | peer->hb_timer.function = sctp_generate_heartbeat_event; |
| 112 | peer->hb_timer.data = (unsigned long)peer; |
| 113 | |
Sridhar Samudrala | ad8fec1 | 2006-07-21 14:48:50 -0700 | [diff] [blame] | 114 | /* Initialize the 64-bit random nonce sent with heartbeat. */ |
| 115 | get_random_bytes(&peer->hb_nonce, sizeof(peer->hb_nonce)); |
| 116 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 117 | atomic_set(&peer->refcnt, 1); |
| 118 | peer->dead = 0; |
| 119 | |
| 120 | peer->malloced = 0; |
| 121 | |
| 122 | /* Initialize the state information for SFR-CACC */ |
| 123 | peer->cacc.changeover_active = 0; |
| 124 | peer->cacc.cycling_changeover = 0; |
| 125 | peer->cacc.next_tsn_at_change = 0; |
| 126 | peer->cacc.cacc_saw_newack = 0; |
| 127 | |
| 128 | return peer; |
| 129 | } |
| 130 | |
| 131 | /* Allocate and initialize a new transport. */ |
Alexey Dobriyan | 3182cd8 | 2005-07-11 20:57:47 -0700 | [diff] [blame] | 132 | struct sctp_transport *sctp_transport_new(const union sctp_addr *addr, |
Al Viro | dd0fc66 | 2005-10-07 07:46:04 +0100 | [diff] [blame] | 133 | gfp_t gfp) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 134 | { |
| 135 | struct sctp_transport *transport; |
| 136 | |
| 137 | transport = t_new(struct sctp_transport, gfp); |
| 138 | if (!transport) |
| 139 | goto fail; |
| 140 | |
| 141 | if (!sctp_transport_init(transport, addr, gfp)) |
| 142 | goto fail_init; |
| 143 | |
| 144 | transport->malloced = 1; |
| 145 | SCTP_DBG_OBJCNT_INC(transport); |
| 146 | |
| 147 | return transport; |
| 148 | |
| 149 | fail_init: |
| 150 | kfree(transport); |
| 151 | |
| 152 | fail: |
| 153 | return NULL; |
| 154 | } |
| 155 | |
| 156 | /* This transport is no longer needed. Free up if possible, or |
| 157 | * delay until it last reference count. |
| 158 | */ |
| 159 | void sctp_transport_free(struct sctp_transport *transport) |
| 160 | { |
| 161 | transport->dead = 1; |
| 162 | |
| 163 | /* Try to delete the heartbeat timer. */ |
| 164 | if (del_timer(&transport->hb_timer)) |
| 165 | sctp_transport_put(transport); |
| 166 | |
| 167 | /* Delete the T3_rtx timer if it's active. |
| 168 | * There is no point in not doing this now and letting |
| 169 | * structure hang around in memory since we know |
| 170 | * the tranport is going away. |
| 171 | */ |
| 172 | if (timer_pending(&transport->T3_rtx_timer) && |
| 173 | del_timer(&transport->T3_rtx_timer)) |
| 174 | sctp_transport_put(transport); |
| 175 | |
| 176 | |
| 177 | sctp_transport_put(transport); |
| 178 | } |
| 179 | |
| 180 | /* Destroy the transport data structure. |
| 181 | * Assumes there are no more users of this structure. |
| 182 | */ |
| 183 | static void sctp_transport_destroy(struct sctp_transport *transport) |
| 184 | { |
| 185 | SCTP_ASSERT(transport->dead, "Transport is not dead", return); |
| 186 | |
| 187 | if (transport->asoc) |
| 188 | sctp_association_put(transport->asoc); |
| 189 | |
| 190 | sctp_packet_free(&transport->packet); |
| 191 | |
| 192 | dst_release(transport->dst); |
| 193 | kfree(transport); |
| 194 | SCTP_DBG_OBJCNT_DEC(transport); |
| 195 | } |
| 196 | |
| 197 | /* Start T3_rtx timer if it is not already running and update the heartbeat |
| 198 | * timer. This routine is called every time a DATA chunk is sent. |
| 199 | */ |
| 200 | void sctp_transport_reset_timers(struct sctp_transport *transport) |
| 201 | { |
| 202 | /* RFC 2960 6.3.2 Retransmission Timer Rules |
| 203 | * |
| 204 | * R1) Every time a DATA chunk is sent to any address(including a |
| 205 | * retransmission), if the T3-rtx timer of that address is not running |
| 206 | * start it running so that it will expire after the RTO of that |
| 207 | * address. |
| 208 | */ |
| 209 | |
| 210 | if (!timer_pending(&transport->T3_rtx_timer)) |
| 211 | if (!mod_timer(&transport->T3_rtx_timer, |
| 212 | jiffies + transport->rto)) |
| 213 | sctp_transport_hold(transport); |
| 214 | |
| 215 | /* When a data chunk is sent, reset the heartbeat interval. */ |
| 216 | if (!mod_timer(&transport->hb_timer, |
| 217 | sctp_transport_timeout(transport))) |
| 218 | sctp_transport_hold(transport); |
| 219 | } |
| 220 | |
| 221 | /* This transport has been assigned to an association. |
| 222 | * Initialize fields from the association or from the sock itself. |
| 223 | * Register the reference count in the association. |
| 224 | */ |
| 225 | void sctp_transport_set_owner(struct sctp_transport *transport, |
| 226 | struct sctp_association *asoc) |
| 227 | { |
| 228 | transport->asoc = asoc; |
| 229 | sctp_association_hold(asoc); |
| 230 | } |
| 231 | |
| 232 | /* Initialize the pmtu of a transport. */ |
| 233 | void sctp_transport_pmtu(struct sctp_transport *transport) |
| 234 | { |
| 235 | struct dst_entry *dst; |
| 236 | |
Al Viro | 09ef7fe | 2006-11-20 17:04:10 -0800 | [diff] [blame] | 237 | dst = transport->af_specific->get_dst(NULL, &transport->ipaddr_h, NULL); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 238 | |
| 239 | if (dst) { |
Frank Filz | 52ccb8e | 2005-12-22 11:36:46 -0800 | [diff] [blame] | 240 | transport->pathmtu = dst_mtu(dst); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 241 | dst_release(dst); |
| 242 | } else |
Frank Filz | 52ccb8e | 2005-12-22 11:36:46 -0800 | [diff] [blame] | 243 | transport->pathmtu = SCTP_DEFAULT_MAXSEGMENT; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 244 | } |
| 245 | |
| 246 | /* Caches the dst entry and source address for a transport's destination |
| 247 | * address. |
| 248 | */ |
| 249 | void sctp_transport_route(struct sctp_transport *transport, |
| 250 | union sctp_addr *saddr, struct sctp_sock *opt) |
| 251 | { |
| 252 | struct sctp_association *asoc = transport->asoc; |
| 253 | struct sctp_af *af = transport->af_specific; |
Al Viro | 09ef7fe | 2006-11-20 17:04:10 -0800 | [diff] [blame] | 254 | union sctp_addr *daddr = &transport->ipaddr_h; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 255 | struct dst_entry *dst; |
| 256 | |
| 257 | dst = af->get_dst(asoc, daddr, saddr); |
| 258 | |
| 259 | if (saddr) |
Al Viro | 09ef7fe | 2006-11-20 17:04:10 -0800 | [diff] [blame] | 260 | memcpy(&transport->saddr_h, saddr, sizeof(union sctp_addr)); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 261 | else |
Al Viro | 09ef7fe | 2006-11-20 17:04:10 -0800 | [diff] [blame] | 262 | af->get_saddr(asoc, dst, daddr, &transport->saddr_h); |
Al Viro | 2a6fd78 | 2006-11-20 17:04:42 -0800 | [diff] [blame^] | 263 | flip_to_n(&transport->saddr, &transport->saddr_h); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 264 | |
| 265 | transport->dst = dst; |
Frank Filz | 52ccb8e | 2005-12-22 11:36:46 -0800 | [diff] [blame] | 266 | if ((transport->param_flags & SPP_PMTUD_DISABLE) && transport->pathmtu) { |
| 267 | return; |
| 268 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 269 | if (dst) { |
Frank Filz | 52ccb8e | 2005-12-22 11:36:46 -0800 | [diff] [blame] | 270 | transport->pathmtu = dst_mtu(dst); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 271 | |
| 272 | /* Initialize sk->sk_rcv_saddr, if the transport is the |
| 273 | * association's active path for getsockname(). |
| 274 | */ |
| 275 | if (asoc && (transport == asoc->peer.active_path)) |
Al Viro | 09ef7fe | 2006-11-20 17:04:10 -0800 | [diff] [blame] | 276 | opt->pf->af->to_sk_saddr(&transport->saddr_h, |
Neil Horman | bf031ff | 2005-12-02 20:32:29 -0800 | [diff] [blame] | 277 | asoc->base.sk); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 278 | } else |
Frank Filz | 52ccb8e | 2005-12-22 11:36:46 -0800 | [diff] [blame] | 279 | transport->pathmtu = SCTP_DEFAULT_MAXSEGMENT; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 280 | } |
| 281 | |
| 282 | /* Hold a reference to a transport. */ |
| 283 | void sctp_transport_hold(struct sctp_transport *transport) |
| 284 | { |
| 285 | atomic_inc(&transport->refcnt); |
| 286 | } |
| 287 | |
| 288 | /* Release a reference to a transport and clean up |
| 289 | * if there are no more references. |
| 290 | */ |
| 291 | void sctp_transport_put(struct sctp_transport *transport) |
| 292 | { |
| 293 | if (atomic_dec_and_test(&transport->refcnt)) |
| 294 | sctp_transport_destroy(transport); |
| 295 | } |
| 296 | |
| 297 | /* Update transport's RTO based on the newly calculated RTT. */ |
| 298 | void sctp_transport_update_rto(struct sctp_transport *tp, __u32 rtt) |
| 299 | { |
| 300 | /* Check for valid transport. */ |
| 301 | SCTP_ASSERT(tp, "NULL transport", return); |
| 302 | |
| 303 | /* We should not be doing any RTO updates unless rto_pending is set. */ |
| 304 | SCTP_ASSERT(tp->rto_pending, "rto_pending not set", return); |
| 305 | |
| 306 | if (tp->rttvar || tp->srtt) { |
| 307 | /* 6.3.1 C3) When a new RTT measurement R' is made, set |
| 308 | * RTTVAR <- (1 - RTO.Beta) * RTTVAR + RTO.Beta * |SRTT - R'| |
| 309 | * SRTT <- (1 - RTO.Alpha) * SRTT + RTO.Alpha * R' |
| 310 | */ |
| 311 | |
| 312 | /* Note: The above algorithm has been rewritten to |
| 313 | * express rto_beta and rto_alpha as inverse powers |
| 314 | * of two. |
| 315 | * For example, assuming the default value of RTO.Alpha of |
| 316 | * 1/8, rto_alpha would be expressed as 3. |
| 317 | */ |
| 318 | tp->rttvar = tp->rttvar - (tp->rttvar >> sctp_rto_beta) |
| 319 | + ((abs(tp->srtt - rtt)) >> sctp_rto_beta); |
| 320 | tp->srtt = tp->srtt - (tp->srtt >> sctp_rto_alpha) |
| 321 | + (rtt >> sctp_rto_alpha); |
| 322 | } else { |
| 323 | /* 6.3.1 C2) When the first RTT measurement R is made, set |
| 324 | * SRTT <- R, RTTVAR <- R/2. |
| 325 | */ |
| 326 | tp->srtt = rtt; |
| 327 | tp->rttvar = rtt >> 1; |
| 328 | } |
| 329 | |
| 330 | /* 6.3.1 G1) Whenever RTTVAR is computed, if RTTVAR = 0, then |
| 331 | * adjust RTTVAR <- G, where G is the CLOCK GRANULARITY. |
| 332 | */ |
| 333 | if (tp->rttvar == 0) |
| 334 | tp->rttvar = SCTP_CLOCK_GRANULARITY; |
| 335 | |
| 336 | /* 6.3.1 C3) After the computation, update RTO <- SRTT + 4 * RTTVAR. */ |
| 337 | tp->rto = tp->srtt + (tp->rttvar << 2); |
| 338 | |
| 339 | /* 6.3.1 C6) Whenever RTO is computed, if it is less than RTO.Min |
| 340 | * seconds then it is rounded up to RTO.Min seconds. |
| 341 | */ |
| 342 | if (tp->rto < tp->asoc->rto_min) |
| 343 | tp->rto = tp->asoc->rto_min; |
| 344 | |
| 345 | /* 6.3.1 C7) A maximum value may be placed on RTO provided it is |
| 346 | * at least RTO.max seconds. |
| 347 | */ |
| 348 | if (tp->rto > tp->asoc->rto_max) |
| 349 | tp->rto = tp->asoc->rto_max; |
| 350 | |
| 351 | tp->rtt = rtt; |
| 352 | |
| 353 | /* Reset rto_pending so that a new RTT measurement is started when a |
| 354 | * new data chunk is sent. |
| 355 | */ |
| 356 | tp->rto_pending = 0; |
| 357 | |
| 358 | SCTP_DEBUG_PRINTK("%s: transport: %p, rtt: %d, srtt: %d " |
Vlad Yasevich | 8116ffa | 2006-01-17 11:55:17 -0800 | [diff] [blame] | 359 | "rttvar: %d, rto: %ld\n", __FUNCTION__, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 360 | tp, rtt, tp->srtt, tp->rttvar, tp->rto); |
| 361 | } |
| 362 | |
| 363 | /* This routine updates the transport's cwnd and partial_bytes_acked |
| 364 | * parameters based on the bytes acked in the received SACK. |
| 365 | */ |
| 366 | void sctp_transport_raise_cwnd(struct sctp_transport *transport, |
| 367 | __u32 sack_ctsn, __u32 bytes_acked) |
| 368 | { |
| 369 | __u32 cwnd, ssthresh, flight_size, pba, pmtu; |
| 370 | |
| 371 | cwnd = transport->cwnd; |
| 372 | flight_size = transport->flight_size; |
| 373 | |
| 374 | /* The appropriate cwnd increase algorithm is performed if, and only |
| 375 | * if the cumulative TSN has advanced and the congestion window is |
| 376 | * being fully utilized. |
| 377 | */ |
| 378 | if ((transport->asoc->ctsn_ack_point >= sack_ctsn) || |
| 379 | (flight_size < cwnd)) |
| 380 | return; |
| 381 | |
| 382 | ssthresh = transport->ssthresh; |
| 383 | pba = transport->partial_bytes_acked; |
Frank Filz | 52ccb8e | 2005-12-22 11:36:46 -0800 | [diff] [blame] | 384 | pmtu = transport->asoc->pathmtu; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 385 | |
| 386 | if (cwnd <= ssthresh) { |
| 387 | /* RFC 2960 7.2.1, sctpimpguide-05 2.14.2 When cwnd is less |
| 388 | * than or equal to ssthresh an SCTP endpoint MUST use the |
| 389 | * slow start algorithm to increase cwnd only if the current |
| 390 | * congestion window is being fully utilized and an incoming |
| 391 | * SACK advances the Cumulative TSN Ack Point. Only when these |
| 392 | * two conditions are met can the cwnd be increased otherwise |
| 393 | * the cwnd MUST not be increased. If these conditions are met |
| 394 | * then cwnd MUST be increased by at most the lesser of |
| 395 | * 1) the total size of the previously outstanding DATA |
| 396 | * chunk(s) acknowledged, and 2) the destination's path MTU. |
| 397 | */ |
| 398 | if (bytes_acked > pmtu) |
| 399 | cwnd += pmtu; |
| 400 | else |
| 401 | cwnd += bytes_acked; |
| 402 | SCTP_DEBUG_PRINTK("%s: SLOW START: transport: %p, " |
| 403 | "bytes_acked: %d, cwnd: %d, ssthresh: %d, " |
| 404 | "flight_size: %d, pba: %d\n", |
| 405 | __FUNCTION__, |
| 406 | transport, bytes_acked, cwnd, |
| 407 | ssthresh, flight_size, pba); |
| 408 | } else { |
| 409 | /* RFC 2960 7.2.2 Whenever cwnd is greater than ssthresh, |
| 410 | * upon each SACK arrival that advances the Cumulative TSN Ack |
| 411 | * Point, increase partial_bytes_acked by the total number of |
| 412 | * bytes of all new chunks acknowledged in that SACK including |
| 413 | * chunks acknowledged by the new Cumulative TSN Ack and by |
| 414 | * Gap Ack Blocks. |
| 415 | * |
| 416 | * When partial_bytes_acked is equal to or greater than cwnd |
| 417 | * and before the arrival of the SACK the sender had cwnd or |
| 418 | * more bytes of data outstanding (i.e., before arrival of the |
| 419 | * SACK, flightsize was greater than or equal to cwnd), |
| 420 | * increase cwnd by MTU, and reset partial_bytes_acked to |
| 421 | * (partial_bytes_acked - cwnd). |
| 422 | */ |
| 423 | pba += bytes_acked; |
| 424 | if (pba >= cwnd) { |
| 425 | cwnd += pmtu; |
| 426 | pba = ((cwnd < pba) ? (pba - cwnd) : 0); |
| 427 | } |
| 428 | SCTP_DEBUG_PRINTK("%s: CONGESTION AVOIDANCE: " |
| 429 | "transport: %p, bytes_acked: %d, cwnd: %d, " |
| 430 | "ssthresh: %d, flight_size: %d, pba: %d\n", |
| 431 | __FUNCTION__, |
| 432 | transport, bytes_acked, cwnd, |
| 433 | ssthresh, flight_size, pba); |
| 434 | } |
| 435 | |
| 436 | transport->cwnd = cwnd; |
| 437 | transport->partial_bytes_acked = pba; |
| 438 | } |
| 439 | |
| 440 | /* This routine is used to lower the transport's cwnd when congestion is |
| 441 | * detected. |
| 442 | */ |
| 443 | void sctp_transport_lower_cwnd(struct sctp_transport *transport, |
| 444 | sctp_lower_cwnd_t reason) |
| 445 | { |
| 446 | switch (reason) { |
| 447 | case SCTP_LOWER_CWND_T3_RTX: |
| 448 | /* RFC 2960 Section 7.2.3, sctpimpguide |
| 449 | * When the T3-rtx timer expires on an address, SCTP should |
| 450 | * perform slow start by: |
| 451 | * ssthresh = max(cwnd/2, 4*MTU) |
| 452 | * cwnd = 1*MTU |
| 453 | * partial_bytes_acked = 0 |
| 454 | */ |
| 455 | transport->ssthresh = max(transport->cwnd/2, |
Frank Filz | 52ccb8e | 2005-12-22 11:36:46 -0800 | [diff] [blame] | 456 | 4*transport->asoc->pathmtu); |
| 457 | transport->cwnd = transport->asoc->pathmtu; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 458 | break; |
| 459 | |
| 460 | case SCTP_LOWER_CWND_FAST_RTX: |
| 461 | /* RFC 2960 7.2.4 Adjust the ssthresh and cwnd of the |
| 462 | * destination address(es) to which the missing DATA chunks |
| 463 | * were last sent, according to the formula described in |
| 464 | * Section 7.2.3. |
| 465 | * |
| 466 | * RFC 2960 7.2.3, sctpimpguide Upon detection of packet |
| 467 | * losses from SACK (see Section 7.2.4), An endpoint |
| 468 | * should do the following: |
| 469 | * ssthresh = max(cwnd/2, 4*MTU) |
| 470 | * cwnd = ssthresh |
| 471 | * partial_bytes_acked = 0 |
| 472 | */ |
| 473 | transport->ssthresh = max(transport->cwnd/2, |
Frank Filz | 52ccb8e | 2005-12-22 11:36:46 -0800 | [diff] [blame] | 474 | 4*transport->asoc->pathmtu); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 475 | transport->cwnd = transport->ssthresh; |
| 476 | break; |
| 477 | |
| 478 | case SCTP_LOWER_CWND_ECNE: |
| 479 | /* RFC 2481 Section 6.1.2. |
| 480 | * If the sender receives an ECN-Echo ACK packet |
| 481 | * then the sender knows that congestion was encountered in the |
| 482 | * network on the path from the sender to the receiver. The |
| 483 | * indication of congestion should be treated just as a |
| 484 | * congestion loss in non-ECN Capable TCP. That is, the TCP |
| 485 | * source halves the congestion window "cwnd" and reduces the |
| 486 | * slow start threshold "ssthresh". |
| 487 | * A critical condition is that TCP does not react to |
| 488 | * congestion indications more than once every window of |
| 489 | * data (or more loosely more than once every round-trip time). |
| 490 | */ |
| 491 | if ((jiffies - transport->last_time_ecne_reduced) > |
| 492 | transport->rtt) { |
| 493 | transport->ssthresh = max(transport->cwnd/2, |
Frank Filz | 52ccb8e | 2005-12-22 11:36:46 -0800 | [diff] [blame] | 494 | 4*transport->asoc->pathmtu); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 495 | transport->cwnd = transport->ssthresh; |
| 496 | transport->last_time_ecne_reduced = jiffies; |
| 497 | } |
| 498 | break; |
| 499 | |
| 500 | case SCTP_LOWER_CWND_INACTIVE: |
| 501 | /* RFC 2960 Section 7.2.1, sctpimpguide |
| 502 | * When the endpoint does not transmit data on a given |
| 503 | * transport address, the cwnd of the transport address |
| 504 | * should be adjusted to max(cwnd/2, 4*MTU) per RTO. |
| 505 | * NOTE: Although the draft recommends that this check needs |
| 506 | * to be done every RTO interval, we do it every hearbeat |
| 507 | * interval. |
| 508 | */ |
| 509 | if ((jiffies - transport->last_time_used) > transport->rto) |
| 510 | transport->cwnd = max(transport->cwnd/2, |
Frank Filz | 52ccb8e | 2005-12-22 11:36:46 -0800 | [diff] [blame] | 511 | 4*transport->asoc->pathmtu); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 512 | break; |
| 513 | }; |
| 514 | |
| 515 | transport->partial_bytes_acked = 0; |
| 516 | SCTP_DEBUG_PRINTK("%s: transport: %p reason: %d cwnd: " |
| 517 | "%d ssthresh: %d\n", __FUNCTION__, |
| 518 | transport, reason, |
| 519 | transport->cwnd, transport->ssthresh); |
| 520 | } |
| 521 | |
| 522 | /* What is the next timeout value for this transport? */ |
| 523 | unsigned long sctp_transport_timeout(struct sctp_transport *t) |
| 524 | { |
| 525 | unsigned long timeout; |
Sridhar Samudrala | ad8fec1 | 2006-07-21 14:48:50 -0700 | [diff] [blame] | 526 | timeout = t->rto + sctp_jitter(t->rto); |
| 527 | if (t->state != SCTP_UNCONFIRMED) |
| 528 | timeout += t->hbinterval; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 529 | timeout += jiffies; |
| 530 | return timeout; |
| 531 | } |