1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* SCTP kernel implementation 3 * (C) Copyright IBM Corp. 2001, 2004 4 * Copyright (c) 1999-2000 Cisco, Inc. 5 * Copyright (c) 1999-2001 Motorola, Inc. 6 * Copyright (c) 2001-2003 Intel Corp. 7 * 8 * This file is part of the SCTP kernel implementation 9 * 10 * These functions implement the sctp_outq class. The outqueue handles 11 * bundling and queueing of outgoing SCTP chunks. 12 * 13 * Please send any bug reports or fixes you make to the 14 * email address(es): 15 * lksctp developers <linux-sctp@vger.kernel.org> 16 * 17 * Written or modified by: 18 * La Monte H.P. Yarroll <piggy@acm.org> 19 * Karl Knutson <karl@athena.chicago.il.us> 20 * Perry Melange <pmelange@null.cc.uic.edu> 21 * Xingang Guo <xingang.guo@intel.com> 22 * Hui Huang <hui.huang@nokia.com> 23 * Sridhar Samudrala <sri@us.ibm.com> 24 * Jon Grimm <jgrimm@us.ibm.com> 25 */ 26 27 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 28 29 #include <linux/types.h> 30 #include <linux/list.h> /* For struct list_head */ 31 #include <linux/socket.h> 32 #include <linux/ip.h> 33 #include <linux/slab.h> 34 #include <net/sock.h> /* For skb_set_owner_w */ 35 36 #include <net/sctp/sctp.h> 37 #include <net/sctp/sm.h> 38 #include <net/sctp/stream_sched.h> 39 #include <trace/events/sctp.h> 40 41 /* Declare internal functions here. */ 42 static int sctp_acked(struct sctp_sackhdr *sack, __u32 tsn); 43 static void sctp_check_transmitted(struct sctp_outq *q, 44 struct list_head *transmitted_queue, 45 struct sctp_transport *transport, 46 union sctp_addr *saddr, 47 struct sctp_sackhdr *sack, 48 __u32 *highest_new_tsn); 49 50 static void sctp_mark_missing(struct sctp_outq *q, 51 struct list_head *transmitted_queue, 52 struct sctp_transport *transport, 53 __u32 highest_new_tsn, 54 int count_of_newacks); 55 56 static void sctp_outq_flush(struct sctp_outq *q, int rtx_timeout, gfp_t gfp); 57 58 /* Add data to the front of the queue. */ 59 static inline void sctp_outq_head_data(struct sctp_outq *q, 60 struct sctp_chunk *ch) 61 { 62 struct sctp_stream_out_ext *oute; 63 __u16 stream; 64 65 list_add(&ch->list, &q->out_chunk_list); 66 q->out_qlen += ch->skb->len; 67 68 stream = sctp_chunk_stream_no(ch); 69 oute = SCTP_SO(&q->asoc->stream, stream)->ext; 70 list_add(&ch->stream_list, &oute->outq); 71 } 72 73 /* Take data from the front of the queue. */ 74 static inline struct sctp_chunk *sctp_outq_dequeue_data(struct sctp_outq *q) 75 { 76 return q->sched->dequeue(q); 77 } 78 79 /* Add data chunk to the end of the queue. */ 80 static inline void sctp_outq_tail_data(struct sctp_outq *q, 81 struct sctp_chunk *ch) 82 { 83 struct sctp_stream_out_ext *oute; 84 __u16 stream; 85 86 list_add_tail(&ch->list, &q->out_chunk_list); 87 q->out_qlen += ch->skb->len; 88 89 stream = sctp_chunk_stream_no(ch); 90 oute = SCTP_SO(&q->asoc->stream, stream)->ext; 91 list_add_tail(&ch->stream_list, &oute->outq); 92 } 93 94 /* 95 * SFR-CACC algorithm: 96 * D) If count_of_newacks is greater than or equal to 2 97 * and t was not sent to the current primary then the 98 * sender MUST NOT increment missing report count for t. 99 */ 100 static inline int sctp_cacc_skip_3_1_d(struct sctp_transport *primary, 101 struct sctp_transport *transport, 102 int count_of_newacks) 103 { 104 if (count_of_newacks >= 2 && transport != primary) 105 return 1; 106 return 0; 107 } 108 109 /* 110 * SFR-CACC algorithm: 111 * F) If count_of_newacks is less than 2, let d be the 112 * destination to which t was sent. If cacc_saw_newack 113 * is 0 for destination d, then the sender MUST NOT 114 * increment missing report count for t. 115 */ 116 static inline int sctp_cacc_skip_3_1_f(struct sctp_transport *transport, 117 int count_of_newacks) 118 { 119 if (count_of_newacks < 2 && 120 (transport && !transport->cacc.cacc_saw_newack)) 121 return 1; 122 return 0; 123 } 124 125 /* 126 * SFR-CACC algorithm: 127 * 3.1) If CYCLING_CHANGEOVER is 0, the sender SHOULD 128 * execute steps C, D, F. 129 * 130 * C has been implemented in sctp_outq_sack 131 */ 132 static inline int sctp_cacc_skip_3_1(struct sctp_transport *primary, 133 struct sctp_transport *transport, 134 int count_of_newacks) 135 { 136 if (!primary->cacc.cycling_changeover) { 137 if (sctp_cacc_skip_3_1_d(primary, transport, count_of_newacks)) 138 return 1; 139 if (sctp_cacc_skip_3_1_f(transport, count_of_newacks)) 140 return 1; 141 return 0; 142 } 143 return 0; 144 } 145 146 /* 147 * SFR-CACC algorithm: 148 * 3.2) Else if CYCLING_CHANGEOVER is 1, and t is less 149 * than next_tsn_at_change of the current primary, then 150 * the sender MUST NOT increment missing report count 151 * for t. 152 */ 153 static inline int sctp_cacc_skip_3_2(struct sctp_transport *primary, __u32 tsn) 154 { 155 if (primary->cacc.cycling_changeover && 156 TSN_lt(tsn, primary->cacc.next_tsn_at_change)) 157 return 1; 158 return 0; 159 } 160 161 /* 162 * SFR-CACC algorithm: 163 * 3) If the missing report count for TSN t is to be 164 * incremented according to [RFC2960] and 165 * [SCTP_STEWART-2002], and CHANGEOVER_ACTIVE is set, 166 * then the sender MUST further execute steps 3.1 and 167 * 3.2 to determine if the missing report count for 168 * TSN t SHOULD NOT be incremented. 169 * 170 * 3.3) If 3.1 and 3.2 do not dictate that the missing 171 * report count for t should not be incremented, then 172 * the sender SHOULD increment missing report count for 173 * t (according to [RFC2960] and [SCTP_STEWART_2002]). 174 */ 175 static inline int sctp_cacc_skip(struct sctp_transport *primary, 176 struct sctp_transport *transport, 177 int count_of_newacks, 178 __u32 tsn) 179 { 180 if (primary->cacc.changeover_active && 181 (sctp_cacc_skip_3_1(primary, transport, count_of_newacks) || 182 sctp_cacc_skip_3_2(primary, tsn))) 183 return 1; 184 return 0; 185 } 186 187 /* Initialize an existing sctp_outq. This does the boring stuff. 188 * You still need to define handlers if you really want to DO 189 * something with this structure... 190 */ 191 void sctp_outq_init(struct sctp_association *asoc, struct sctp_outq *q) 192 { 193 memset(q, 0, sizeof(struct sctp_outq)); 194 195 q->asoc = asoc; 196 INIT_LIST_HEAD(&q->out_chunk_list); 197 INIT_LIST_HEAD(&q->control_chunk_list); 198 INIT_LIST_HEAD(&q->retransmit); 199 INIT_LIST_HEAD(&q->sacked); 200 INIT_LIST_HEAD(&q->abandoned); 201 sctp_sched_set_sched(asoc, sctp_sk(asoc->base.sk)->default_ss); 202 } 203 204 /* Free the outqueue structure and any related pending chunks. 205 */ 206 static void __sctp_outq_teardown(struct sctp_outq *q) 207 { 208 struct sctp_transport *transport; 209 struct list_head *lchunk, *temp; 210 struct sctp_chunk *chunk, *tmp; 211 212 /* Throw away unacknowledged chunks. */ 213 list_for_each_entry(transport, &q->asoc->peer.transport_addr_list, 214 transports) { 215 while ((lchunk = sctp_list_dequeue(&transport->transmitted)) != NULL) { 216 chunk = list_entry(lchunk, struct sctp_chunk, 217 transmitted_list); 218 /* Mark as part of a failed message. */ 219 sctp_chunk_fail(chunk, q->error); 220 sctp_chunk_free(chunk); 221 } 222 } 223 224 /* Throw away chunks that have been gap ACKed. */ 225 list_for_each_safe(lchunk, temp, &q->sacked) { 226 list_del_init(lchunk); 227 chunk = list_entry(lchunk, struct sctp_chunk, 228 transmitted_list); 229 sctp_chunk_fail(chunk, q->error); 230 sctp_chunk_free(chunk); 231 } 232 233 /* Throw away any chunks in the retransmit queue. */ 234 list_for_each_safe(lchunk, temp, &q->retransmit) { 235 list_del_init(lchunk); 236 chunk = list_entry(lchunk, struct sctp_chunk, 237 transmitted_list); 238 sctp_chunk_fail(chunk, q->error); 239 sctp_chunk_free(chunk); 240 } 241 242 /* Throw away any chunks that are in the abandoned queue. */ 243 list_for_each_safe(lchunk, temp, &q->abandoned) { 244 list_del_init(lchunk); 245 chunk = list_entry(lchunk, struct sctp_chunk, 246 transmitted_list); 247 sctp_chunk_fail(chunk, q->error); 248 sctp_chunk_free(chunk); 249 } 250 251 /* Throw away any leftover data chunks. */ 252 while ((chunk = sctp_outq_dequeue_data(q)) != NULL) { 253 sctp_sched_dequeue_done(q, chunk); 254 255 /* Mark as send failure. */ 256 sctp_chunk_fail(chunk, q->error); 257 sctp_chunk_free(chunk); 258 } 259 260 /* Throw away any leftover control chunks. */ 261 list_for_each_entry_safe(chunk, tmp, &q->control_chunk_list, list) { 262 list_del_init(&chunk->list); 263 sctp_chunk_free(chunk); 264 } 265 } 266 267 void sctp_outq_teardown(struct sctp_outq *q) 268 { 269 __sctp_outq_teardown(q); 270 sctp_outq_init(q->asoc, q); 271 } 272 273 /* Free the outqueue structure and any related pending chunks. */ 274 void sctp_outq_free(struct sctp_outq *q) 275 { 276 /* Throw away leftover chunks. */ 277 __sctp_outq_teardown(q); 278 } 279 280 /* Put a new chunk in an sctp_outq. */ 281 void sctp_outq_tail(struct sctp_outq *q, struct sctp_chunk *chunk, gfp_t gfp) 282 { 283 struct net *net = q->asoc->base.net; 284 285 pr_debug("%s: outq:%p, chunk:%p[%s]\n", __func__, q, chunk, 286 chunk && chunk->chunk_hdr ? 287 sctp_cname(SCTP_ST_CHUNK(chunk->chunk_hdr->type)) : 288 "illegal chunk"); 289 290 /* If it is data, queue it up, otherwise, send it 291 * immediately. 292 */ 293 if (sctp_chunk_is_data(chunk)) { 294 pr_debug("%s: outqueueing: outq:%p, chunk:%p[%s])\n", 295 __func__, q, chunk, chunk && chunk->chunk_hdr ? 296 sctp_cname(SCTP_ST_CHUNK(chunk->chunk_hdr->type)) : 297 "illegal chunk"); 298 299 sctp_outq_tail_data(q, chunk); 300 if (chunk->asoc->peer.prsctp_capable && 301 SCTP_PR_PRIO_ENABLED(chunk->sinfo.sinfo_flags)) 302 chunk->asoc->sent_cnt_removable++; 303 if (chunk->chunk_hdr->flags & SCTP_DATA_UNORDERED) 304 SCTP_INC_STATS(net, SCTP_MIB_OUTUNORDERCHUNKS); 305 else 306 SCTP_INC_STATS(net, SCTP_MIB_OUTORDERCHUNKS); 307 } else { 308 list_add_tail(&chunk->list, &q->control_chunk_list); 309 SCTP_INC_STATS(net, SCTP_MIB_OUTCTRLCHUNKS); 310 } 311 312 if (!q->cork) 313 sctp_outq_flush(q, 0, gfp); 314 } 315 316 /* Insert a chunk into the sorted list based on the TSNs. The retransmit list 317 * and the abandoned list are in ascending order. 318 */ 319 static void sctp_insert_list(struct list_head *head, struct list_head *new) 320 { 321 struct list_head *pos; 322 struct sctp_chunk *nchunk, *lchunk; 323 __u32 ntsn, ltsn; 324 int done = 0; 325 326 nchunk = list_entry(new, struct sctp_chunk, transmitted_list); 327 ntsn = ntohl(nchunk->subh.data_hdr->tsn); 328 329 list_for_each(pos, head) { 330 lchunk = list_entry(pos, struct sctp_chunk, transmitted_list); 331 ltsn = ntohl(lchunk->subh.data_hdr->tsn); 332 if (TSN_lt(ntsn, ltsn)) { 333 list_add(new, pos->prev); 334 done = 1; 335 break; 336 } 337 } 338 if (!done) 339 list_add_tail(new, head); 340 } 341 342 static int sctp_prsctp_prune_sent(struct sctp_association *asoc, 343 struct sctp_sndrcvinfo *sinfo, 344 struct list_head *queue, int msg_len) 345 { 346 struct sctp_chunk *chk, *temp; 347 348 list_for_each_entry_safe(chk, temp, queue, transmitted_list) { 349 struct sctp_stream_out *streamout; 350 351 if (!chk->msg->abandoned && 352 (!SCTP_PR_PRIO_ENABLED(chk->sinfo.sinfo_flags) || 353 chk->sinfo.sinfo_timetolive <= sinfo->sinfo_timetolive)) 354 continue; 355 356 chk->msg->abandoned = 1; 357 list_del_init(&chk->transmitted_list); 358 sctp_insert_list(&asoc->outqueue.abandoned, 359 &chk->transmitted_list); 360 361 streamout = SCTP_SO(&asoc->stream, chk->sinfo.sinfo_stream); 362 asoc->sent_cnt_removable--; 363 asoc->abandoned_sent[SCTP_PR_INDEX(PRIO)]++; 364 streamout->ext->abandoned_sent[SCTP_PR_INDEX(PRIO)]++; 365 366 if (queue != &asoc->outqueue.retransmit && 367 !chk->tsn_gap_acked) { 368 if (chk->transport) 369 chk->transport->flight_size -= 370 sctp_data_size(chk); 371 asoc->outqueue.outstanding_bytes -= sctp_data_size(chk); 372 } 373 374 msg_len -= chk->skb->truesize + sizeof(struct sctp_chunk); 375 if (msg_len <= 0) 376 break; 377 } 378 379 return msg_len; 380 } 381 382 static int sctp_prsctp_prune_unsent(struct sctp_association *asoc, 383 struct sctp_sndrcvinfo *sinfo, int msg_len) 384 { 385 struct sctp_outq *q = &asoc->outqueue; 386 struct sctp_chunk *chk, *temp; 387 struct sctp_stream_out *sout; 388 389 q->sched->unsched_all(&asoc->stream); 390 391 list_for_each_entry_safe(chk, temp, &q->out_chunk_list, list) { 392 if (!chk->msg->abandoned && 393 (!(chk->chunk_hdr->flags & SCTP_DATA_FIRST_FRAG) || 394 !SCTP_PR_PRIO_ENABLED(chk->sinfo.sinfo_flags) || 395 chk->sinfo.sinfo_timetolive <= sinfo->sinfo_timetolive)) 396 continue; 397 398 chk->msg->abandoned = 1; 399 sctp_sched_dequeue_common(q, chk); 400 asoc->sent_cnt_removable--; 401 asoc->abandoned_unsent[SCTP_PR_INDEX(PRIO)]++; 402 403 sout = SCTP_SO(&asoc->stream, chk->sinfo.sinfo_stream); 404 sout->ext->abandoned_unsent[SCTP_PR_INDEX(PRIO)]++; 405 406 /* clear out_curr if all frag chunks are pruned */ 407 if (asoc->stream.out_curr == sout && 408 list_is_last(&chk->frag_list, &chk->msg->chunks)) 409 asoc->stream.out_curr = NULL; 410 411 msg_len -= chk->skb->truesize + sizeof(struct sctp_chunk); 412 sctp_chunk_free(chk); 413 if (msg_len <= 0) 414 break; 415 } 416 417 q->sched->sched_all(&asoc->stream); 418 419 return msg_len; 420 } 421 422 /* Abandon the chunks according their priorities */ 423 void sctp_prsctp_prune(struct sctp_association *asoc, 424 struct sctp_sndrcvinfo *sinfo, int msg_len) 425 { 426 struct sctp_transport *transport; 427 428 if (!asoc->peer.prsctp_capable || !asoc->sent_cnt_removable) 429 return; 430 431 msg_len = sctp_prsctp_prune_sent(asoc, sinfo, 432 &asoc->outqueue.retransmit, 433 msg_len); 434 if (msg_len <= 0) 435 return; 436 437 list_for_each_entry(transport, &asoc->peer.transport_addr_list, 438 transports) { 439 msg_len = sctp_prsctp_prune_sent(asoc, sinfo, 440 &transport->transmitted, 441 msg_len); 442 if (msg_len <= 0) 443 return; 444 } 445 446 sctp_prsctp_prune_unsent(asoc, sinfo, msg_len); 447 } 448 449 /* Mark all the eligible packets on a transport for retransmission. */ 450 void sctp_retransmit_mark(struct sctp_outq *q, 451 struct sctp_transport *transport, 452 __u8 reason) 453 { 454 struct list_head *lchunk, *ltemp; 455 struct sctp_chunk *chunk; 456 457 /* Walk through the specified transmitted queue. */ 458 list_for_each_safe(lchunk, ltemp, &transport->transmitted) { 459 chunk = list_entry(lchunk, struct sctp_chunk, 460 transmitted_list); 461 462 /* If the chunk is abandoned, move it to abandoned list. */ 463 if (sctp_chunk_abandoned(chunk)) { 464 list_del_init(lchunk); 465 sctp_insert_list(&q->abandoned, lchunk); 466 467 /* If this chunk has not been previousely acked, 468 * stop considering it 'outstanding'. Our peer 469 * will most likely never see it since it will 470 * not be retransmitted 471 */ 472 if (!chunk->tsn_gap_acked) { 473 if (chunk->transport) 474 chunk->transport->flight_size -= 475 sctp_data_size(chunk); 476 q->outstanding_bytes -= sctp_data_size(chunk); 477 q->asoc->peer.rwnd += sctp_data_size(chunk); 478 } 479 continue; 480 } 481 482 /* If we are doing retransmission due to a timeout or pmtu 483 * discovery, only the chunks that are not yet acked should 484 * be added to the retransmit queue. 485 */ 486 if ((reason == SCTP_RTXR_FAST_RTX && 487 (chunk->fast_retransmit == SCTP_NEED_FRTX)) || 488 (reason != SCTP_RTXR_FAST_RTX && !chunk->tsn_gap_acked)) { 489 /* RFC 2960 6.2.1 Processing a Received SACK 490 * 491 * C) Any time a DATA chunk is marked for 492 * retransmission (via either T3-rtx timer expiration 493 * (Section 6.3.3) or via fast retransmit 494 * (Section 7.2.4)), add the data size of those 495 * chunks to the rwnd. 496 */ 497 q->asoc->peer.rwnd += sctp_data_size(chunk); 498 q->outstanding_bytes -= sctp_data_size(chunk); 499 if (chunk->transport) 500 transport->flight_size -= sctp_data_size(chunk); 501 502 /* sctpimpguide-05 Section 2.8.2 503 * M5) If a T3-rtx timer expires, the 504 * 'TSN.Missing.Report' of all affected TSNs is set 505 * to 0. 506 */ 507 chunk->tsn_missing_report = 0; 508 509 /* If a chunk that is being used for RTT measurement 510 * has to be retransmitted, we cannot use this chunk 511 * anymore for RTT measurements. Reset rto_pending so 512 * that a new RTT measurement is started when a new 513 * data chunk is sent. 514 */ 515 if (chunk->rtt_in_progress) { 516 chunk->rtt_in_progress = 0; 517 transport->rto_pending = 0; 518 } 519 520 /* Move the chunk to the retransmit queue. The chunks 521 * on the retransmit queue are always kept in order. 522 */ 523 list_del_init(lchunk); 524 sctp_insert_list(&q->retransmit, lchunk); 525 } 526 } 527 528 pr_debug("%s: transport:%p, reason:%d, cwnd:%d, ssthresh:%d, " 529 "flight_size:%d, pba:%d\n", __func__, transport, reason, 530 transport->cwnd, transport->ssthresh, transport->flight_size, 531 transport->partial_bytes_acked); 532 } 533 534 /* Mark all the eligible packets on a transport for retransmission and force 535 * one packet out. 536 */ 537 void sctp_retransmit(struct sctp_outq *q, struct sctp_transport *transport, 538 enum sctp_retransmit_reason reason) 539 { 540 struct net *net = q->asoc->base.net; 541 542 switch (reason) { 543 case SCTP_RTXR_T3_RTX: 544 SCTP_INC_STATS(net, SCTP_MIB_T3_RETRANSMITS); 545 sctp_transport_lower_cwnd(transport, SCTP_LOWER_CWND_T3_RTX); 546 /* Update the retran path if the T3-rtx timer has expired for 547 * the current retran path. 548 */ 549 if (transport == transport->asoc->peer.retran_path) 550 sctp_assoc_update_retran_path(transport->asoc); 551 transport->asoc->rtx_data_chunks += 552 transport->asoc->unack_data; 553 if (transport->pl.state == SCTP_PL_COMPLETE && 554 transport->asoc->unack_data) 555 sctp_transport_reset_probe_timer(transport); 556 break; 557 case SCTP_RTXR_FAST_RTX: 558 SCTP_INC_STATS(net, SCTP_MIB_FAST_RETRANSMITS); 559 sctp_transport_lower_cwnd(transport, SCTP_LOWER_CWND_FAST_RTX); 560 q->fast_rtx = 1; 561 break; 562 case SCTP_RTXR_PMTUD: 563 SCTP_INC_STATS(net, SCTP_MIB_PMTUD_RETRANSMITS); 564 break; 565 case SCTP_RTXR_T1_RTX: 566 SCTP_INC_STATS(net, SCTP_MIB_T1_RETRANSMITS); 567 transport->asoc->init_retries++; 568 break; 569 default: 570 BUG(); 571 } 572 573 sctp_retransmit_mark(q, transport, reason); 574 575 /* PR-SCTP A5) Any time the T3-rtx timer expires, on any destination, 576 * the sender SHOULD try to advance the "Advanced.Peer.Ack.Point" by 577 * following the procedures outlined in C1 - C5. 578 */ 579 if (reason == SCTP_RTXR_T3_RTX) 580 q->asoc->stream.si->generate_ftsn(q, q->asoc->ctsn_ack_point); 581 582 /* Flush the queues only on timeout, since fast_rtx is only 583 * triggered during sack processing and the queue 584 * will be flushed at the end. 585 */ 586 if (reason != SCTP_RTXR_FAST_RTX) 587 sctp_outq_flush(q, /* rtx_timeout */ 1, GFP_ATOMIC); 588 } 589 590 /* 591 * Transmit DATA chunks on the retransmit queue. Upon return from 592 * __sctp_outq_flush_rtx() the packet 'pkt' may contain chunks which 593 * need to be transmitted by the caller. 594 * We assume that pkt->transport has already been set. 595 * 596 * The return value is a normal kernel error return value. 597 */ 598 static int __sctp_outq_flush_rtx(struct sctp_outq *q, struct sctp_packet *pkt, 599 int rtx_timeout, int *start_timer, gfp_t gfp) 600 { 601 struct sctp_transport *transport = pkt->transport; 602 struct sctp_chunk *chunk, *chunk1; 603 struct list_head *lqueue; 604 enum sctp_xmit status; 605 int error = 0; 606 int timer = 0; 607 int done = 0; 608 int fast_rtx; 609 610 lqueue = &q->retransmit; 611 fast_rtx = q->fast_rtx; 612 613 /* This loop handles time-out retransmissions, fast retransmissions, 614 * and retransmissions due to opening of whindow. 615 * 616 * RFC 2960 6.3.3 Handle T3-rtx Expiration 617 * 618 * E3) Determine how many of the earliest (i.e., lowest TSN) 619 * outstanding DATA chunks for the address for which the 620 * T3-rtx has expired will fit into a single packet, subject 621 * to the MTU constraint for the path corresponding to the 622 * destination transport address to which the retransmission 623 * is being sent (this may be different from the address for 624 * which the timer expires [see Section 6.4]). Call this value 625 * K. Bundle and retransmit those K DATA chunks in a single 626 * packet to the destination endpoint. 627 * 628 * [Just to be painfully clear, if we are retransmitting 629 * because a timeout just happened, we should send only ONE 630 * packet of retransmitted data.] 631 * 632 * For fast retransmissions we also send only ONE packet. However, 633 * if we are just flushing the queue due to open window, we'll 634 * try to send as much as possible. 635 */ 636 list_for_each_entry_safe(chunk, chunk1, lqueue, transmitted_list) { 637 /* If the chunk is abandoned, move it to abandoned list. */ 638 if (sctp_chunk_abandoned(chunk)) { 639 list_del_init(&chunk->transmitted_list); 640 sctp_insert_list(&q->abandoned, 641 &chunk->transmitted_list); 642 continue; 643 } 644 645 /* Make sure that Gap Acked TSNs are not retransmitted. A 646 * simple approach is just to move such TSNs out of the 647 * way and into a 'transmitted' queue and skip to the 648 * next chunk. 649 */ 650 if (chunk->tsn_gap_acked) { 651 list_move_tail(&chunk->transmitted_list, 652 &transport->transmitted); 653 continue; 654 } 655 656 /* If we are doing fast retransmit, ignore non-fast_rtransmit 657 * chunks 658 */ 659 if (fast_rtx && !chunk->fast_retransmit) 660 continue; 661 662 redo: 663 /* Attempt to append this chunk to the packet. */ 664 status = sctp_packet_append_chunk(pkt, chunk); 665 666 switch (status) { 667 case SCTP_XMIT_PMTU_FULL: 668 if (!pkt->has_data && !pkt->has_cookie_echo) { 669 /* If this packet did not contain DATA then 670 * retransmission did not happen, so do it 671 * again. We'll ignore the error here since 672 * control chunks are already freed so there 673 * is nothing we can do. 674 */ 675 sctp_packet_transmit(pkt, gfp); 676 goto redo; 677 } 678 679 /* Send this packet. */ 680 error = sctp_packet_transmit(pkt, gfp); 681 682 /* If we are retransmitting, we should only 683 * send a single packet. 684 * Otherwise, try appending this chunk again. 685 */ 686 if (rtx_timeout || fast_rtx) 687 done = 1; 688 else 689 goto redo; 690 691 /* Bundle next chunk in the next round. */ 692 break; 693 694 case SCTP_XMIT_RWND_FULL: 695 /* Send this packet. */ 696 error = sctp_packet_transmit(pkt, gfp); 697 698 /* Stop sending DATA as there is no more room 699 * at the receiver. 700 */ 701 done = 1; 702 break; 703 704 case SCTP_XMIT_DELAY: 705 /* Send this packet. */ 706 error = sctp_packet_transmit(pkt, gfp); 707 708 /* Stop sending DATA because of nagle delay. */ 709 done = 1; 710 break; 711 712 default: 713 /* The append was successful, so add this chunk to 714 * the transmitted list. 715 */ 716 list_move_tail(&chunk->transmitted_list, 717 &transport->transmitted); 718 719 /* Mark the chunk as ineligible for fast retransmit 720 * after it is retransmitted. 721 */ 722 if (chunk->fast_retransmit == SCTP_NEED_FRTX) 723 chunk->fast_retransmit = SCTP_DONT_FRTX; 724 725 q->asoc->stats.rtxchunks++; 726 break; 727 } 728 729 /* Set the timer if there were no errors */ 730 if (!error && !timer) 731 timer = 1; 732 733 if (done) 734 break; 735 } 736 737 /* If we are here due to a retransmit timeout or a fast 738 * retransmit and if there are any chunks left in the retransmit 739 * queue that could not fit in the PMTU sized packet, they need 740 * to be marked as ineligible for a subsequent fast retransmit. 741 */ 742 if (rtx_timeout || fast_rtx) { 743 list_for_each_entry(chunk1, lqueue, transmitted_list) { 744 if (chunk1->fast_retransmit == SCTP_NEED_FRTX) 745 chunk1->fast_retransmit = SCTP_DONT_FRTX; 746 } 747 } 748 749 *start_timer = timer; 750 751 /* Clear fast retransmit hint */ 752 if (fast_rtx) 753 q->fast_rtx = 0; 754 755 return error; 756 } 757 758 /* Cork the outqueue so queued chunks are really queued. */ 759 void sctp_outq_uncork(struct sctp_outq *q, gfp_t gfp) 760 { 761 if (q->cork) 762 q->cork = 0; 763 764 sctp_outq_flush(q, 0, gfp); 765 } 766 767 static int sctp_packet_singleton(struct sctp_transport *transport, 768 struct sctp_chunk *chunk, gfp_t gfp) 769 { 770 const struct sctp_association *asoc = transport->asoc; 771 const __u16 sport = asoc->base.bind_addr.port; 772 const __u16 dport = asoc->peer.port; 773 const __u32 vtag = asoc->peer.i.init_tag; 774 struct sctp_packet singleton; 775 776 sctp_packet_init(&singleton, transport, sport, dport); 777 sctp_packet_config(&singleton, vtag, 0); 778 if (sctp_packet_append_chunk(&singleton, chunk) != SCTP_XMIT_OK) { 779 list_del_init(&chunk->list); 780 sctp_chunk_free(chunk); 781 return -ENOMEM; 782 } 783 return sctp_packet_transmit(&singleton, gfp); 784 } 785 786 /* Struct to hold the context during sctp outq flush */ 787 struct sctp_flush_ctx { 788 struct sctp_outq *q; 789 /* Current transport being used. It's NOT the same as curr active one */ 790 struct sctp_transport *transport; 791 /* These transports have chunks to send. */ 792 struct list_head transport_list; 793 struct sctp_association *asoc; 794 /* Packet on the current transport above */ 795 struct sctp_packet *packet; 796 gfp_t gfp; 797 }; 798 799 /* transport: current transport */ 800 static void sctp_outq_select_transport(struct sctp_flush_ctx *ctx, 801 struct sctp_chunk *chunk) 802 { 803 struct sctp_transport *new_transport = chunk->transport; 804 805 if (!new_transport) { 806 if (!sctp_chunk_is_data(chunk)) { 807 /* If we have a prior transport pointer, see if 808 * the destination address of the chunk 809 * matches the destination address of the 810 * current transport. If not a match, then 811 * try to look up the transport with a given 812 * destination address. We do this because 813 * after processing ASCONFs, we may have new 814 * transports created. 815 */ 816 if (ctx->transport && sctp_cmp_addr_exact(&chunk->dest, 817 &ctx->transport->ipaddr)) 818 new_transport = ctx->transport; 819 else 820 new_transport = sctp_assoc_lookup_paddr(ctx->asoc, 821 &chunk->dest); 822 } 823 824 /* if we still don't have a new transport, then 825 * use the current active path. 826 */ 827 if (!new_transport) 828 new_transport = ctx->asoc->peer.active_path; 829 } else { 830 __u8 type; 831 832 switch (new_transport->state) { 833 case SCTP_INACTIVE: 834 case SCTP_UNCONFIRMED: 835 case SCTP_PF: 836 /* If the chunk is Heartbeat or Heartbeat Ack, 837 * send it to chunk->transport, even if it's 838 * inactive. 839 * 840 * 3.3.6 Heartbeat Acknowledgement: 841 * ... 842 * A HEARTBEAT ACK is always sent to the source IP 843 * address of the IP datagram containing the 844 * HEARTBEAT chunk to which this ack is responding. 845 * ... 846 * 847 * ASCONF_ACKs also must be sent to the source. 848 */ 849 type = chunk->chunk_hdr->type; 850 if (type != SCTP_CID_HEARTBEAT && 851 type != SCTP_CID_HEARTBEAT_ACK && 852 type != SCTP_CID_ASCONF_ACK) 853 new_transport = ctx->asoc->peer.active_path; 854 break; 855 default: 856 break; 857 } 858 } 859 860 /* Are we switching transports? Take care of transport locks. */ 861 if (new_transport != ctx->transport) { 862 ctx->transport = new_transport; 863 ctx->packet = &ctx->transport->packet; 864 865 if (list_empty(&ctx->transport->send_ready)) 866 list_add_tail(&ctx->transport->send_ready, 867 &ctx->transport_list); 868 869 sctp_packet_config(ctx->packet, 870 ctx->asoc->peer.i.init_tag, 871 ctx->asoc->peer.ecn_capable); 872 /* We've switched transports, so apply the 873 * Burst limit to the new transport. 874 */ 875 sctp_transport_burst_limited(ctx->transport); 876 } 877 } 878 879 static void sctp_outq_flush_ctrl(struct sctp_flush_ctx *ctx) 880 { 881 struct sctp_chunk *chunk, *tmp; 882 enum sctp_xmit status; 883 int one_packet, error; 884 885 list_for_each_entry_safe(chunk, tmp, &ctx->q->control_chunk_list, list) { 886 one_packet = 0; 887 888 /* RFC 5061, 5.3 889 * F1) This means that until such time as the ASCONF 890 * containing the add is acknowledged, the sender MUST 891 * NOT use the new IP address as a source for ANY SCTP 892 * packet except on carrying an ASCONF Chunk. 893 */ 894 if (ctx->asoc->src_out_of_asoc_ok && 895 chunk->chunk_hdr->type != SCTP_CID_ASCONF) 896 continue; 897 898 list_del_init(&chunk->list); 899 900 /* Pick the right transport to use. Should always be true for 901 * the first chunk as we don't have a transport by then. 902 */ 903 sctp_outq_select_transport(ctx, chunk); 904 905 switch (chunk->chunk_hdr->type) { 906 /* 6.10 Bundling 907 * ... 908 * An endpoint MUST NOT bundle INIT, INIT ACK or SHUTDOWN 909 * COMPLETE with any other chunks. [Send them immediately.] 910 */ 911 case SCTP_CID_INIT: 912 case SCTP_CID_INIT_ACK: 913 case SCTP_CID_SHUTDOWN_COMPLETE: 914 error = sctp_packet_singleton(ctx->transport, chunk, 915 ctx->gfp); 916 if (error < 0) { 917 ctx->asoc->base.sk->sk_err = -error; 918 return; 919 } 920 ctx->asoc->stats.octrlchunks++; 921 break; 922 923 case SCTP_CID_ABORT: 924 if (sctp_test_T_bit(chunk)) 925 ctx->packet->vtag = ctx->asoc->c.my_vtag; 926 fallthrough; 927 928 /* The following chunks are "response" chunks, i.e. 929 * they are generated in response to something we 930 * received. If we are sending these, then we can 931 * send only 1 packet containing these chunks. 932 */ 933 case SCTP_CID_HEARTBEAT_ACK: 934 case SCTP_CID_SHUTDOWN_ACK: 935 case SCTP_CID_COOKIE_ACK: 936 case SCTP_CID_COOKIE_ECHO: 937 case SCTP_CID_ERROR: 938 case SCTP_CID_ECN_CWR: 939 case SCTP_CID_ASCONF_ACK: 940 one_packet = 1; 941 fallthrough; 942 943 case SCTP_CID_HEARTBEAT: 944 if (chunk->pmtu_probe) { 945 error = sctp_packet_singleton(ctx->transport, 946 chunk, ctx->gfp); 947 if (!error) 948 ctx->asoc->stats.octrlchunks++; 949 break; 950 } 951 fallthrough; 952 case SCTP_CID_SACK: 953 case SCTP_CID_SHUTDOWN: 954 case SCTP_CID_ECN_ECNE: 955 case SCTP_CID_ASCONF: 956 case SCTP_CID_FWD_TSN: 957 case SCTP_CID_I_FWD_TSN: 958 case SCTP_CID_RECONF: 959 status = sctp_packet_transmit_chunk(ctx->packet, chunk, 960 one_packet, ctx->gfp); 961 if (status != SCTP_XMIT_OK) { 962 /* put the chunk back */ 963 list_add(&chunk->list, &ctx->q->control_chunk_list); 964 break; 965 } 966 967 ctx->asoc->stats.octrlchunks++; 968 /* PR-SCTP C5) If a FORWARD TSN is sent, the 969 * sender MUST assure that at least one T3-rtx 970 * timer is running. 971 */ 972 if (chunk->chunk_hdr->type == SCTP_CID_FWD_TSN || 973 chunk->chunk_hdr->type == SCTP_CID_I_FWD_TSN) { 974 sctp_transport_reset_t3_rtx(ctx->transport); 975 ctx->transport->last_time_sent = jiffies; 976 } 977 978 if (chunk == ctx->asoc->strreset_chunk) 979 sctp_transport_reset_reconf_timer(ctx->transport); 980 981 break; 982 983 default: 984 /* We built a chunk with an illegal type! */ 985 BUG(); 986 } 987 } 988 } 989 990 /* Returns false if new data shouldn't be sent */ 991 static bool sctp_outq_flush_rtx(struct sctp_flush_ctx *ctx, 992 int rtx_timeout) 993 { 994 int error, start_timer = 0; 995 996 if (ctx->asoc->peer.retran_path->state == SCTP_UNCONFIRMED) 997 return false; 998 999 if (ctx->transport != ctx->asoc->peer.retran_path) { 1000 /* Switch transports & prepare the packet. */ 1001 ctx->transport = ctx->asoc->peer.retran_path; 1002 ctx->packet = &ctx->transport->packet; 1003 1004 if (list_empty(&ctx->transport->send_ready)) 1005 list_add_tail(&ctx->transport->send_ready, 1006 &ctx->transport_list); 1007 1008 sctp_packet_config(ctx->packet, ctx->asoc->peer.i.init_tag, 1009 ctx->asoc->peer.ecn_capable); 1010 } 1011 1012 error = __sctp_outq_flush_rtx(ctx->q, ctx->packet, rtx_timeout, 1013 &start_timer, ctx->gfp); 1014 if (error < 0) 1015 ctx->asoc->base.sk->sk_err = -error; 1016 1017 if (start_timer) { 1018 sctp_transport_reset_t3_rtx(ctx->transport); 1019 ctx->transport->last_time_sent = jiffies; 1020 } 1021 1022 /* This can happen on COOKIE-ECHO resend. Only 1023 * one chunk can get bundled with a COOKIE-ECHO. 1024 */ 1025 if (ctx->packet->has_cookie_echo) 1026 return false; 1027 1028 /* Don't send new data if there is still data 1029 * waiting to retransmit. 1030 */ 1031 if (!list_empty(&ctx->q->retransmit)) 1032 return false; 1033 1034 return true; 1035 } 1036 1037 static void sctp_outq_flush_data(struct sctp_flush_ctx *ctx, 1038 int rtx_timeout) 1039 { 1040 struct sctp_chunk *chunk; 1041 enum sctp_xmit status; 1042 1043 /* Is it OK to send data chunks? */ 1044 switch (ctx->asoc->state) { 1045 case SCTP_STATE_COOKIE_ECHOED: 1046 /* Only allow bundling when this packet has a COOKIE-ECHO 1047 * chunk. 1048 */ 1049 if (!ctx->packet || !ctx->packet->has_cookie_echo) 1050 return; 1051 1052 fallthrough; 1053 case SCTP_STATE_ESTABLISHED: 1054 case SCTP_STATE_SHUTDOWN_PENDING: 1055 case SCTP_STATE_SHUTDOWN_RECEIVED: 1056 break; 1057 1058 default: 1059 /* Do nothing. */ 1060 return; 1061 } 1062 1063 /* RFC 2960 6.1 Transmission of DATA Chunks 1064 * 1065 * C) When the time comes for the sender to transmit, 1066 * before sending new DATA chunks, the sender MUST 1067 * first transmit any outstanding DATA chunks which 1068 * are marked for retransmission (limited by the 1069 * current cwnd). 1070 */ 1071 if (!list_empty(&ctx->q->retransmit) && 1072 !sctp_outq_flush_rtx(ctx, rtx_timeout)) 1073 return; 1074 1075 /* Apply Max.Burst limitation to the current transport in 1076 * case it will be used for new data. We are going to 1077 * rest it before we return, but we want to apply the limit 1078 * to the currently queued data. 1079 */ 1080 if (ctx->transport) 1081 sctp_transport_burst_limited(ctx->transport); 1082 1083 /* Finally, transmit new packets. */ 1084 while ((chunk = sctp_outq_dequeue_data(ctx->q)) != NULL) { 1085 __u32 sid = ntohs(chunk->subh.data_hdr->stream); 1086 __u8 stream_state = SCTP_SO(&ctx->asoc->stream, sid)->state; 1087 1088 /* Has this chunk expired? */ 1089 if (sctp_chunk_abandoned(chunk)) { 1090 sctp_sched_dequeue_done(ctx->q, chunk); 1091 sctp_chunk_fail(chunk, 0); 1092 sctp_chunk_free(chunk); 1093 continue; 1094 } 1095 1096 if (stream_state == SCTP_STREAM_CLOSED) { 1097 sctp_outq_head_data(ctx->q, chunk); 1098 break; 1099 } 1100 1101 sctp_outq_select_transport(ctx, chunk); 1102 1103 pr_debug("%s: outq:%p, chunk:%p[%s], tx-tsn:0x%x skb->head:%p skb->users:%d\n", 1104 __func__, ctx->q, chunk, chunk && chunk->chunk_hdr ? 1105 sctp_cname(SCTP_ST_CHUNK(chunk->chunk_hdr->type)) : 1106 "illegal chunk", ntohl(chunk->subh.data_hdr->tsn), 1107 chunk->skb ? chunk->skb->head : NULL, chunk->skb ? 1108 refcount_read(&chunk->skb->users) : -1); 1109 1110 /* Add the chunk to the packet. */ 1111 status = sctp_packet_transmit_chunk(ctx->packet, chunk, 0, 1112 ctx->gfp); 1113 if (status != SCTP_XMIT_OK) { 1114 /* We could not append this chunk, so put 1115 * the chunk back on the output queue. 1116 */ 1117 pr_debug("%s: could not transmit tsn:0x%x, status:%d\n", 1118 __func__, ntohl(chunk->subh.data_hdr->tsn), 1119 status); 1120 1121 sctp_outq_head_data(ctx->q, chunk); 1122 break; 1123 } 1124 1125 /* The sender is in the SHUTDOWN-PENDING state, 1126 * The sender MAY set the I-bit in the DATA 1127 * chunk header. 1128 */ 1129 if (ctx->asoc->state == SCTP_STATE_SHUTDOWN_PENDING) 1130 chunk->chunk_hdr->flags |= SCTP_DATA_SACK_IMM; 1131 if (chunk->chunk_hdr->flags & SCTP_DATA_UNORDERED) 1132 ctx->asoc->stats.ouodchunks++; 1133 else 1134 ctx->asoc->stats.oodchunks++; 1135 1136 /* Only now it's safe to consider this 1137 * chunk as sent, sched-wise. 1138 */ 1139 sctp_sched_dequeue_done(ctx->q, chunk); 1140 1141 list_add_tail(&chunk->transmitted_list, 1142 &ctx->transport->transmitted); 1143 1144 sctp_transport_reset_t3_rtx(ctx->transport); 1145 ctx->transport->last_time_sent = jiffies; 1146 1147 /* Only let one DATA chunk get bundled with a 1148 * COOKIE-ECHO chunk. 1149 */ 1150 if (ctx->packet->has_cookie_echo) 1151 break; 1152 } 1153 } 1154 1155 static void sctp_outq_flush_transports(struct sctp_flush_ctx *ctx) 1156 { 1157 struct sock *sk = ctx->asoc->base.sk; 1158 struct list_head *ltransport; 1159 struct sctp_packet *packet; 1160 struct sctp_transport *t; 1161 int error = 0; 1162 1163 while ((ltransport = sctp_list_dequeue(&ctx->transport_list)) != NULL) { 1164 t = list_entry(ltransport, struct sctp_transport, send_ready); 1165 packet = &t->packet; 1166 if (!sctp_packet_empty(packet)) { 1167 rcu_read_lock(); 1168 if (t->dst && __sk_dst_get(sk) != t->dst) { 1169 dst_hold(t->dst); 1170 sk_setup_caps(sk, t->dst); 1171 } 1172 rcu_read_unlock(); 1173 error = sctp_packet_transmit(packet, ctx->gfp); 1174 if (error < 0) 1175 ctx->q->asoc->base.sk->sk_err = -error; 1176 } 1177 1178 /* Clear the burst limited state, if any */ 1179 sctp_transport_burst_reset(t); 1180 } 1181 } 1182 1183 /* Try to flush an outqueue. 1184 * 1185 * Description: Send everything in q which we legally can, subject to 1186 * congestion limitations. 1187 * * Note: This function can be called from multiple contexts so appropriate 1188 * locking concerns must be made. Today we use the sock lock to protect 1189 * this function. 1190 */ 1191 1192 static void sctp_outq_flush(struct sctp_outq *q, int rtx_timeout, gfp_t gfp) 1193 { 1194 struct sctp_flush_ctx ctx = { 1195 .q = q, 1196 .transport = NULL, 1197 .transport_list = LIST_HEAD_INIT(ctx.transport_list), 1198 .asoc = q->asoc, 1199 .packet = NULL, 1200 .gfp = gfp, 1201 }; 1202 1203 /* 6.10 Bundling 1204 * ... 1205 * When bundling control chunks with DATA chunks, an 1206 * endpoint MUST place control chunks first in the outbound 1207 * SCTP packet. The transmitter MUST transmit DATA chunks 1208 * within a SCTP packet in increasing order of TSN. 1209 * ... 1210 */ 1211 1212 sctp_outq_flush_ctrl(&ctx); 1213 1214 if (q->asoc->src_out_of_asoc_ok) 1215 goto sctp_flush_out; 1216 1217 sctp_outq_flush_data(&ctx, rtx_timeout); 1218 1219 sctp_flush_out: 1220 1221 sctp_outq_flush_transports(&ctx); 1222 } 1223 1224 /* Update unack_data based on the incoming SACK chunk */ 1225 static void sctp_sack_update_unack_data(struct sctp_association *assoc, 1226 struct sctp_sackhdr *sack) 1227 { 1228 union sctp_sack_variable *frags; 1229 __u16 unack_data; 1230 int i; 1231 1232 unack_data = assoc->next_tsn - assoc->ctsn_ack_point - 1; 1233 1234 frags = sack->variable; 1235 for (i = 0; i < ntohs(sack->num_gap_ack_blocks); i++) { 1236 unack_data -= ((ntohs(frags[i].gab.end) - 1237 ntohs(frags[i].gab.start) + 1)); 1238 } 1239 1240 assoc->unack_data = unack_data; 1241 } 1242 1243 /* This is where we REALLY process a SACK. 1244 * 1245 * Process the SACK against the outqueue. Mostly, this just frees 1246 * things off the transmitted queue. 1247 */ 1248 int sctp_outq_sack(struct sctp_outq *q, struct sctp_chunk *chunk) 1249 { 1250 struct sctp_association *asoc = q->asoc; 1251 struct sctp_sackhdr *sack = chunk->subh.sack_hdr; 1252 struct sctp_transport *transport; 1253 struct sctp_chunk *tchunk = NULL; 1254 struct list_head *lchunk, *transport_list, *temp; 1255 union sctp_sack_variable *frags = sack->variable; 1256 __u32 sack_ctsn, ctsn, tsn; 1257 __u32 highest_tsn, highest_new_tsn; 1258 __u32 sack_a_rwnd; 1259 unsigned int outstanding; 1260 struct sctp_transport *primary = asoc->peer.primary_path; 1261 int count_of_newacks = 0; 1262 int gap_ack_blocks; 1263 u8 accum_moved = 0; 1264 1265 /* Grab the association's destination address list. */ 1266 transport_list = &asoc->peer.transport_addr_list; 1267 1268 /* SCTP path tracepoint for congestion control debugging. */ 1269 if (trace_sctp_probe_path_enabled()) { 1270 list_for_each_entry(transport, transport_list, transports) 1271 trace_sctp_probe_path(transport, asoc); 1272 } 1273 1274 sack_ctsn = ntohl(sack->cum_tsn_ack); 1275 gap_ack_blocks = ntohs(sack->num_gap_ack_blocks); 1276 asoc->stats.gapcnt += gap_ack_blocks; 1277 /* 1278 * SFR-CACC algorithm: 1279 * On receipt of a SACK the sender SHOULD execute the 1280 * following statements. 1281 * 1282 * 1) If the cumulative ack in the SACK passes next tsn_at_change 1283 * on the current primary, the CHANGEOVER_ACTIVE flag SHOULD be 1284 * cleared. The CYCLING_CHANGEOVER flag SHOULD also be cleared for 1285 * all destinations. 1286 * 2) If the SACK contains gap acks and the flag CHANGEOVER_ACTIVE 1287 * is set the receiver of the SACK MUST take the following actions: 1288 * 1289 * A) Initialize the cacc_saw_newack to 0 for all destination 1290 * addresses. 1291 * 1292 * Only bother if changeover_active is set. Otherwise, this is 1293 * totally suboptimal to do on every SACK. 1294 */ 1295 if (primary->cacc.changeover_active) { 1296 u8 clear_cycling = 0; 1297 1298 if (TSN_lte(primary->cacc.next_tsn_at_change, sack_ctsn)) { 1299 primary->cacc.changeover_active = 0; 1300 clear_cycling = 1; 1301 } 1302 1303 if (clear_cycling || gap_ack_blocks) { 1304 list_for_each_entry(transport, transport_list, 1305 transports) { 1306 if (clear_cycling) 1307 transport->cacc.cycling_changeover = 0; 1308 if (gap_ack_blocks) 1309 transport->cacc.cacc_saw_newack = 0; 1310 } 1311 } 1312 } 1313 1314 /* Get the highest TSN in the sack. */ 1315 highest_tsn = sack_ctsn; 1316 if (gap_ack_blocks) 1317 highest_tsn += ntohs(frags[gap_ack_blocks - 1].gab.end); 1318 1319 if (TSN_lt(asoc->highest_sacked, highest_tsn)) 1320 asoc->highest_sacked = highest_tsn; 1321 1322 highest_new_tsn = sack_ctsn; 1323 1324 /* Run through the retransmit queue. Credit bytes received 1325 * and free those chunks that we can. 1326 */ 1327 sctp_check_transmitted(q, &q->retransmit, NULL, NULL, sack, &highest_new_tsn); 1328 1329 /* Run through the transmitted queue. 1330 * Credit bytes received and free those chunks which we can. 1331 * 1332 * This is a MASSIVE candidate for optimization. 1333 */ 1334 list_for_each_entry(transport, transport_list, transports) { 1335 sctp_check_transmitted(q, &transport->transmitted, 1336 transport, &chunk->source, sack, 1337 &highest_new_tsn); 1338 /* 1339 * SFR-CACC algorithm: 1340 * C) Let count_of_newacks be the number of 1341 * destinations for which cacc_saw_newack is set. 1342 */ 1343 if (transport->cacc.cacc_saw_newack) 1344 count_of_newacks++; 1345 } 1346 1347 /* Move the Cumulative TSN Ack Point if appropriate. */ 1348 if (TSN_lt(asoc->ctsn_ack_point, sack_ctsn)) { 1349 asoc->ctsn_ack_point = sack_ctsn; 1350 accum_moved = 1; 1351 } 1352 1353 if (gap_ack_blocks) { 1354 1355 if (asoc->fast_recovery && accum_moved) 1356 highest_new_tsn = highest_tsn; 1357 1358 list_for_each_entry(transport, transport_list, transports) 1359 sctp_mark_missing(q, &transport->transmitted, transport, 1360 highest_new_tsn, count_of_newacks); 1361 } 1362 1363 /* Update unack_data field in the assoc. */ 1364 sctp_sack_update_unack_data(asoc, sack); 1365 1366 ctsn = asoc->ctsn_ack_point; 1367 1368 /* Throw away stuff rotting on the sack queue. */ 1369 list_for_each_safe(lchunk, temp, &q->sacked) { 1370 tchunk = list_entry(lchunk, struct sctp_chunk, 1371 transmitted_list); 1372 tsn = ntohl(tchunk->subh.data_hdr->tsn); 1373 if (TSN_lte(tsn, ctsn)) { 1374 list_del_init(&tchunk->transmitted_list); 1375 if (asoc->peer.prsctp_capable && 1376 SCTP_PR_PRIO_ENABLED(chunk->sinfo.sinfo_flags)) 1377 asoc->sent_cnt_removable--; 1378 sctp_chunk_free(tchunk); 1379 } 1380 } 1381 1382 /* ii) Set rwnd equal to the newly received a_rwnd minus the 1383 * number of bytes still outstanding after processing the 1384 * Cumulative TSN Ack and the Gap Ack Blocks. 1385 */ 1386 1387 sack_a_rwnd = ntohl(sack->a_rwnd); 1388 asoc->peer.zero_window_announced = !sack_a_rwnd; 1389 outstanding = q->outstanding_bytes; 1390 1391 if (outstanding < sack_a_rwnd) 1392 sack_a_rwnd -= outstanding; 1393 else 1394 sack_a_rwnd = 0; 1395 1396 asoc->peer.rwnd = sack_a_rwnd; 1397 1398 asoc->stream.si->generate_ftsn(q, sack_ctsn); 1399 1400 pr_debug("%s: sack cumulative tsn ack:0x%x\n", __func__, sack_ctsn); 1401 pr_debug("%s: cumulative tsn ack of assoc:%p is 0x%x, " 1402 "advertised peer ack point:0x%x\n", __func__, asoc, ctsn, 1403 asoc->adv_peer_ack_point); 1404 1405 return sctp_outq_is_empty(q); 1406 } 1407 1408 /* Is the outqueue empty? 1409 * The queue is empty when we have not pending data, no in-flight data 1410 * and nothing pending retransmissions. 1411 */ 1412 int sctp_outq_is_empty(const struct sctp_outq *q) 1413 { 1414 return q->out_qlen == 0 && q->outstanding_bytes == 0 && 1415 list_empty(&q->retransmit); 1416 } 1417 1418 /******************************************************************** 1419 * 2nd Level Abstractions 1420 ********************************************************************/ 1421 1422 /* Go through a transport's transmitted list or the association's retransmit 1423 * list and move chunks that are acked by the Cumulative TSN Ack to q->sacked. 1424 * The retransmit list will not have an associated transport. 1425 * 1426 * I added coherent debug information output. --xguo 1427 * 1428 * Instead of printing 'sacked' or 'kept' for each TSN on the 1429 * transmitted_queue, we print a range: SACKED: TSN1-TSN2, TSN3, TSN4-TSN5. 1430 * KEPT TSN6-TSN7, etc. 1431 */ 1432 static void sctp_check_transmitted(struct sctp_outq *q, 1433 struct list_head *transmitted_queue, 1434 struct sctp_transport *transport, 1435 union sctp_addr *saddr, 1436 struct sctp_sackhdr *sack, 1437 __u32 *highest_new_tsn_in_sack) 1438 { 1439 struct list_head *lchunk; 1440 struct sctp_chunk *tchunk; 1441 struct list_head tlist; 1442 __u32 tsn; 1443 __u32 sack_ctsn; 1444 __u32 rtt; 1445 __u8 restart_timer = 0; 1446 int bytes_acked = 0; 1447 int migrate_bytes = 0; 1448 bool forward_progress = false; 1449 1450 sack_ctsn = ntohl(sack->cum_tsn_ack); 1451 1452 INIT_LIST_HEAD(&tlist); 1453 1454 /* The while loop will skip empty transmitted queues. */ 1455 while (NULL != (lchunk = sctp_list_dequeue(transmitted_queue))) { 1456 tchunk = list_entry(lchunk, struct sctp_chunk, 1457 transmitted_list); 1458 1459 if (sctp_chunk_abandoned(tchunk)) { 1460 /* Move the chunk to abandoned list. */ 1461 sctp_insert_list(&q->abandoned, lchunk); 1462 1463 /* If this chunk has not been acked, stop 1464 * considering it as 'outstanding'. 1465 */ 1466 if (transmitted_queue != &q->retransmit && 1467 !tchunk->tsn_gap_acked) { 1468 if (tchunk->transport) 1469 tchunk->transport->flight_size -= 1470 sctp_data_size(tchunk); 1471 q->outstanding_bytes -= sctp_data_size(tchunk); 1472 } 1473 continue; 1474 } 1475 1476 tsn = ntohl(tchunk->subh.data_hdr->tsn); 1477 if (sctp_acked(sack, tsn)) { 1478 /* If this queue is the retransmit queue, the 1479 * retransmit timer has already reclaimed 1480 * the outstanding bytes for this chunk, so only 1481 * count bytes associated with a transport. 1482 */ 1483 if (transport && !tchunk->tsn_gap_acked) { 1484 /* If this chunk is being used for RTT 1485 * measurement, calculate the RTT and update 1486 * the RTO using this value. 1487 * 1488 * 6.3.1 C5) Karn's algorithm: RTT measurements 1489 * MUST NOT be made using packets that were 1490 * retransmitted (and thus for which it is 1491 * ambiguous whether the reply was for the 1492 * first instance of the packet or a later 1493 * instance). 1494 */ 1495 if (!sctp_chunk_retransmitted(tchunk) && 1496 tchunk->rtt_in_progress) { 1497 tchunk->rtt_in_progress = 0; 1498 rtt = jiffies - tchunk->sent_at; 1499 sctp_transport_update_rto(transport, 1500 rtt); 1501 } 1502 1503 if (TSN_lte(tsn, sack_ctsn)) { 1504 /* 1505 * SFR-CACC algorithm: 1506 * 2) If the SACK contains gap acks 1507 * and the flag CHANGEOVER_ACTIVE is 1508 * set the receiver of the SACK MUST 1509 * take the following action: 1510 * 1511 * B) For each TSN t being acked that 1512 * has not been acked in any SACK so 1513 * far, set cacc_saw_newack to 1 for 1514 * the destination that the TSN was 1515 * sent to. 1516 */ 1517 if (sack->num_gap_ack_blocks && 1518 q->asoc->peer.primary_path->cacc. 1519 changeover_active) 1520 transport->cacc.cacc_saw_newack 1521 = 1; 1522 } 1523 } 1524 1525 /* If the chunk hasn't been marked as ACKED, 1526 * mark it and account bytes_acked if the 1527 * chunk had a valid transport (it will not 1528 * have a transport if ASCONF had deleted it 1529 * while DATA was outstanding). 1530 */ 1531 if (!tchunk->tsn_gap_acked) { 1532 tchunk->tsn_gap_acked = 1; 1533 if (TSN_lt(*highest_new_tsn_in_sack, tsn)) 1534 *highest_new_tsn_in_sack = tsn; 1535 bytes_acked += sctp_data_size(tchunk); 1536 if (!tchunk->transport) 1537 migrate_bytes += sctp_data_size(tchunk); 1538 forward_progress = true; 1539 } 1540 1541 if (TSN_lte(tsn, sack_ctsn)) { 1542 /* RFC 2960 6.3.2 Retransmission Timer Rules 1543 * 1544 * R3) Whenever a SACK is received 1545 * that acknowledges the DATA chunk 1546 * with the earliest outstanding TSN 1547 * for that address, restart T3-rtx 1548 * timer for that address with its 1549 * current RTO. 1550 */ 1551 restart_timer = 1; 1552 forward_progress = true; 1553 1554 list_add_tail(&tchunk->transmitted_list, 1555 &q->sacked); 1556 } else { 1557 /* RFC2960 7.2.4, sctpimpguide-05 2.8.2 1558 * M2) Each time a SACK arrives reporting 1559 * 'Stray DATA chunk(s)' record the highest TSN 1560 * reported as newly acknowledged, call this 1561 * value 'HighestTSNinSack'. A newly 1562 * acknowledged DATA chunk is one not 1563 * previously acknowledged in a SACK. 1564 * 1565 * When the SCTP sender of data receives a SACK 1566 * chunk that acknowledges, for the first time, 1567 * the receipt of a DATA chunk, all the still 1568 * unacknowledged DATA chunks whose TSN is 1569 * older than that newly acknowledged DATA 1570 * chunk, are qualified as 'Stray DATA chunks'. 1571 */ 1572 list_add_tail(lchunk, &tlist); 1573 } 1574 } else { 1575 if (tchunk->tsn_gap_acked) { 1576 pr_debug("%s: receiver reneged on data TSN:0x%x\n", 1577 __func__, tsn); 1578 1579 tchunk->tsn_gap_acked = 0; 1580 1581 if (tchunk->transport) 1582 bytes_acked -= sctp_data_size(tchunk); 1583 1584 /* RFC 2960 6.3.2 Retransmission Timer Rules 1585 * 1586 * R4) Whenever a SACK is received missing a 1587 * TSN that was previously acknowledged via a 1588 * Gap Ack Block, start T3-rtx for the 1589 * destination address to which the DATA 1590 * chunk was originally 1591 * transmitted if it is not already running. 1592 */ 1593 restart_timer = 1; 1594 } 1595 1596 list_add_tail(lchunk, &tlist); 1597 } 1598 } 1599 1600 if (transport) { 1601 if (bytes_acked) { 1602 struct sctp_association *asoc = transport->asoc; 1603 1604 /* We may have counted DATA that was migrated 1605 * to this transport due to DEL-IP operation. 1606 * Subtract those bytes, since the were never 1607 * send on this transport and shouldn't be 1608 * credited to this transport. 1609 */ 1610 bytes_acked -= migrate_bytes; 1611 1612 /* 8.2. When an outstanding TSN is acknowledged, 1613 * the endpoint shall clear the error counter of 1614 * the destination transport address to which the 1615 * DATA chunk was last sent. 1616 * The association's overall error counter is 1617 * also cleared. 1618 */ 1619 transport->error_count = 0; 1620 transport->asoc->overall_error_count = 0; 1621 forward_progress = true; 1622 1623 /* 1624 * While in SHUTDOWN PENDING, we may have started 1625 * the T5 shutdown guard timer after reaching the 1626 * retransmission limit. Stop that timer as soon 1627 * as the receiver acknowledged any data. 1628 */ 1629 if (asoc->state == SCTP_STATE_SHUTDOWN_PENDING && 1630 del_timer(&asoc->timers 1631 [SCTP_EVENT_TIMEOUT_T5_SHUTDOWN_GUARD])) 1632 sctp_association_put(asoc); 1633 1634 /* Mark the destination transport address as 1635 * active if it is not so marked. 1636 */ 1637 if ((transport->state == SCTP_INACTIVE || 1638 transport->state == SCTP_UNCONFIRMED) && 1639 sctp_cmp_addr_exact(&transport->ipaddr, saddr)) { 1640 sctp_assoc_control_transport( 1641 transport->asoc, 1642 transport, 1643 SCTP_TRANSPORT_UP, 1644 SCTP_RECEIVED_SACK); 1645 } 1646 1647 sctp_transport_raise_cwnd(transport, sack_ctsn, 1648 bytes_acked); 1649 1650 transport->flight_size -= bytes_acked; 1651 if (transport->flight_size == 0) 1652 transport->partial_bytes_acked = 0; 1653 q->outstanding_bytes -= bytes_acked + migrate_bytes; 1654 } else { 1655 /* RFC 2960 6.1, sctpimpguide-06 2.15.2 1656 * When a sender is doing zero window probing, it 1657 * should not timeout the association if it continues 1658 * to receive new packets from the receiver. The 1659 * reason is that the receiver MAY keep its window 1660 * closed for an indefinite time. 1661 * A sender is doing zero window probing when the 1662 * receiver's advertised window is zero, and there is 1663 * only one data chunk in flight to the receiver. 1664 * 1665 * Allow the association to timeout while in SHUTDOWN 1666 * PENDING or SHUTDOWN RECEIVED in case the receiver 1667 * stays in zero window mode forever. 1668 */ 1669 if (!q->asoc->peer.rwnd && 1670 !list_empty(&tlist) && 1671 (sack_ctsn+2 == q->asoc->next_tsn) && 1672 q->asoc->state < SCTP_STATE_SHUTDOWN_PENDING) { 1673 pr_debug("%s: sack received for zero window " 1674 "probe:%u\n", __func__, sack_ctsn); 1675 1676 q->asoc->overall_error_count = 0; 1677 transport->error_count = 0; 1678 } 1679 } 1680 1681 /* RFC 2960 6.3.2 Retransmission Timer Rules 1682 * 1683 * R2) Whenever all outstanding data sent to an address have 1684 * been acknowledged, turn off the T3-rtx timer of that 1685 * address. 1686 */ 1687 if (!transport->flight_size) { 1688 if (del_timer(&transport->T3_rtx_timer)) 1689 sctp_transport_put(transport); 1690 } else if (restart_timer) { 1691 if (!mod_timer(&transport->T3_rtx_timer, 1692 jiffies + transport->rto)) 1693 sctp_transport_hold(transport); 1694 } 1695 1696 if (forward_progress) { 1697 if (transport->dst) 1698 sctp_transport_dst_confirm(transport); 1699 } 1700 } 1701 1702 list_splice(&tlist, transmitted_queue); 1703 } 1704 1705 /* Mark chunks as missing and consequently may get retransmitted. */ 1706 static void sctp_mark_missing(struct sctp_outq *q, 1707 struct list_head *transmitted_queue, 1708 struct sctp_transport *transport, 1709 __u32 highest_new_tsn_in_sack, 1710 int count_of_newacks) 1711 { 1712 struct sctp_chunk *chunk; 1713 __u32 tsn; 1714 char do_fast_retransmit = 0; 1715 struct sctp_association *asoc = q->asoc; 1716 struct sctp_transport *primary = asoc->peer.primary_path; 1717 1718 list_for_each_entry(chunk, transmitted_queue, transmitted_list) { 1719 1720 tsn = ntohl(chunk->subh.data_hdr->tsn); 1721 1722 /* RFC 2960 7.2.4, sctpimpguide-05 2.8.2 M3) Examine all 1723 * 'Unacknowledged TSN's', if the TSN number of an 1724 * 'Unacknowledged TSN' is smaller than the 'HighestTSNinSack' 1725 * value, increment the 'TSN.Missing.Report' count on that 1726 * chunk if it has NOT been fast retransmitted or marked for 1727 * fast retransmit already. 1728 */ 1729 if (chunk->fast_retransmit == SCTP_CAN_FRTX && 1730 !chunk->tsn_gap_acked && 1731 TSN_lt(tsn, highest_new_tsn_in_sack)) { 1732 1733 /* SFR-CACC may require us to skip marking 1734 * this chunk as missing. 1735 */ 1736 if (!transport || !sctp_cacc_skip(primary, 1737 chunk->transport, 1738 count_of_newacks, tsn)) { 1739 chunk->tsn_missing_report++; 1740 1741 pr_debug("%s: tsn:0x%x missing counter:%d\n", 1742 __func__, tsn, chunk->tsn_missing_report); 1743 } 1744 } 1745 /* 1746 * M4) If any DATA chunk is found to have a 1747 * 'TSN.Missing.Report' 1748 * value larger than or equal to 3, mark that chunk for 1749 * retransmission and start the fast retransmit procedure. 1750 */ 1751 1752 if (chunk->tsn_missing_report >= 3) { 1753 chunk->fast_retransmit = SCTP_NEED_FRTX; 1754 do_fast_retransmit = 1; 1755 } 1756 } 1757 1758 if (transport) { 1759 if (do_fast_retransmit) 1760 sctp_retransmit(q, transport, SCTP_RTXR_FAST_RTX); 1761 1762 pr_debug("%s: transport:%p, cwnd:%d, ssthresh:%d, " 1763 "flight_size:%d, pba:%d\n", __func__, transport, 1764 transport->cwnd, transport->ssthresh, 1765 transport->flight_size, transport->partial_bytes_acked); 1766 } 1767 } 1768 1769 /* Is the given TSN acked by this packet? */ 1770 static int sctp_acked(struct sctp_sackhdr *sack, __u32 tsn) 1771 { 1772 __u32 ctsn = ntohl(sack->cum_tsn_ack); 1773 union sctp_sack_variable *frags; 1774 __u16 tsn_offset, blocks; 1775 int i; 1776 1777 if (TSN_lte(tsn, ctsn)) 1778 goto pass; 1779 1780 /* 3.3.4 Selective Acknowledgment (SACK) (3): 1781 * 1782 * Gap Ack Blocks: 1783 * These fields contain the Gap Ack Blocks. They are repeated 1784 * for each Gap Ack Block up to the number of Gap Ack Blocks 1785 * defined in the Number of Gap Ack Blocks field. All DATA 1786 * chunks with TSNs greater than or equal to (Cumulative TSN 1787 * Ack + Gap Ack Block Start) and less than or equal to 1788 * (Cumulative TSN Ack + Gap Ack Block End) of each Gap Ack 1789 * Block are assumed to have been received correctly. 1790 */ 1791 1792 frags = sack->variable; 1793 blocks = ntohs(sack->num_gap_ack_blocks); 1794 tsn_offset = tsn - ctsn; 1795 for (i = 0; i < blocks; ++i) { 1796 if (tsn_offset >= ntohs(frags[i].gab.start) && 1797 tsn_offset <= ntohs(frags[i].gab.end)) 1798 goto pass; 1799 } 1800 1801 return 0; 1802 pass: 1803 return 1; 1804 } 1805 1806 static inline int sctp_get_skip_pos(struct sctp_fwdtsn_skip *skiplist, 1807 int nskips, __be16 stream) 1808 { 1809 int i; 1810 1811 for (i = 0; i < nskips; i++) { 1812 if (skiplist[i].stream == stream) 1813 return i; 1814 } 1815 return i; 1816 } 1817 1818 /* Create and add a fwdtsn chunk to the outq's control queue if needed. */ 1819 void sctp_generate_fwdtsn(struct sctp_outq *q, __u32 ctsn) 1820 { 1821 struct sctp_association *asoc = q->asoc; 1822 struct sctp_chunk *ftsn_chunk = NULL; 1823 struct sctp_fwdtsn_skip ftsn_skip_arr[10]; 1824 int nskips = 0; 1825 int skip_pos = 0; 1826 __u32 tsn; 1827 struct sctp_chunk *chunk; 1828 struct list_head *lchunk, *temp; 1829 1830 if (!asoc->peer.prsctp_capable) 1831 return; 1832 1833 /* PR-SCTP C1) Let SackCumAck be the Cumulative TSN ACK carried in the 1834 * received SACK. 1835 * 1836 * If (Advanced.Peer.Ack.Point < SackCumAck), then update 1837 * Advanced.Peer.Ack.Point to be equal to SackCumAck. 1838 */ 1839 if (TSN_lt(asoc->adv_peer_ack_point, ctsn)) 1840 asoc->adv_peer_ack_point = ctsn; 1841 1842 /* PR-SCTP C2) Try to further advance the "Advanced.Peer.Ack.Point" 1843 * locally, that is, to move "Advanced.Peer.Ack.Point" up as long as 1844 * the chunk next in the out-queue space is marked as "abandoned" as 1845 * shown in the following example: 1846 * 1847 * Assuming that a SACK arrived with the Cumulative TSN ACK 102 1848 * and the Advanced.Peer.Ack.Point is updated to this value: 1849 * 1850 * out-queue at the end of ==> out-queue after Adv.Ack.Point 1851 * normal SACK processing local advancement 1852 * ... ... 1853 * Adv.Ack.Pt-> 102 acked 102 acked 1854 * 103 abandoned 103 abandoned 1855 * 104 abandoned Adv.Ack.P-> 104 abandoned 1856 * 105 105 1857 * 106 acked 106 acked 1858 * ... ... 1859 * 1860 * In this example, the data sender successfully advanced the 1861 * "Advanced.Peer.Ack.Point" from 102 to 104 locally. 1862 */ 1863 list_for_each_safe(lchunk, temp, &q->abandoned) { 1864 chunk = list_entry(lchunk, struct sctp_chunk, 1865 transmitted_list); 1866 tsn = ntohl(chunk->subh.data_hdr->tsn); 1867 1868 /* Remove any chunks in the abandoned queue that are acked by 1869 * the ctsn. 1870 */ 1871 if (TSN_lte(tsn, ctsn)) { 1872 list_del_init(lchunk); 1873 sctp_chunk_free(chunk); 1874 } else { 1875 if (TSN_lte(tsn, asoc->adv_peer_ack_point+1)) { 1876 asoc->adv_peer_ack_point = tsn; 1877 if (chunk->chunk_hdr->flags & 1878 SCTP_DATA_UNORDERED) 1879 continue; 1880 skip_pos = sctp_get_skip_pos(&ftsn_skip_arr[0], 1881 nskips, 1882 chunk->subh.data_hdr->stream); 1883 ftsn_skip_arr[skip_pos].stream = 1884 chunk->subh.data_hdr->stream; 1885 ftsn_skip_arr[skip_pos].ssn = 1886 chunk->subh.data_hdr->ssn; 1887 if (skip_pos == nskips) 1888 nskips++; 1889 if (nskips == 10) 1890 break; 1891 } else 1892 break; 1893 } 1894 } 1895 1896 /* PR-SCTP C3) If, after step C1 and C2, the "Advanced.Peer.Ack.Point" 1897 * is greater than the Cumulative TSN ACK carried in the received 1898 * SACK, the data sender MUST send the data receiver a FORWARD TSN 1899 * chunk containing the latest value of the 1900 * "Advanced.Peer.Ack.Point". 1901 * 1902 * C4) For each "abandoned" TSN the sender of the FORWARD TSN SHOULD 1903 * list each stream and sequence number in the forwarded TSN. This 1904 * information will enable the receiver to easily find any 1905 * stranded TSN's waiting on stream reorder queues. Each stream 1906 * SHOULD only be reported once; this means that if multiple 1907 * abandoned messages occur in the same stream then only the 1908 * highest abandoned stream sequence number is reported. If the 1909 * total size of the FORWARD TSN does NOT fit in a single MTU then 1910 * the sender of the FORWARD TSN SHOULD lower the 1911 * Advanced.Peer.Ack.Point to the last TSN that will fit in a 1912 * single MTU. 1913 */ 1914 if (asoc->adv_peer_ack_point > ctsn) 1915 ftsn_chunk = sctp_make_fwdtsn(asoc, asoc->adv_peer_ack_point, 1916 nskips, &ftsn_skip_arr[0]); 1917 1918 if (ftsn_chunk) { 1919 list_add_tail(&ftsn_chunk->list, &q->control_chunk_list); 1920 SCTP_INC_STATS(asoc->base.net, SCTP_MIB_OUTCTRLCHUNKS); 1921 } 1922 } 1923