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