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