1 /* SCTP kernel 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 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 * This SCTP 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 * This SCTP 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, see 28 * <http://www.gnu.org/licenses/>. 29 * 30 * Please send any bug reports or fixes you make to the 31 * email address(es): 32 * lksctp developers <linux-sctp@vger.kernel.org> 33 * 34 * Written or modified by: 35 * La Monte H.P. Yarroll <piggy@acm.org> 36 * Karl Knutson <karl@athena.chicago.il.us> 37 * Jon Grimm <jgrimm@us.ibm.com> 38 * Xingang Guo <xingang.guo@intel.com> 39 * Hui Huang <hui.huang@nokia.com> 40 * Sridhar Samudrala <sri@us.ibm.com> 41 * Ardelle Fan <ardelle.fan@intel.com> 42 */ 43 44 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 45 46 #include <linux/slab.h> 47 #include <linux/types.h> 48 #include <linux/random.h> 49 #include <net/sctp/sctp.h> 50 #include <net/sctp/sm.h> 51 52 /* 1st Level Abstractions. */ 53 54 /* Initialize a new transport from provided memory. */ 55 static struct sctp_transport *sctp_transport_init(struct net *net, 56 struct sctp_transport *peer, 57 const union sctp_addr *addr, 58 gfp_t gfp) 59 { 60 /* Copy in the address. */ 61 peer->ipaddr = *addr; 62 peer->af_specific = sctp_get_af_specific(addr->sa.sa_family); 63 memset(&peer->saddr, 0, sizeof(union sctp_addr)); 64 65 peer->sack_generation = 0; 66 67 /* From 6.3.1 RTO Calculation: 68 * 69 * C1) Until an RTT measurement has been made for a packet sent to the 70 * given destination transport address, set RTO to the protocol 71 * parameter 'RTO.Initial'. 72 */ 73 peer->rto = msecs_to_jiffies(net->sctp.rto_initial); 74 75 peer->last_time_heard = 0; 76 peer->last_time_ecne_reduced = jiffies; 77 78 peer->param_flags = SPP_HB_DISABLE | 79 SPP_PMTUD_ENABLE | 80 SPP_SACKDELAY_ENABLE; 81 82 /* Initialize the default path max_retrans. */ 83 peer->pathmaxrxt = net->sctp.max_retrans_path; 84 peer->pf_retrans = net->sctp.pf_retrans; 85 86 INIT_LIST_HEAD(&peer->transmitted); 87 INIT_LIST_HEAD(&peer->send_ready); 88 INIT_LIST_HEAD(&peer->transports); 89 90 timer_setup(&peer->T3_rtx_timer, sctp_generate_t3_rtx_event, 0); 91 timer_setup(&peer->hb_timer, sctp_generate_heartbeat_event, 0); 92 timer_setup(&peer->reconf_timer, sctp_generate_reconf_event, 0); 93 timer_setup(&peer->proto_unreach_timer, 94 sctp_generate_proto_unreach_event, 0); 95 96 /* Initialize the 64-bit random nonce sent with heartbeat. */ 97 get_random_bytes(&peer->hb_nonce, sizeof(peer->hb_nonce)); 98 99 refcount_set(&peer->refcnt, 1); 100 101 return peer; 102 } 103 104 /* Allocate and initialize a new transport. */ 105 struct sctp_transport *sctp_transport_new(struct net *net, 106 const union sctp_addr *addr, 107 gfp_t gfp) 108 { 109 struct sctp_transport *transport; 110 111 transport = kzalloc(sizeof(*transport), gfp); 112 if (!transport) 113 goto fail; 114 115 if (!sctp_transport_init(net, transport, addr, gfp)) 116 goto fail_init; 117 118 SCTP_DBG_OBJCNT_INC(transport); 119 120 return transport; 121 122 fail_init: 123 kfree(transport); 124 125 fail: 126 return NULL; 127 } 128 129 /* This transport is no longer needed. Free up if possible, or 130 * delay until it last reference count. 131 */ 132 void sctp_transport_free(struct sctp_transport *transport) 133 { 134 /* Try to delete the heartbeat timer. */ 135 if (del_timer(&transport->hb_timer)) 136 sctp_transport_put(transport); 137 138 /* Delete the T3_rtx timer if it's active. 139 * There is no point in not doing this now and letting 140 * structure hang around in memory since we know 141 * the tranport is going away. 142 */ 143 if (del_timer(&transport->T3_rtx_timer)) 144 sctp_transport_put(transport); 145 146 if (del_timer(&transport->reconf_timer)) 147 sctp_transport_put(transport); 148 149 /* Delete the ICMP proto unreachable timer if it's active. */ 150 if (del_timer(&transport->proto_unreach_timer)) 151 sctp_association_put(transport->asoc); 152 153 sctp_transport_put(transport); 154 } 155 156 static void sctp_transport_destroy_rcu(struct rcu_head *head) 157 { 158 struct sctp_transport *transport; 159 160 transport = container_of(head, struct sctp_transport, rcu); 161 162 dst_release(transport->dst); 163 kfree(transport); 164 SCTP_DBG_OBJCNT_DEC(transport); 165 } 166 167 /* Destroy the transport data structure. 168 * Assumes there are no more users of this structure. 169 */ 170 static void sctp_transport_destroy(struct sctp_transport *transport) 171 { 172 if (unlikely(refcount_read(&transport->refcnt))) { 173 WARN(1, "Attempt to destroy undead transport %p!\n", transport); 174 return; 175 } 176 177 sctp_packet_free(&transport->packet); 178 179 if (transport->asoc) 180 sctp_association_put(transport->asoc); 181 182 call_rcu(&transport->rcu, sctp_transport_destroy_rcu); 183 } 184 185 /* Start T3_rtx timer if it is not already running and update the heartbeat 186 * timer. This routine is called every time a DATA chunk is sent. 187 */ 188 void sctp_transport_reset_t3_rtx(struct sctp_transport *transport) 189 { 190 /* RFC 2960 6.3.2 Retransmission Timer Rules 191 * 192 * R1) Every time a DATA chunk is sent to any address(including a 193 * retransmission), if the T3-rtx timer of that address is not running 194 * start it running so that it will expire after the RTO of that 195 * address. 196 */ 197 198 if (!timer_pending(&transport->T3_rtx_timer)) 199 if (!mod_timer(&transport->T3_rtx_timer, 200 jiffies + transport->rto)) 201 sctp_transport_hold(transport); 202 } 203 204 void sctp_transport_reset_hb_timer(struct sctp_transport *transport) 205 { 206 unsigned long expires; 207 208 /* When a data chunk is sent, reset the heartbeat interval. */ 209 expires = jiffies + sctp_transport_timeout(transport); 210 if (time_before(transport->hb_timer.expires, expires) && 211 !mod_timer(&transport->hb_timer, 212 expires + prandom_u32_max(transport->rto))) 213 sctp_transport_hold(transport); 214 } 215 216 void sctp_transport_reset_reconf_timer(struct sctp_transport *transport) 217 { 218 if (!timer_pending(&transport->reconf_timer)) 219 if (!mod_timer(&transport->reconf_timer, 220 jiffies + transport->rto)) 221 sctp_transport_hold(transport); 222 } 223 224 /* This transport has been assigned to an association. 225 * Initialize fields from the association or from the sock itself. 226 * Register the reference count in the association. 227 */ 228 void sctp_transport_set_owner(struct sctp_transport *transport, 229 struct sctp_association *asoc) 230 { 231 transport->asoc = asoc; 232 sctp_association_hold(asoc); 233 } 234 235 /* Initialize the pmtu of a transport. */ 236 void sctp_transport_pmtu(struct sctp_transport *transport, struct sock *sk) 237 { 238 /* If we don't have a fresh route, look one up */ 239 if (!transport->dst || transport->dst->obsolete) { 240 sctp_transport_dst_release(transport); 241 transport->af_specific->get_dst(transport, &transport->saddr, 242 &transport->fl, sk); 243 } 244 245 if (transport->dst) { 246 transport->pathmtu = SCTP_TRUNC4(dst_mtu(transport->dst)); 247 } else 248 transport->pathmtu = SCTP_DEFAULT_MAXSEGMENT; 249 } 250 251 bool sctp_transport_update_pmtu(struct sctp_transport *t, u32 pmtu) 252 { 253 struct dst_entry *dst = sctp_transport_dst_check(t); 254 bool change = true; 255 256 if (unlikely(pmtu < SCTP_DEFAULT_MINSEGMENT)) { 257 pr_warn_ratelimited("%s: Reported pmtu %d too low, using default minimum of %d\n", 258 __func__, pmtu, SCTP_DEFAULT_MINSEGMENT); 259 /* Use default minimum segment instead */ 260 pmtu = SCTP_DEFAULT_MINSEGMENT; 261 } 262 pmtu = SCTP_TRUNC4(pmtu); 263 264 if (dst) { 265 dst->ops->update_pmtu(dst, t->asoc->base.sk, NULL, pmtu); 266 dst = sctp_transport_dst_check(t); 267 } 268 269 if (!dst) { 270 t->af_specific->get_dst(t, &t->saddr, &t->fl, t->asoc->base.sk); 271 dst = t->dst; 272 } 273 274 if (dst) { 275 /* Re-fetch, as under layers may have a higher minimum size */ 276 pmtu = SCTP_TRUNC4(dst_mtu(dst)); 277 change = t->pathmtu != pmtu; 278 } 279 t->pathmtu = pmtu; 280 281 return change; 282 } 283 284 /* Caches the dst entry and source address for a transport's destination 285 * address. 286 */ 287 void sctp_transport_route(struct sctp_transport *transport, 288 union sctp_addr *saddr, struct sctp_sock *opt) 289 { 290 struct sctp_association *asoc = transport->asoc; 291 struct sctp_af *af = transport->af_specific; 292 293 af->get_dst(transport, saddr, &transport->fl, sctp_opt2sk(opt)); 294 295 if (saddr) 296 memcpy(&transport->saddr, saddr, sizeof(union sctp_addr)); 297 else 298 af->get_saddr(opt, transport, &transport->fl); 299 300 if ((transport->param_flags & SPP_PMTUD_DISABLE) && transport->pathmtu) { 301 return; 302 } 303 if (transport->dst) { 304 transport->pathmtu = SCTP_TRUNC4(dst_mtu(transport->dst)); 305 306 /* Initialize sk->sk_rcv_saddr, if the transport is the 307 * association's active path for getsockname(). 308 */ 309 if (asoc && (!asoc->peer.primary_path || 310 (transport == asoc->peer.active_path))) 311 opt->pf->to_sk_saddr(&transport->saddr, 312 asoc->base.sk); 313 } else 314 transport->pathmtu = SCTP_DEFAULT_MAXSEGMENT; 315 } 316 317 /* Hold a reference to a transport. */ 318 int sctp_transport_hold(struct sctp_transport *transport) 319 { 320 return refcount_inc_not_zero(&transport->refcnt); 321 } 322 323 /* Release a reference to a transport and clean up 324 * if there are no more references. 325 */ 326 void sctp_transport_put(struct sctp_transport *transport) 327 { 328 if (refcount_dec_and_test(&transport->refcnt)) 329 sctp_transport_destroy(transport); 330 } 331 332 /* Update transport's RTO based on the newly calculated RTT. */ 333 void sctp_transport_update_rto(struct sctp_transport *tp, __u32 rtt) 334 { 335 if (unlikely(!tp->rto_pending)) 336 /* We should not be doing any RTO updates unless rto_pending is set. */ 337 pr_debug("%s: rto_pending not set on transport %p!\n", __func__, tp); 338 339 if (tp->rttvar || tp->srtt) { 340 struct net *net = sock_net(tp->asoc->base.sk); 341 /* 6.3.1 C3) When a new RTT measurement R' is made, set 342 * RTTVAR <- (1 - RTO.Beta) * RTTVAR + RTO.Beta * |SRTT - R'| 343 * SRTT <- (1 - RTO.Alpha) * SRTT + RTO.Alpha * R' 344 */ 345 346 /* Note: The above algorithm has been rewritten to 347 * express rto_beta and rto_alpha as inverse powers 348 * of two. 349 * For example, assuming the default value of RTO.Alpha of 350 * 1/8, rto_alpha would be expressed as 3. 351 */ 352 tp->rttvar = tp->rttvar - (tp->rttvar >> net->sctp.rto_beta) 353 + (((__u32)abs((__s64)tp->srtt - (__s64)rtt)) >> net->sctp.rto_beta); 354 tp->srtt = tp->srtt - (tp->srtt >> net->sctp.rto_alpha) 355 + (rtt >> net->sctp.rto_alpha); 356 } else { 357 /* 6.3.1 C2) When the first RTT measurement R is made, set 358 * SRTT <- R, RTTVAR <- R/2. 359 */ 360 tp->srtt = rtt; 361 tp->rttvar = rtt >> 1; 362 } 363 364 /* 6.3.1 G1) Whenever RTTVAR is computed, if RTTVAR = 0, then 365 * adjust RTTVAR <- G, where G is the CLOCK GRANULARITY. 366 */ 367 if (tp->rttvar == 0) 368 tp->rttvar = SCTP_CLOCK_GRANULARITY; 369 370 /* 6.3.1 C3) After the computation, update RTO <- SRTT + 4 * RTTVAR. */ 371 tp->rto = tp->srtt + (tp->rttvar << 2); 372 373 /* 6.3.1 C6) Whenever RTO is computed, if it is less than RTO.Min 374 * seconds then it is rounded up to RTO.Min seconds. 375 */ 376 if (tp->rto < tp->asoc->rto_min) 377 tp->rto = tp->asoc->rto_min; 378 379 /* 6.3.1 C7) A maximum value may be placed on RTO provided it is 380 * at least RTO.max seconds. 381 */ 382 if (tp->rto > tp->asoc->rto_max) 383 tp->rto = tp->asoc->rto_max; 384 385 sctp_max_rto(tp->asoc, tp); 386 tp->rtt = rtt; 387 388 /* Reset rto_pending so that a new RTT measurement is started when a 389 * new data chunk is sent. 390 */ 391 tp->rto_pending = 0; 392 393 pr_debug("%s: transport:%p, rtt:%d, srtt:%d rttvar:%d, rto:%ld\n", 394 __func__, tp, rtt, tp->srtt, tp->rttvar, tp->rto); 395 } 396 397 /* This routine updates the transport's cwnd and partial_bytes_acked 398 * parameters based on the bytes acked in the received SACK. 399 */ 400 void sctp_transport_raise_cwnd(struct sctp_transport *transport, 401 __u32 sack_ctsn, __u32 bytes_acked) 402 { 403 struct sctp_association *asoc = transport->asoc; 404 __u32 cwnd, ssthresh, flight_size, pba, pmtu; 405 406 cwnd = transport->cwnd; 407 flight_size = transport->flight_size; 408 409 /* See if we need to exit Fast Recovery first */ 410 if (asoc->fast_recovery && 411 TSN_lte(asoc->fast_recovery_exit, sack_ctsn)) 412 asoc->fast_recovery = 0; 413 414 ssthresh = transport->ssthresh; 415 pba = transport->partial_bytes_acked; 416 pmtu = transport->asoc->pathmtu; 417 418 if (cwnd <= ssthresh) { 419 /* RFC 4960 7.2.1 420 * o When cwnd is less than or equal to ssthresh, an SCTP 421 * endpoint MUST use the slow-start algorithm to increase 422 * cwnd only if the current congestion window is being fully 423 * utilized, an incoming SACK advances the Cumulative TSN 424 * Ack Point, and the data sender is not in Fast Recovery. 425 * Only when these three conditions are met can the cwnd be 426 * increased; otherwise, the cwnd MUST not be increased. 427 * If these conditions are met, then cwnd MUST be increased 428 * by, at most, the lesser of 1) the total size of the 429 * previously outstanding DATA chunk(s) acknowledged, and 430 * 2) the destination's path MTU. This upper bound protects 431 * against the ACK-Splitting attack outlined in [SAVAGE99]. 432 */ 433 if (asoc->fast_recovery) 434 return; 435 436 /* The appropriate cwnd increase algorithm is performed 437 * if, and only if the congestion window is being fully 438 * utilized. Note that RFC4960 Errata 3.22 removed the 439 * other condition on ctsn moving. 440 */ 441 if (flight_size < cwnd) 442 return; 443 444 if (bytes_acked > pmtu) 445 cwnd += pmtu; 446 else 447 cwnd += bytes_acked; 448 449 pr_debug("%s: slow start: transport:%p, bytes_acked:%d, " 450 "cwnd:%d, ssthresh:%d, flight_size:%d, pba:%d\n", 451 __func__, transport, bytes_acked, cwnd, ssthresh, 452 flight_size, pba); 453 } else { 454 /* RFC 2960 7.2.2 Whenever cwnd is greater than ssthresh, 455 * upon each SACK arrival, increase partial_bytes_acked 456 * by the total number of bytes of all new chunks 457 * acknowledged in that SACK including chunks 458 * acknowledged by the new Cumulative TSN Ack and by Gap 459 * Ack Blocks. (updated by RFC4960 Errata 3.22) 460 * 461 * When partial_bytes_acked is greater than cwnd and 462 * before the arrival of the SACK the sender had less 463 * bytes of data outstanding than cwnd (i.e., before 464 * arrival of the SACK, flightsize was less than cwnd), 465 * reset partial_bytes_acked to cwnd. (RFC 4960 Errata 466 * 3.26) 467 * 468 * When partial_bytes_acked is equal to or greater than 469 * cwnd and before the arrival of the SACK the sender 470 * had cwnd or more bytes of data outstanding (i.e., 471 * before arrival of the SACK, flightsize was greater 472 * than or equal to cwnd), partial_bytes_acked is reset 473 * to (partial_bytes_acked - cwnd). Next, cwnd is 474 * increased by MTU. (RFC 4960 Errata 3.12) 475 */ 476 pba += bytes_acked; 477 if (pba > cwnd && flight_size < cwnd) 478 pba = cwnd; 479 if (pba >= cwnd && flight_size >= cwnd) { 480 pba = pba - cwnd; 481 cwnd += pmtu; 482 } 483 484 pr_debug("%s: congestion avoidance: transport:%p, " 485 "bytes_acked:%d, cwnd:%d, ssthresh:%d, " 486 "flight_size:%d, pba:%d\n", __func__, 487 transport, bytes_acked, cwnd, ssthresh, 488 flight_size, pba); 489 } 490 491 transport->cwnd = cwnd; 492 transport->partial_bytes_acked = pba; 493 } 494 495 /* This routine is used to lower the transport's cwnd when congestion is 496 * detected. 497 */ 498 void sctp_transport_lower_cwnd(struct sctp_transport *transport, 499 enum sctp_lower_cwnd reason) 500 { 501 struct sctp_association *asoc = transport->asoc; 502 503 switch (reason) { 504 case SCTP_LOWER_CWND_T3_RTX: 505 /* RFC 2960 Section 7.2.3, sctpimpguide 506 * When the T3-rtx timer expires on an address, SCTP should 507 * perform slow start by: 508 * ssthresh = max(cwnd/2, 4*MTU) 509 * cwnd = 1*MTU 510 * partial_bytes_acked = 0 511 */ 512 transport->ssthresh = max(transport->cwnd/2, 513 4*asoc->pathmtu); 514 transport->cwnd = asoc->pathmtu; 515 516 /* T3-rtx also clears fast recovery */ 517 asoc->fast_recovery = 0; 518 break; 519 520 case SCTP_LOWER_CWND_FAST_RTX: 521 /* RFC 2960 7.2.4 Adjust the ssthresh and cwnd of the 522 * destination address(es) to which the missing DATA chunks 523 * were last sent, according to the formula described in 524 * Section 7.2.3. 525 * 526 * RFC 2960 7.2.3, sctpimpguide Upon detection of packet 527 * losses from SACK (see Section 7.2.4), An endpoint 528 * should do the following: 529 * ssthresh = max(cwnd/2, 4*MTU) 530 * cwnd = ssthresh 531 * partial_bytes_acked = 0 532 */ 533 if (asoc->fast_recovery) 534 return; 535 536 /* Mark Fast recovery */ 537 asoc->fast_recovery = 1; 538 asoc->fast_recovery_exit = asoc->next_tsn - 1; 539 540 transport->ssthresh = max(transport->cwnd/2, 541 4*asoc->pathmtu); 542 transport->cwnd = transport->ssthresh; 543 break; 544 545 case SCTP_LOWER_CWND_ECNE: 546 /* RFC 2481 Section 6.1.2. 547 * If the sender receives an ECN-Echo ACK packet 548 * then the sender knows that congestion was encountered in the 549 * network on the path from the sender to the receiver. The 550 * indication of congestion should be treated just as a 551 * congestion loss in non-ECN Capable TCP. That is, the TCP 552 * source halves the congestion window "cwnd" and reduces the 553 * slow start threshold "ssthresh". 554 * A critical condition is that TCP does not react to 555 * congestion indications more than once every window of 556 * data (or more loosely more than once every round-trip time). 557 */ 558 if (time_after(jiffies, transport->last_time_ecne_reduced + 559 transport->rtt)) { 560 transport->ssthresh = max(transport->cwnd/2, 561 4*asoc->pathmtu); 562 transport->cwnd = transport->ssthresh; 563 transport->last_time_ecne_reduced = jiffies; 564 } 565 break; 566 567 case SCTP_LOWER_CWND_INACTIVE: 568 /* RFC 2960 Section 7.2.1, sctpimpguide 569 * When the endpoint does not transmit data on a given 570 * transport address, the cwnd of the transport address 571 * should be adjusted to max(cwnd/2, 4*MTU) per RTO. 572 * NOTE: Although the draft recommends that this check needs 573 * to be done every RTO interval, we do it every hearbeat 574 * interval. 575 */ 576 transport->cwnd = max(transport->cwnd/2, 577 4*asoc->pathmtu); 578 /* RFC 4960 Errata 3.27.2: also adjust sshthresh */ 579 transport->ssthresh = transport->cwnd; 580 break; 581 } 582 583 transport->partial_bytes_acked = 0; 584 585 pr_debug("%s: transport:%p, reason:%d, cwnd:%d, ssthresh:%d\n", 586 __func__, transport, reason, transport->cwnd, 587 transport->ssthresh); 588 } 589 590 /* Apply Max.Burst limit to the congestion window: 591 * sctpimpguide-05 2.14.2 592 * D) When the time comes for the sender to 593 * transmit new DATA chunks, the protocol parameter Max.Burst MUST 594 * first be applied to limit how many new DATA chunks may be sent. 595 * The limit is applied by adjusting cwnd as follows: 596 * if ((flightsize+ Max.Burst * MTU) < cwnd) 597 * cwnd = flightsize + Max.Burst * MTU 598 */ 599 600 void sctp_transport_burst_limited(struct sctp_transport *t) 601 { 602 struct sctp_association *asoc = t->asoc; 603 u32 old_cwnd = t->cwnd; 604 u32 max_burst_bytes; 605 606 if (t->burst_limited || asoc->max_burst == 0) 607 return; 608 609 max_burst_bytes = t->flight_size + (asoc->max_burst * asoc->pathmtu); 610 if (max_burst_bytes < old_cwnd) { 611 t->cwnd = max_burst_bytes; 612 t->burst_limited = old_cwnd; 613 } 614 } 615 616 /* Restore the old cwnd congestion window, after the burst had it's 617 * desired effect. 618 */ 619 void sctp_transport_burst_reset(struct sctp_transport *t) 620 { 621 if (t->burst_limited) { 622 t->cwnd = t->burst_limited; 623 t->burst_limited = 0; 624 } 625 } 626 627 /* What is the next timeout value for this transport? */ 628 unsigned long sctp_transport_timeout(struct sctp_transport *trans) 629 { 630 /* RTO + timer slack +/- 50% of RTO */ 631 unsigned long timeout = trans->rto >> 1; 632 633 if (trans->state != SCTP_UNCONFIRMED && 634 trans->state != SCTP_PF) 635 timeout += trans->hbinterval; 636 637 return timeout; 638 } 639 640 /* Reset transport variables to their initial values */ 641 void sctp_transport_reset(struct sctp_transport *t) 642 { 643 struct sctp_association *asoc = t->asoc; 644 645 /* RFC 2960 (bis), Section 5.2.4 646 * All the congestion control parameters (e.g., cwnd, ssthresh) 647 * related to this peer MUST be reset to their initial values 648 * (see Section 6.2.1) 649 */ 650 t->cwnd = min(4*asoc->pathmtu, max_t(__u32, 2*asoc->pathmtu, 4380)); 651 t->burst_limited = 0; 652 t->ssthresh = asoc->peer.i.a_rwnd; 653 t->rto = asoc->rto_initial; 654 sctp_max_rto(asoc, t); 655 t->rtt = 0; 656 t->srtt = 0; 657 t->rttvar = 0; 658 659 /* Reset these additional variables so that we have a clean slate. */ 660 t->partial_bytes_acked = 0; 661 t->flight_size = 0; 662 t->error_count = 0; 663 t->rto_pending = 0; 664 t->hb_sent = 0; 665 666 /* Initialize the state information for SFR-CACC */ 667 t->cacc.changeover_active = 0; 668 t->cacc.cycling_changeover = 0; 669 t->cacc.next_tsn_at_change = 0; 670 t->cacc.cacc_saw_newack = 0; 671 } 672 673 /* Schedule retransmission on the given transport */ 674 void sctp_transport_immediate_rtx(struct sctp_transport *t) 675 { 676 /* Stop pending T3_rtx_timer */ 677 if (del_timer(&t->T3_rtx_timer)) 678 sctp_transport_put(t); 679 680 sctp_retransmit(&t->asoc->outqueue, t, SCTP_RTXR_T3_RTX); 681 if (!timer_pending(&t->T3_rtx_timer)) { 682 if (!mod_timer(&t->T3_rtx_timer, jiffies + t->rto)) 683 sctp_transport_hold(t); 684 } 685 } 686 687 /* Drop dst */ 688 void sctp_transport_dst_release(struct sctp_transport *t) 689 { 690 dst_release(t->dst); 691 t->dst = NULL; 692 t->dst_pending_confirm = 0; 693 } 694 695 /* Schedule neighbour confirm */ 696 void sctp_transport_dst_confirm(struct sctp_transport *t) 697 { 698 t->dst_pending_confirm = 1; 699 } 700