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