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