blob: 052a4796a4579436bdfc65bb04ab19f2363c1eba [file] [log] [blame]
Vlad Yasevich60c778b2008-01-11 09:57:09 -05001/* SCTP kernel implementation
Linus Torvalds1da177e2005-04-16 15:20:36 -07002 * (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 *
Vlad Yasevich60c778b2008-01-11 09:57:09 -05007 * This file is part of the SCTP kernel implementation
Linus Torvalds1da177e2005-04-16 15:20:36 -07008 *
9 * These functions implement the sctp_outq class. The outqueue handles
10 * bundling and queueing of outgoing SCTP chunks.
11 *
Vlad Yasevich60c778b2008-01-11 09:57:09 -050012 * This SCTP implementation is free software;
Linus Torvalds1da177e2005-04-16 15:20:36 -070013 * 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 *
Vlad Yasevich60c778b2008-01-11 09:57:09 -050018 * This SCTP implementation is distributed in the hope that it
Linus Torvalds1da177e2005-04-16 15:20:36 -070019 * 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
Jeff Kirsher4b2f13a2013-12-06 06:28:48 -080025 * along with GNU CC; see the file COPYING. If not, see
26 * <http://www.gnu.org/licenses/>.
Linus Torvalds1da177e2005-04-16 15:20:36 -070027 *
28 * Please send any bug reports or fixes you make to the
29 * email address(es):
Daniel Borkmann91705c62013-07-23 14:51:47 +020030 * lksctp developers <linux-sctp@vger.kernel.org>
Linus Torvalds1da177e2005-04-16 15:20:36 -070031 *
Linus Torvalds1da177e2005-04-16 15:20:36 -070032 * 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>
Linus Torvalds1da177e2005-04-16 15:20:36 -070040 */
41
Joe Perches145ce502010-08-24 13:21:08 +000042#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
43
Linus Torvalds1da177e2005-04-16 15:20:36 -070044#include <linux/types.h>
45#include <linux/list.h> /* For struct list_head */
46#include <linux/socket.h>
47#include <linux/ip.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090048#include <linux/slab.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070049#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. */
55static int sctp_acked(struct sctp_sackhdr *sack, __u32 tsn);
56static void sctp_check_transmitted(struct sctp_outq *q,
57 struct list_head *transmitted_queue,
58 struct sctp_transport *transport,
Nicolas Dichteledfee032012-10-03 05:43:22 +000059 union sctp_addr *saddr,
Linus Torvalds1da177e2005-04-16 15:20:36 -070060 struct sctp_sackhdr *sack,
Vlad Yasevichbfa0d982010-04-30 22:41:10 -040061 __u32 *highest_new_tsn);
Linus Torvalds1da177e2005-04-16 15:20:36 -070062
63static 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
69static void sctp_generate_fwdtsn(struct sctp_outq *q, __u32 sack_ctsn);
70
Marcelo Ricardo Leitnercea87682016-03-10 18:33:07 -030071static int sctp_outq_flush(struct sctp_outq *q, int rtx_timeout, gfp_t gfp);
Adrian Bunkabd0b1982008-07-22 14:20:45 -070072
Linus Torvalds1da177e2005-04-16 15:20:36 -070073/* Add data to the front of the queue. */
74static inline void sctp_outq_head_data(struct sctp_outq *q,
75 struct sctp_chunk *ch)
76{
David S. Miller79af02c2005-07-08 21:47:49 -070077 list_add(&ch->list, &q->out_chunk_list);
Linus Torvalds1da177e2005-04-16 15:20:36 -070078 q->out_qlen += ch->skb->len;
Linus Torvalds1da177e2005-04-16 15:20:36 -070079}
80
81/* Take data from the front of the queue. */
82static inline struct sctp_chunk *sctp_outq_dequeue_data(struct sctp_outq *q)
83{
David S. Miller79af02c2005-07-08 21:47:49 -070084 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);
Linus Torvalds1da177e2005-04-16 15:20:36 -070091 q->out_qlen -= ch->skb->len;
David S. Miller79af02c2005-07-08 21:47:49 -070092 }
Linus Torvalds1da177e2005-04-16 15:20:36 -070093 return ch;
94}
95/* Add data chunk to the end of the queue. */
96static inline void sctp_outq_tail_data(struct sctp_outq *q,
97 struct sctp_chunk *ch)
98{
David S. Miller79af02c2005-07-08 21:47:49 -070099 list_add_tail(&ch->list, &q->out_chunk_list);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700100 q->out_qlen += ch->skb->len;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700101}
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 */
109static inline int sctp_cacc_skip_3_1_d(struct sctp_transport *primary,
110 struct sctp_transport *transport,
111 int count_of_newacks)
112{
wangweidongcb3f8372013-12-23 12:16:50 +0800113 if (count_of_newacks >= 2 && transport != primary)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700114 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 */
125static inline int sctp_cacc_skip_3_1_f(struct sctp_transport *transport,
126 int count_of_newacks)
127{
Vlad Yasevichf246a7b2011-04-18 19:13:56 +0000128 if (count_of_newacks < 2 &&
129 (transport && !transport->cacc.cacc_saw_newack))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700130 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 */
141static 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 */
162static 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,
Lucas De Marchi25985ed2011-03-30 22:57:33 -0300175 * then the sender MUST further execute steps 3.1 and
Linus Torvalds1da177e2005-04-16 15:20:36 -0700176 * 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
Lucas De Marchi25985ed2011-03-30 22:57:33 -0300181 * the sender SHOULD increment missing report count for
Linus Torvalds1da177e2005-04-16 15:20:36 -0700182 * t (according to [RFC2960] and [SCTP_STEWART_2002]).
183 */
184static 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 &&
Joe Perchesf64f9e72009-11-29 16:55:45 -0800190 (sctp_cacc_skip_3_1(primary, transport, count_of_newacks) ||
191 sctp_cacc_skip_3_2(primary, tsn)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700192 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 */
200void sctp_outq_init(struct sctp_association *asoc, struct sctp_outq *q)
201{
Neil Hormanc5c77742013-06-12 14:26:44 -0400202 memset(q, 0, sizeof(struct sctp_outq));
203
Linus Torvalds1da177e2005-04-16 15:20:36 -0700204 q->asoc = asoc;
David S. Miller79af02c2005-07-08 21:47:49 -0700205 INIT_LIST_HEAD(&q->out_chunk_list);
206 INIT_LIST_HEAD(&q->control_chunk_list);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700207 INIT_LIST_HEAD(&q->retransmit);
208 INIT_LIST_HEAD(&q->sacked);
209 INIT_LIST_HEAD(&q->abandoned);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700210}
211
212/* Free the outqueue structure and any related pending chunks.
213 */
Neil Horman2f94aab2013-01-17 11:15:08 +0000214static void __sctp_outq_teardown(struct sctp_outq *q)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700215{
216 struct sctp_transport *transport;
Robert P. J. Day9dbc15f2008-04-12 18:54:24 -0700217 struct list_head *lchunk, *temp;
David S. Miller79af02c2005-07-08 21:47:49 -0700218 struct sctp_chunk *chunk, *tmp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700219
220 /* Throw away unacknowledged chunks. */
Robert P. J. Day9dbc15f2008-04-12 18:54:24 -0700221 list_for_each_entry(transport, &q->asoc->peer.transport_addr_list,
222 transports) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700223 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
Linus Torvalds1da177e2005-04-16 15:20:36 -0700267 /* Throw away any leftover control chunks. */
David S. Miller79af02c2005-07-08 21:47:49 -0700268 list_for_each_entry_safe(chunk, tmp, &q->control_chunk_list, list) {
269 list_del_init(&chunk->list);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700270 sctp_chunk_free(chunk);
David S. Miller79af02c2005-07-08 21:47:49 -0700271 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700272}
273
Neil Horman2f94aab2013-01-17 11:15:08 +0000274void sctp_outq_teardown(struct sctp_outq *q)
275{
276 __sctp_outq_teardown(q);
277 sctp_outq_init(q->asoc, q);
278}
279
Linus Torvalds1da177e2005-04-16 15:20:36 -0700280/* Free the outqueue structure and any related pending chunks. */
281void sctp_outq_free(struct sctp_outq *q)
282{
283 /* Throw away leftover chunks. */
Neil Horman2f94aab2013-01-17 11:15:08 +0000284 __sctp_outq_teardown(q);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700285}
286
287/* Put a new chunk in an sctp_outq. */
Marcelo Ricardo Leitnercea87682016-03-10 18:33:07 -0300288int sctp_outq_tail(struct sctp_outq *q, struct sctp_chunk *chunk, gfp_t gfp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700289{
Eric W. Biedermanb01a2402012-08-06 08:47:55 +0000290 struct net *net = sock_net(q->asoc->base.sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700291 int error = 0;
292
Daniel Borkmannbb333812013-06-28 19:49:40 +0200293 pr_debug("%s: outq:%p, chunk:%p[%s]\n", __func__, q, chunk,
294 chunk && chunk->chunk_hdr ?
295 sctp_cname(SCTP_ST_CHUNK(chunk->chunk_hdr->type)) :
296 "illegal chunk");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700297
298 /* If it is data, queue it up, otherwise, send it
299 * immediately.
300 */
Shan Weiec7b9512010-04-30 22:41:09 -0400301 if (sctp_chunk_is_data(chunk)) {
Xin Long2c897912016-09-14 02:04:18 +0800302 pr_debug("%s: outqueueing: outq:%p, chunk:%p[%s])\n",
303 __func__, q, chunk, chunk && chunk->chunk_hdr ?
304 sctp_cname(SCTP_ST_CHUNK(chunk->chunk_hdr->type)) :
305 "illegal chunk");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700306
Xin Long2c897912016-09-14 02:04:18 +0800307 sctp_outq_tail_data(q, chunk);
308 if (chunk->asoc->prsctp_enable &&
309 SCTP_PR_PRIO_ENABLED(chunk->sinfo.sinfo_flags))
310 chunk->asoc->sent_cnt_removable++;
311 if (chunk->chunk_hdr->flags & SCTP_DATA_UNORDERED)
312 SCTP_INC_STATS(net, SCTP_MIB_OUTUNORDERCHUNKS);
313 else
314 SCTP_INC_STATS(net, SCTP_MIB_OUTORDERCHUNKS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700315 } else {
David S. Miller79af02c2005-07-08 21:47:49 -0700316 list_add_tail(&chunk->list, &q->control_chunk_list);
Eric W. Biedermanb01a2402012-08-06 08:47:55 +0000317 SCTP_INC_STATS(net, SCTP_MIB_OUTCTRLCHUNKS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700318 }
319
Linus Torvalds1da177e2005-04-16 15:20:36 -0700320 if (!q->cork)
Marcelo Ricardo Leitnercea87682016-03-10 18:33:07 -0300321 error = sctp_outq_flush(q, 0, gfp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700322
323 return error;
324}
325
326/* Insert a chunk into the sorted list based on the TSNs. The retransmit list
327 * and the abandoned list are in ascending order.
328 */
329static void sctp_insert_list(struct list_head *head, struct list_head *new)
330{
331 struct list_head *pos;
332 struct sctp_chunk *nchunk, *lchunk;
333 __u32 ntsn, ltsn;
334 int done = 0;
335
336 nchunk = list_entry(new, struct sctp_chunk, transmitted_list);
337 ntsn = ntohl(nchunk->subh.data_hdr->tsn);
338
339 list_for_each(pos, head) {
340 lchunk = list_entry(pos, struct sctp_chunk, transmitted_list);
341 ltsn = ntohl(lchunk->subh.data_hdr->tsn);
342 if (TSN_lt(ntsn, ltsn)) {
343 list_add(new, pos->prev);
344 done = 1;
345 break;
346 }
347 }
348 if (!done)
YOSHIFUJI Hideakid808ad92007-02-09 23:25:18 +0900349 list_add_tail(new, head);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700350}
351
Xin Long8dbdf1f2016-07-09 19:47:45 +0800352static int sctp_prsctp_prune_sent(struct sctp_association *asoc,
353 struct sctp_sndrcvinfo *sinfo,
354 struct list_head *queue, int msg_len)
355{
356 struct sctp_chunk *chk, *temp;
357
358 list_for_each_entry_safe(chk, temp, queue, transmitted_list) {
359 if (!SCTP_PR_PRIO_ENABLED(chk->sinfo.sinfo_flags) ||
360 chk->prsctp_param <= sinfo->sinfo_timetolive)
361 continue;
362
363 list_del_init(&chk->transmitted_list);
364 sctp_insert_list(&asoc->outqueue.abandoned,
365 &chk->transmitted_list);
366
367 asoc->sent_cnt_removable--;
368 asoc->abandoned_sent[SCTP_PR_INDEX(PRIO)]++;
369
370 if (!chk->tsn_gap_acked) {
371 if (chk->transport)
372 chk->transport->flight_size -=
373 sctp_data_size(chk);
374 asoc->outqueue.outstanding_bytes -= sctp_data_size(chk);
375 }
376
377 msg_len -= SCTP_DATA_SNDSIZE(chk) +
378 sizeof(struct sk_buff) +
379 sizeof(struct sctp_chunk);
380 if (msg_len <= 0)
381 break;
382 }
383
384 return msg_len;
385}
386
387static int sctp_prsctp_prune_unsent(struct sctp_association *asoc,
388 struct sctp_sndrcvinfo *sinfo,
389 struct list_head *queue, int msg_len)
390{
391 struct sctp_chunk *chk, *temp;
392
393 list_for_each_entry_safe(chk, temp, queue, list) {
394 if (!SCTP_PR_PRIO_ENABLED(chk->sinfo.sinfo_flags) ||
395 chk->prsctp_param <= sinfo->sinfo_timetolive)
396 continue;
397
398 list_del_init(&chk->list);
399 asoc->sent_cnt_removable--;
400 asoc->abandoned_unsent[SCTP_PR_INDEX(PRIO)]++;
401
402 msg_len -= SCTP_DATA_SNDSIZE(chk) +
403 sizeof(struct sk_buff) +
404 sizeof(struct sctp_chunk);
405 sctp_chunk_free(chk);
406 if (msg_len <= 0)
407 break;
408 }
409
410 return msg_len;
411}
412
413/* Abandon the chunks according their priorities */
414void sctp_prsctp_prune(struct sctp_association *asoc,
415 struct sctp_sndrcvinfo *sinfo, int msg_len)
416{
417 struct sctp_transport *transport;
418
419 if (!asoc->prsctp_enable || !asoc->sent_cnt_removable)
420 return;
421
422 msg_len = sctp_prsctp_prune_sent(asoc, sinfo,
423 &asoc->outqueue.retransmit,
424 msg_len);
425 if (msg_len <= 0)
426 return;
427
428 list_for_each_entry(transport, &asoc->peer.transport_addr_list,
429 transports) {
430 msg_len = sctp_prsctp_prune_sent(asoc, sinfo,
431 &transport->transmitted,
432 msg_len);
433 if (msg_len <= 0)
434 return;
435 }
436
437 sctp_prsctp_prune_unsent(asoc, sinfo,
438 &asoc->outqueue.out_chunk_list,
439 msg_len);
440}
441
Linus Torvalds1da177e2005-04-16 15:20:36 -0700442/* Mark all the eligible packets on a transport for retransmission. */
443void sctp_retransmit_mark(struct sctp_outq *q,
444 struct sctp_transport *transport,
Vlad Yasevichb6157d82007-10-24 15:59:16 -0400445 __u8 reason)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700446{
447 struct list_head *lchunk, *ltemp;
448 struct sctp_chunk *chunk;
449
450 /* Walk through the specified transmitted queue. */
451 list_for_each_safe(lchunk, ltemp, &transport->transmitted) {
452 chunk = list_entry(lchunk, struct sctp_chunk,
453 transmitted_list);
454
455 /* If the chunk is abandoned, move it to abandoned list. */
456 if (sctp_chunk_abandoned(chunk)) {
457 list_del_init(lchunk);
458 sctp_insert_list(&q->abandoned, lchunk);
Vlad Yasevich8c4a2d42007-02-21 02:06:04 -0800459
460 /* If this chunk has not been previousely acked,
461 * stop considering it 'outstanding'. Our peer
462 * will most likely never see it since it will
463 * not be retransmitted
464 */
465 if (!chunk->tsn_gap_acked) {
Vlad Yasevich31b02e12009-09-04 18:21:00 -0400466 if (chunk->transport)
467 chunk->transport->flight_size -=
468 sctp_data_size(chunk);
Vlad Yasevich8c4a2d42007-02-21 02:06:04 -0800469 q->outstanding_bytes -= sctp_data_size(chunk);
Thomas Grafa76c0ad2011-12-19 04:11:40 +0000470 q->asoc->peer.rwnd += sctp_data_size(chunk);
Vlad Yasevich8c4a2d42007-02-21 02:06:04 -0800471 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700472 continue;
473 }
474
Vlad Yasevichb6157d82007-10-24 15:59:16 -0400475 /* If we are doing retransmission due to a timeout or pmtu
476 * discovery, only the chunks that are not yet acked should
477 * be added to the retransmit queue.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700478 */
Vlad Yasevichb6157d82007-10-24 15:59:16 -0400479 if ((reason == SCTP_RTXR_FAST_RTX &&
Neil Hormanc226ef92008-07-25 12:44:09 -0400480 (chunk->fast_retransmit == SCTP_NEED_FRTX)) ||
Vlad Yasevichb6157d82007-10-24 15:59:16 -0400481 (reason != SCTP_RTXR_FAST_RTX && !chunk->tsn_gap_acked)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700482 /* RFC 2960 6.2.1 Processing a Received SACK
483 *
484 * C) Any time a DATA chunk is marked for
485 * retransmission (via either T3-rtx timer expiration
486 * (Section 6.3.3) or via fast retransmit
487 * (Section 7.2.4)), add the data size of those
488 * chunks to the rwnd.
489 */
Thomas Grafa76c0ad2011-12-19 04:11:40 +0000490 q->asoc->peer.rwnd += sctp_data_size(chunk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700491 q->outstanding_bytes -= sctp_data_size(chunk);
Vlad Yasevich31b02e12009-09-04 18:21:00 -0400492 if (chunk->transport)
493 transport->flight_size -= sctp_data_size(chunk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700494
495 /* sctpimpguide-05 Section 2.8.2
496 * M5) If a T3-rtx timer expires, the
497 * 'TSN.Missing.Report' of all affected TSNs is set
498 * to 0.
499 */
500 chunk->tsn_missing_report = 0;
501
502 /* If a chunk that is being used for RTT measurement
503 * has to be retransmitted, we cannot use this chunk
504 * anymore for RTT measurements. Reset rto_pending so
505 * that a new RTT measurement is started when a new
506 * data chunk is sent.
507 */
508 if (chunk->rtt_in_progress) {
509 chunk->rtt_in_progress = 0;
510 transport->rto_pending = 0;
511 }
512
Xufeng Zhang6eabca52013-11-25 11:26:57 +0800513 chunk->resent = 1;
514
Linus Torvalds1da177e2005-04-16 15:20:36 -0700515 /* Move the chunk to the retransmit queue. The chunks
516 * on the retransmit queue are always kept in order.
517 */
518 list_del_init(lchunk);
519 sctp_insert_list(&q->retransmit, lchunk);
520 }
521 }
522
Daniel Borkmannbb333812013-06-28 19:49:40 +0200523 pr_debug("%s: transport:%p, reason:%d, cwnd:%d, ssthresh:%d, "
524 "flight_size:%d, pba:%d\n", __func__, transport, reason,
525 transport->cwnd, transport->ssthresh, transport->flight_size,
526 transport->partial_bytes_acked);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700527}
528
529/* Mark all the eligible packets on a transport for retransmission and force
530 * one packet out.
531 */
532void sctp_retransmit(struct sctp_outq *q, struct sctp_transport *transport,
533 sctp_retransmit_reason_t reason)
534{
Eric W. Biedermanb01a2402012-08-06 08:47:55 +0000535 struct net *net = sock_net(q->asoc->base.sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700536
wangweidongcb3f8372013-12-23 12:16:50 +0800537 switch (reason) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700538 case SCTP_RTXR_T3_RTX:
Eric W. Biedermanb01a2402012-08-06 08:47:55 +0000539 SCTP_INC_STATS(net, SCTP_MIB_T3_RETRANSMITS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700540 sctp_transport_lower_cwnd(transport, SCTP_LOWER_CWND_T3_RTX);
541 /* Update the retran path if the T3-rtx timer has expired for
542 * the current retran path.
543 */
544 if (transport == transport->asoc->peer.retran_path)
545 sctp_assoc_update_retran_path(transport->asoc);
Neil Horman58fbbed2008-02-29 11:40:56 -0800546 transport->asoc->rtx_data_chunks +=
547 transport->asoc->unack_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700548 break;
549 case SCTP_RTXR_FAST_RTX:
Eric W. Biedermanb01a2402012-08-06 08:47:55 +0000550 SCTP_INC_STATS(net, SCTP_MIB_FAST_RETRANSMITS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700551 sctp_transport_lower_cwnd(transport, SCTP_LOWER_CWND_FAST_RTX);
Vlad Yasevich62aeaff2008-06-04 12:39:11 -0700552 q->fast_rtx = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700553 break;
554 case SCTP_RTXR_PMTUD:
Eric W. Biedermanb01a2402012-08-06 08:47:55 +0000555 SCTP_INC_STATS(net, SCTP_MIB_PMTUD_RETRANSMITS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700556 break;
Vlad Yasevichb6157d82007-10-24 15:59:16 -0400557 case SCTP_RTXR_T1_RTX:
Eric W. Biedermanb01a2402012-08-06 08:47:55 +0000558 SCTP_INC_STATS(net, SCTP_MIB_T1_RETRANSMITS);
Neil Horman58fbbed2008-02-29 11:40:56 -0800559 transport->asoc->init_retries++;
Vlad Yasevichb6157d82007-10-24 15:59:16 -0400560 break;
Sridhar Samudralaac0b0462006-08-22 00:15:33 -0700561 default:
562 BUG();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700563 }
564
Vlad Yasevichb6157d82007-10-24 15:59:16 -0400565 sctp_retransmit_mark(q, transport, reason);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700566
567 /* PR-SCTP A5) Any time the T3-rtx timer expires, on any destination,
568 * the sender SHOULD try to advance the "Advanced.Peer.Ack.Point" by
569 * following the procedures outlined in C1 - C5.
570 */
Vlad Yasevich8b750ce2008-06-04 12:39:36 -0700571 if (reason == SCTP_RTXR_T3_RTX)
572 sctp_generate_fwdtsn(q, q->asoc->ctsn_ack_point);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700573
Vlad Yasevich8b750ce2008-06-04 12:39:36 -0700574 /* Flush the queues only on timeout, since fast_rtx is only
575 * triggered during sack processing and the queue
576 * will be flushed at the end.
577 */
578 if (reason != SCTP_RTXR_FAST_RTX)
Xin Long64519442016-09-14 02:04:21 +0800579 sctp_outq_flush(q, /* rtx_timeout */ 1, GFP_ATOMIC);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700580}
581
582/*
583 * Transmit DATA chunks on the retransmit queue. Upon return from
584 * sctp_outq_flush_rtx() the packet 'pkt' may contain chunks which
585 * need to be transmitted by the caller.
586 * We assume that pkt->transport has already been set.
587 *
588 * The return value is a normal kernel error return value.
589 */
590static int sctp_outq_flush_rtx(struct sctp_outq *q, struct sctp_packet *pkt,
591 int rtx_timeout, int *start_timer)
592{
593 struct list_head *lqueue;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700594 struct sctp_transport *transport = pkt->transport;
595 sctp_xmit_t status;
596 struct sctp_chunk *chunk, *chunk1;
Vlad Yasevich62aeaff2008-06-04 12:39:11 -0700597 int fast_rtx;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700598 int error = 0;
Vlad Yasevich62aeaff2008-06-04 12:39:11 -0700599 int timer = 0;
Vlad Yasevich8b750ce2008-06-04 12:39:36 -0700600 int done = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700601
Linus Torvalds1da177e2005-04-16 15:20:36 -0700602 lqueue = &q->retransmit;
Vlad Yasevich62aeaff2008-06-04 12:39:11 -0700603 fast_rtx = q->fast_rtx;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700604
Vlad Yasevich8b750ce2008-06-04 12:39:36 -0700605 /* This loop handles time-out retransmissions, fast retransmissions,
606 * and retransmissions due to opening of whindow.
607 *
608 * RFC 2960 6.3.3 Handle T3-rtx Expiration
Linus Torvalds1da177e2005-04-16 15:20:36 -0700609 *
610 * E3) Determine how many of the earliest (i.e., lowest TSN)
611 * outstanding DATA chunks for the address for which the
612 * T3-rtx has expired will fit into a single packet, subject
613 * to the MTU constraint for the path corresponding to the
614 * destination transport address to which the retransmission
615 * is being sent (this may be different from the address for
616 * which the timer expires [see Section 6.4]). Call this value
617 * K. Bundle and retransmit those K DATA chunks in a single
618 * packet to the destination endpoint.
619 *
620 * [Just to be painfully clear, if we are retransmitting
621 * because a timeout just happened, we should send only ONE
622 * packet of retransmitted data.]
Vlad Yasevich8b750ce2008-06-04 12:39:36 -0700623 *
624 * For fast retransmissions we also send only ONE packet. However,
625 * if we are just flushing the queue due to open window, we'll
626 * try to send as much as possible.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700627 */
Vlad Yasevich8b750ce2008-06-04 12:39:36 -0700628 list_for_each_entry_safe(chunk, chunk1, lqueue, transmitted_list) {
Wei Yongjun4c6a6f42011-04-19 21:32:28 +0000629 /* If the chunk is abandoned, move it to abandoned list. */
630 if (sctp_chunk_abandoned(chunk)) {
631 list_del_init(&chunk->transmitted_list);
632 sctp_insert_list(&q->abandoned,
633 &chunk->transmitted_list);
634 continue;
635 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700636
637 /* Make sure that Gap Acked TSNs are not retransmitted. A
638 * simple approach is just to move such TSNs out of the
639 * way and into a 'transmitted' queue and skip to the
640 * next chunk.
641 */
642 if (chunk->tsn_gap_acked) {
Wei Yongjun54a27922012-09-03 23:58:16 +0000643 list_move_tail(&chunk->transmitted_list,
644 &transport->transmitted);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700645 continue;
646 }
647
Vlad Yasevich8b750ce2008-06-04 12:39:36 -0700648 /* If we are doing fast retransmit, ignore non-fast_rtransmit
649 * chunks
650 */
651 if (fast_rtx && !chunk->fast_retransmit)
652 continue;
653
Wei Yongjunbc4f8412010-04-30 22:38:53 -0400654redo:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700655 /* Attempt to append this chunk to the packet. */
656 status = sctp_packet_append_chunk(pkt, chunk);
657
658 switch (status) {
659 case SCTP_XMIT_PMTU_FULL:
Wei Yongjunbc4f8412010-04-30 22:38:53 -0400660 if (!pkt->has_data && !pkt->has_cookie_echo) {
661 /* If this packet did not contain DATA then
662 * retransmission did not happen, so do it
663 * again. We'll ignore the error here since
664 * control chunks are already freed so there
665 * is nothing we can do.
666 */
Marcelo Ricardo Leitnercea87682016-03-10 18:33:07 -0300667 sctp_packet_transmit(pkt, GFP_ATOMIC);
Wei Yongjunbc4f8412010-04-30 22:38:53 -0400668 goto redo;
669 }
670
Linus Torvalds1da177e2005-04-16 15:20:36 -0700671 /* Send this packet. */
Marcelo Ricardo Leitnercea87682016-03-10 18:33:07 -0300672 error = sctp_packet_transmit(pkt, GFP_ATOMIC);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700673
674 /* If we are retransmitting, we should only
675 * send a single packet.
Vlad Yasevichf246a7b2011-04-18 19:13:56 +0000676 * Otherwise, try appending this chunk again.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700677 */
Vlad Yasevich8b750ce2008-06-04 12:39:36 -0700678 if (rtx_timeout || fast_rtx)
679 done = 1;
Vlad Yasevichf246a7b2011-04-18 19:13:56 +0000680 else
681 goto redo;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700682
Vlad Yasevich8b750ce2008-06-04 12:39:36 -0700683 /* Bundle next chunk in the next round. */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700684 break;
685
686 case SCTP_XMIT_RWND_FULL:
YOSHIFUJI Hideakid808ad92007-02-09 23:25:18 +0900687 /* Send this packet. */
Marcelo Ricardo Leitnercea87682016-03-10 18:33:07 -0300688 error = sctp_packet_transmit(pkt, GFP_ATOMIC);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700689
690 /* Stop sending DATA as there is no more room
691 * at the receiver.
692 */
Vlad Yasevich8b750ce2008-06-04 12:39:36 -0700693 done = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700694 break;
695
David Laight526cbef2014-07-22 08:59:14 +0000696 case SCTP_XMIT_DELAY:
YOSHIFUJI Hideakid808ad92007-02-09 23:25:18 +0900697 /* Send this packet. */
Marcelo Ricardo Leitnercea87682016-03-10 18:33:07 -0300698 error = sctp_packet_transmit(pkt, GFP_ATOMIC);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700699
700 /* Stop sending DATA because of nagle delay. */
Vlad Yasevich8b750ce2008-06-04 12:39:36 -0700701 done = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700702 break;
703
704 default:
705 /* The append was successful, so add this chunk to
706 * the transmitted list.
707 */
Wei Yongjun54a27922012-09-03 23:58:16 +0000708 list_move_tail(&chunk->transmitted_list,
709 &transport->transmitted);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700710
YOSHIFUJI Hideakid808ad92007-02-09 23:25:18 +0900711 /* Mark the chunk as ineligible for fast retransmit
Linus Torvalds1da177e2005-04-16 15:20:36 -0700712 * after it is retransmitted.
713 */
Neil Hormanc226ef92008-07-25 12:44:09 -0400714 if (chunk->fast_retransmit == SCTP_NEED_FRTX)
715 chunk->fast_retransmit = SCTP_DONT_FRTX;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700716
Michele Baldessari196d6752012-12-01 04:49:42 +0000717 q->asoc->stats.rtxchunks++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700718 break;
Stephen Hemminger3ff50b72007-04-20 17:09:22 -0700719 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700720
Vlad Yasevich62aeaff2008-06-04 12:39:11 -0700721 /* Set the timer if there were no errors */
722 if (!error && !timer)
723 timer = 1;
724
Vlad Yasevich8b750ce2008-06-04 12:39:36 -0700725 if (done)
726 break;
727 }
728
729 /* If we are here due to a retransmit timeout or a fast
730 * retransmit and if there are any chunks left in the retransmit
731 * queue that could not fit in the PMTU sized packet, they need
732 * to be marked as ineligible for a subsequent fast retransmit.
733 */
734 if (rtx_timeout || fast_rtx) {
735 list_for_each_entry(chunk1, lqueue, transmitted_list) {
Neil Hormanc226ef92008-07-25 12:44:09 -0400736 if (chunk1->fast_retransmit == SCTP_NEED_FRTX)
737 chunk1->fast_retransmit = SCTP_DONT_FRTX;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700738 }
739 }
740
Vlad Yasevich62aeaff2008-06-04 12:39:11 -0700741 *start_timer = timer;
742
743 /* Clear fast retransmit hint */
744 if (fast_rtx)
745 q->fast_rtx = 0;
746
Linus Torvalds1da177e2005-04-16 15:20:36 -0700747 return error;
748}
749
750/* Cork the outqueue so queued chunks are really queued. */
Marcelo Ricardo Leitnercea87682016-03-10 18:33:07 -0300751int sctp_outq_uncork(struct sctp_outq *q, gfp_t gfp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700752{
Vlad Yasevich7d54dc62007-11-09 11:43:41 -0500753 if (q->cork)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700754 q->cork = 0;
Daniel Borkmanndacda322013-04-16 11:07:14 +0000755
Marcelo Ricardo Leitnercea87682016-03-10 18:33:07 -0300756 return sctp_outq_flush(q, 0, gfp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700757}
758
Vlad Yasevich2e3216c2008-06-19 16:08:18 -0700759
Linus Torvalds1da177e2005-04-16 15:20:36 -0700760/*
761 * Try to flush an outqueue.
762 *
763 * Description: Send everything in q which we legally can, subject to
764 * congestion limitations.
765 * * Note: This function can be called from multiple contexts so appropriate
766 * locking concerns must be made. Today we use the sock lock to protect
767 * this function.
768 */
Marcelo Ricardo Leitnercea87682016-03-10 18:33:07 -0300769static int sctp_outq_flush(struct sctp_outq *q, int rtx_timeout, gfp_t gfp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700770{
771 struct sctp_packet *packet;
772 struct sctp_packet singleton;
773 struct sctp_association *asoc = q->asoc;
774 __u16 sport = asoc->base.bind_addr.port;
775 __u16 dport = asoc->peer.port;
776 __u32 vtag = asoc->peer.i.init_tag;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700777 struct sctp_transport *transport = NULL;
778 struct sctp_transport *new_transport;
David S. Miller79af02c2005-07-08 21:47:49 -0700779 struct sctp_chunk *chunk, *tmp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700780 sctp_xmit_t status;
781 int error = 0;
782 int start_timer = 0;
Vlad Yasevich2e3216c2008-06-19 16:08:18 -0700783 int one_packet = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700784
785 /* These transports have chunks to send. */
786 struct list_head transport_list;
787 struct list_head *ltransport;
788
789 INIT_LIST_HEAD(&transport_list);
790 packet = NULL;
791
792 /*
793 * 6.10 Bundling
794 * ...
795 * When bundling control chunks with DATA chunks, an
796 * endpoint MUST place control chunks first in the outbound
797 * SCTP packet. The transmitter MUST transmit DATA chunks
798 * within a SCTP packet in increasing order of TSN.
799 * ...
800 */
801
David S. Miller79af02c2005-07-08 21:47:49 -0700802 list_for_each_entry_safe(chunk, tmp, &q->control_chunk_list, list) {
Michio Honda8a07eb02011-04-26 20:19:36 +0900803 /* RFC 5061, 5.3
804 * F1) This means that until such time as the ASCONF
805 * containing the add is acknowledged, the sender MUST
806 * NOT use the new IP address as a source for ANY SCTP
807 * packet except on carrying an ASCONF Chunk.
808 */
809 if (asoc->src_out_of_asoc_ok &&
810 chunk->chunk_hdr->type != SCTP_CID_ASCONF)
811 continue;
812
David S. Miller79af02c2005-07-08 21:47:49 -0700813 list_del_init(&chunk->list);
814
Linus Torvalds1da177e2005-04-16 15:20:36 -0700815 /* Pick the right transport to use. */
816 new_transport = chunk->transport;
817
818 if (!new_transport) {
Vlad Yasevicha08de642007-12-20 14:11:47 -0800819 /*
820 * If we have a prior transport pointer, see if
821 * the destination address of the chunk
822 * matches the destination address of the
823 * current transport. If not a match, then
824 * try to look up the transport with a given
825 * destination address. We do this because
826 * after processing ASCONFs, we may have new
827 * transports created.
828 */
829 if (transport &&
830 sctp_cmp_addr_exact(&chunk->dest,
831 &transport->ipaddr))
832 new_transport = transport;
833 else
834 new_transport = sctp_assoc_lookup_paddr(asoc,
835 &chunk->dest);
836
837 /* if we still don't have a new transport, then
838 * use the current active path.
839 */
840 if (!new_transport)
841 new_transport = asoc->peer.active_path;
Sridhar Samudralaad8fec12006-07-21 14:48:50 -0700842 } else if ((new_transport->state == SCTP_INACTIVE) ||
Neil Horman5aa93bc2012-07-21 07:56:07 +0000843 (new_transport->state == SCTP_UNCONFIRMED) ||
844 (new_transport->state == SCTP_PF)) {
Frank Filz3f7a87d2005-06-20 13:14:57 -0700845 /* If the chunk is Heartbeat or Heartbeat Ack,
846 * send it to chunk->transport, even if it's
Linus Torvalds1da177e2005-04-16 15:20:36 -0700847 * inactive.
848 *
849 * 3.3.6 Heartbeat Acknowledgement:
YOSHIFUJI Hideakid808ad92007-02-09 23:25:18 +0900850 * ...
Linus Torvalds1da177e2005-04-16 15:20:36 -0700851 * A HEARTBEAT ACK is always sent to the source IP
852 * address of the IP datagram containing the
853 * HEARTBEAT chunk to which this ack is responding.
YOSHIFUJI Hideakid808ad92007-02-09 23:25:18 +0900854 * ...
Vlad Yasevicha08de642007-12-20 14:11:47 -0800855 *
856 * ASCONF_ACKs also must be sent to the source.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700857 */
858 if (chunk->chunk_hdr->type != SCTP_CID_HEARTBEAT &&
Vlad Yasevicha08de642007-12-20 14:11:47 -0800859 chunk->chunk_hdr->type != SCTP_CID_HEARTBEAT_ACK &&
860 chunk->chunk_hdr->type != SCTP_CID_ASCONF_ACK)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700861 new_transport = asoc->peer.active_path;
862 }
863
864 /* Are we switching transports?
865 * Take care of transport locks.
866 */
867 if (new_transport != transport) {
868 transport = new_transport;
869 if (list_empty(&transport->send_ready)) {
870 list_add_tail(&transport->send_ready,
871 &transport_list);
872 }
873 packet = &transport->packet;
874 sctp_packet_config(packet, vtag,
875 asoc->peer.ecn_capable);
876 }
877
878 switch (chunk->chunk_hdr->type) {
879 /*
880 * 6.10 Bundling
881 * ...
882 * An endpoint MUST NOT bundle INIT, INIT ACK or SHUTDOWN
883 * COMPLETE with any other chunks. [Send them immediately.]
884 */
885 case SCTP_CID_INIT:
886 case SCTP_CID_INIT_ACK:
887 case SCTP_CID_SHUTDOWN_COMPLETE:
888 sctp_packet_init(&singleton, transport, sport, dport);
889 sctp_packet_config(&singleton, vtag, 0);
890 sctp_packet_append_chunk(&singleton, chunk);
Marcelo Ricardo Leitnercea87682016-03-10 18:33:07 -0300891 error = sctp_packet_transmit(&singleton, gfp);
Xin Long64519442016-09-14 02:04:21 +0800892 if (error < 0) {
893 asoc->base.sk->sk_err = -error;
894 return 0;
895 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700896 break;
897
898 case SCTP_CID_ABORT:
Gui Jianfengf4ad85c2008-04-12 18:39:34 -0700899 if (sctp_test_T_bit(chunk)) {
900 packet->vtag = asoc->c.my_vtag;
901 }
Vlad Yasevich2e3216c2008-06-19 16:08:18 -0700902 /* The following chunks are "response" chunks, i.e.
903 * they are generated in response to something we
904 * received. If we are sending these, then we can
905 * send only 1 packet containing these chunks.
906 */
907 case SCTP_CID_HEARTBEAT_ACK:
908 case SCTP_CID_SHUTDOWN_ACK:
909 case SCTP_CID_COOKIE_ACK:
910 case SCTP_CID_COOKIE_ECHO:
911 case SCTP_CID_ERROR:
912 case SCTP_CID_ECN_CWR:
913 case SCTP_CID_ASCONF_ACK:
914 one_packet = 1;
Lucas De Marchi25985ed2011-03-30 22:57:33 -0300915 /* Fall through */
Vlad Yasevich2e3216c2008-06-19 16:08:18 -0700916
Linus Torvalds1da177e2005-04-16 15:20:36 -0700917 case SCTP_CID_SACK:
918 case SCTP_CID_HEARTBEAT:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700919 case SCTP_CID_SHUTDOWN:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700920 case SCTP_CID_ECN_ECNE:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700921 case SCTP_CID_ASCONF:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700922 case SCTP_CID_FWD_TSN:
Vlad Yasevich2e3216c2008-06-19 16:08:18 -0700923 status = sctp_packet_transmit_chunk(packet, chunk,
Marcelo Ricardo Leitnercea87682016-03-10 18:33:07 -0300924 one_packet, gfp);
Vlad Yasevich2e3216c2008-06-19 16:08:18 -0700925 if (status != SCTP_XMIT_OK) {
926 /* put the chunk back */
927 list_add(&chunk->list, &q->control_chunk_list);
Michele Baldessari196d6752012-12-01 04:49:42 +0000928 } else {
929 asoc->stats.octrlchunks++;
Wei Yongjunbd69b982010-04-30 21:42:43 -0400930 /* PR-SCTP C5) If a FORWARD TSN is sent, the
931 * sender MUST assure that at least one T3-rtx
932 * timer is running.
933 */
Marcelo Ricardo Leitnerba6f5e32016-04-06 15:15:19 -0300934 if (chunk->chunk_hdr->type == SCTP_CID_FWD_TSN) {
935 sctp_transport_reset_t3_rtx(transport);
936 transport->last_time_sent = jiffies;
937 }
Vlad Yasevich2e3216c2008-06-19 16:08:18 -0700938 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700939 break;
940
941 default:
942 /* We built a chunk with an illegal type! */
943 BUG();
Stephen Hemminger3ff50b72007-04-20 17:09:22 -0700944 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700945 }
946
Michio Honda8a07eb02011-04-26 20:19:36 +0900947 if (q->asoc->src_out_of_asoc_ok)
948 goto sctp_flush_out;
949
Linus Torvalds1da177e2005-04-16 15:20:36 -0700950 /* Is it OK to send data chunks? */
951 switch (asoc->state) {
952 case SCTP_STATE_COOKIE_ECHOED:
953 /* Only allow bundling when this packet has a COOKIE-ECHO
954 * chunk.
955 */
956 if (!packet || !packet->has_cookie_echo)
957 break;
958
959 /* fallthru */
960 case SCTP_STATE_ESTABLISHED:
961 case SCTP_STATE_SHUTDOWN_PENDING:
962 case SCTP_STATE_SHUTDOWN_RECEIVED:
963 /*
964 * RFC 2960 6.1 Transmission of DATA Chunks
965 *
966 * C) When the time comes for the sender to transmit,
967 * before sending new DATA chunks, the sender MUST
968 * first transmit any outstanding DATA chunks which
969 * are marked for retransmission (limited by the
970 * current cwnd).
971 */
972 if (!list_empty(&q->retransmit)) {
Michio Hondaf207c052011-06-16 10:54:23 +0900973 if (asoc->peer.retran_path->state == SCTP_UNCONFIRMED)
974 goto sctp_flush_out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700975 if (transport == asoc->peer.retran_path)
976 goto retran;
977
978 /* Switch transports & prepare the packet. */
979
980 transport = asoc->peer.retran_path;
981
982 if (list_empty(&transport->send_ready)) {
983 list_add_tail(&transport->send_ready,
984 &transport_list);
985 }
986
987 packet = &transport->packet;
988 sctp_packet_config(packet, vtag,
989 asoc->peer.ecn_capable);
990 retran:
991 error = sctp_outq_flush_rtx(q, packet,
992 rtx_timeout, &start_timer);
Xin Long64519442016-09-14 02:04:21 +0800993 if (error < 0)
994 asoc->base.sk->sk_err = -error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700995
Marcelo Ricardo Leitnerba6f5e32016-04-06 15:15:19 -0300996 if (start_timer) {
997 sctp_transport_reset_t3_rtx(transport);
998 transport->last_time_sent = jiffies;
999 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001000
1001 /* This can happen on COOKIE-ECHO resend. Only
1002 * one chunk can get bundled with a COOKIE-ECHO.
1003 */
1004 if (packet->has_cookie_echo)
1005 goto sctp_flush_out;
1006
1007 /* Don't send new data if there is still data
1008 * waiting to retransmit.
1009 */
1010 if (!list_empty(&q->retransmit))
1011 goto sctp_flush_out;
1012 }
1013
Vlad Yasevich46d5a802009-11-23 15:54:00 -05001014 /* Apply Max.Burst limitation to the current transport in
1015 * case it will be used for new data. We are going to
1016 * rest it before we return, but we want to apply the limit
1017 * to the currently queued data.
1018 */
1019 if (transport)
1020 sctp_transport_burst_limited(transport);
1021
Linus Torvalds1da177e2005-04-16 15:20:36 -07001022 /* Finally, transmit new packets. */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001023 while ((chunk = sctp_outq_dequeue_data(q)) != NULL) {
1024 /* RFC 2960 6.5 Every DATA chunk MUST carry a valid
1025 * stream identifier.
1026 */
1027 if (chunk->sinfo.sinfo_stream >=
1028 asoc->c.sinit_num_ostreams) {
1029
1030 /* Mark as failed send. */
1031 sctp_chunk_fail(chunk, SCTP_ERROR_INV_STRM);
Xin Long8dbdf1f2016-07-09 19:47:45 +08001032 if (asoc->prsctp_enable &&
1033 SCTP_PR_PRIO_ENABLED(chunk->sinfo.sinfo_flags))
1034 asoc->sent_cnt_removable--;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001035 sctp_chunk_free(chunk);
1036 continue;
1037 }
1038
1039 /* Has this chunk expired? */
1040 if (sctp_chunk_abandoned(chunk)) {
1041 sctp_chunk_fail(chunk, 0);
1042 sctp_chunk_free(chunk);
1043 continue;
1044 }
1045
1046 /* If there is a specified transport, use it.
1047 * Otherwise, we want to use the active path.
1048 */
1049 new_transport = chunk->transport;
Frank Filz3f7a87d2005-06-20 13:14:57 -07001050 if (!new_transport ||
Sridhar Samudralaad8fec12006-07-21 14:48:50 -07001051 ((new_transport->state == SCTP_INACTIVE) ||
Neil Horman5aa93bc2012-07-21 07:56:07 +00001052 (new_transport->state == SCTP_UNCONFIRMED) ||
1053 (new_transport->state == SCTP_PF)))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001054 new_transport = asoc->peer.active_path;
Marcelo Ricardo Leitner31b055e2016-03-18 18:39:19 -03001055 if (new_transport->state == SCTP_UNCONFIRMED) {
1056 WARN_ONCE(1, "Atempt to send packet on unconfirmed path.");
1057 sctp_chunk_fail(chunk, 0);
1058 sctp_chunk_free(chunk);
Michio Hondaf207c052011-06-16 10:54:23 +09001059 continue;
Marcelo Ricardo Leitner31b055e2016-03-18 18:39:19 -03001060 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001061
1062 /* Change packets if necessary. */
1063 if (new_transport != transport) {
1064 transport = new_transport;
1065
1066 /* Schedule to have this transport's
1067 * packet flushed.
1068 */
1069 if (list_empty(&transport->send_ready)) {
1070 list_add_tail(&transport->send_ready,
1071 &transport_list);
1072 }
1073
1074 packet = &transport->packet;
1075 sctp_packet_config(packet, vtag,
1076 asoc->peer.ecn_capable);
Vlad Yasevich46d5a802009-11-23 15:54:00 -05001077 /* We've switched transports, so apply the
1078 * Burst limit to the new transport.
1079 */
1080 sctp_transport_burst_limited(transport);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001081 }
1082
Daniel Borkmannbb333812013-06-28 19:49:40 +02001083 pr_debug("%s: outq:%p, chunk:%p[%s], tx-tsn:0x%x skb->head:%p "
1084 "skb->users:%d\n",
1085 __func__, q, chunk, chunk && chunk->chunk_hdr ?
1086 sctp_cname(SCTP_ST_CHUNK(chunk->chunk_hdr->type)) :
1087 "illegal chunk", ntohl(chunk->subh.data_hdr->tsn),
1088 chunk->skb ? chunk->skb->head : NULL, chunk->skb ?
1089 atomic_read(&chunk->skb->users) : -1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001090
1091 /* Add the chunk to the packet. */
Marcelo Ricardo Leitnercea87682016-03-10 18:33:07 -03001092 status = sctp_packet_transmit_chunk(packet, chunk, 0, gfp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001093
1094 switch (status) {
1095 case SCTP_XMIT_PMTU_FULL:
1096 case SCTP_XMIT_RWND_FULL:
David Laight526cbef2014-07-22 08:59:14 +00001097 case SCTP_XMIT_DELAY:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001098 /* We could not append this chunk, so put
1099 * the chunk back on the output queue.
1100 */
Daniel Borkmannbb333812013-06-28 19:49:40 +02001101 pr_debug("%s: could not transmit tsn:0x%x, status:%d\n",
1102 __func__, ntohl(chunk->subh.data_hdr->tsn),
1103 status);
1104
Linus Torvalds1da177e2005-04-16 15:20:36 -07001105 sctp_outq_head_data(q, chunk);
1106 goto sctp_flush_out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001107
1108 case SCTP_XMIT_OK:
Wei Yongjunb93d6472009-11-23 15:53:56 -05001109 /* The sender is in the SHUTDOWN-PENDING state,
1110 * The sender MAY set the I-bit in the DATA
1111 * chunk header.
1112 */
1113 if (asoc->state == SCTP_STATE_SHUTDOWN_PENDING)
1114 chunk->chunk_hdr->flags |= SCTP_DATA_SACK_IMM;
Michele Baldessari196d6752012-12-01 04:49:42 +00001115 if (chunk->chunk_hdr->flags & SCTP_DATA_UNORDERED)
1116 asoc->stats.ouodchunks++;
1117 else
1118 asoc->stats.oodchunks++;
Wei Yongjunb93d6472009-11-23 15:53:56 -05001119
Linus Torvalds1da177e2005-04-16 15:20:36 -07001120 break;
1121
1122 default:
1123 BUG();
1124 }
1125
YOSHIFUJI Hideakid808ad92007-02-09 23:25:18 +09001126 /* BUG: We assume that the sctp_packet_transmit()
Linus Torvalds1da177e2005-04-16 15:20:36 -07001127 * call below will succeed all the time and add the
1128 * chunk to the transmitted list and restart the
1129 * timers.
1130 * It is possible that the call can fail under OOM
1131 * conditions.
1132 *
1133 * Is this really a problem? Won't this behave
1134 * like a lost TSN?
1135 */
1136 list_add_tail(&chunk->transmitted_list,
1137 &transport->transmitted);
1138
Marcelo Ricardo Leitnerba6f5e32016-04-06 15:15:19 -03001139 sctp_transport_reset_t3_rtx(transport);
1140 transport->last_time_sent = jiffies;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001141
Linus Torvalds1da177e2005-04-16 15:20:36 -07001142 /* Only let one DATA chunk get bundled with a
1143 * COOKIE-ECHO chunk.
1144 */
1145 if (packet->has_cookie_echo)
1146 goto sctp_flush_out;
1147 }
1148 break;
1149
1150 default:
1151 /* Do nothing. */
1152 break;
1153 }
1154
1155sctp_flush_out:
1156
1157 /* Before returning, examine all the transports touched in
1158 * this call. Right now, we bluntly force clear all the
1159 * transports. Things might change after we implement Nagle.
1160 * But such an examination is still required.
1161 *
1162 * --xguo
1163 */
wangweidongcb3f8372013-12-23 12:16:50 +08001164 while ((ltransport = sctp_list_dequeue(&transport_list)) != NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001165 struct sctp_transport *t = list_entry(ltransport,
1166 struct sctp_transport,
1167 send_ready);
1168 packet = &t->packet;
Xin Long64519442016-09-14 02:04:21 +08001169 if (!sctp_packet_empty(packet)) {
Marcelo Ricardo Leitnercea87682016-03-10 18:33:07 -03001170 error = sctp_packet_transmit(packet, gfp);
Xin Long64519442016-09-14 02:04:21 +08001171 if (error < 0)
1172 asoc->base.sk->sk_err = -error;
1173 }
Vlad Yasevich46d5a802009-11-23 15:54:00 -05001174
1175 /* Clear the burst limited state, if any */
1176 sctp_transport_burst_reset(t);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001177 }
1178
Xin Long64519442016-09-14 02:04:21 +08001179 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001180}
1181
1182/* Update unack_data based on the incoming SACK chunk */
1183static void sctp_sack_update_unack_data(struct sctp_association *assoc,
1184 struct sctp_sackhdr *sack)
1185{
1186 sctp_sack_variable_t *frags;
1187 __u16 unack_data;
1188 int i;
1189
1190 unack_data = assoc->next_tsn - assoc->ctsn_ack_point - 1;
1191
1192 frags = sack->variable;
1193 for (i = 0; i < ntohs(sack->num_gap_ack_blocks); i++) {
1194 unack_data -= ((ntohs(frags[i].gab.end) -
1195 ntohs(frags[i].gab.start) + 1));
1196 }
1197
1198 assoc->unack_data = unack_data;
1199}
1200
Linus Torvalds1da177e2005-04-16 15:20:36 -07001201/* This is where we REALLY process a SACK.
1202 *
1203 * Process the SACK against the outqueue. Mostly, this just frees
1204 * things off the transmitted queue.
1205 */
Nicolas Dichteledfee032012-10-03 05:43:22 +00001206int sctp_outq_sack(struct sctp_outq *q, struct sctp_chunk *chunk)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001207{
1208 struct sctp_association *asoc = q->asoc;
Nicolas Dichteledfee032012-10-03 05:43:22 +00001209 struct sctp_sackhdr *sack = chunk->subh.sack_hdr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001210 struct sctp_transport *transport;
1211 struct sctp_chunk *tchunk = NULL;
Robert P. J. Day9dbc15f2008-04-12 18:54:24 -07001212 struct list_head *lchunk, *transport_list, *temp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001213 sctp_sack_variable_t *frags = sack->variable;
1214 __u32 sack_ctsn, ctsn, tsn;
1215 __u32 highest_tsn, highest_new_tsn;
1216 __u32 sack_a_rwnd;
Eric Dumazet95c96172012-04-15 05:58:06 +00001217 unsigned int outstanding;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001218 struct sctp_transport *primary = asoc->peer.primary_path;
1219 int count_of_newacks = 0;
Vlad Yasevich2cd9b822008-06-19 17:59:13 -04001220 int gap_ack_blocks;
Vlad Yasevichea862c82010-04-30 22:41:10 -04001221 u8 accum_moved = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001222
1223 /* Grab the association's destination address list. */
1224 transport_list = &asoc->peer.transport_addr_list;
1225
1226 sack_ctsn = ntohl(sack->cum_tsn_ack);
Vlad Yasevich2cd9b822008-06-19 17:59:13 -04001227 gap_ack_blocks = ntohs(sack->num_gap_ack_blocks);
Michele Baldessari196d6752012-12-01 04:49:42 +00001228 asoc->stats.gapcnt += gap_ack_blocks;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001229 /*
1230 * SFR-CACC algorithm:
1231 * On receipt of a SACK the sender SHOULD execute the
1232 * following statements.
1233 *
1234 * 1) If the cumulative ack in the SACK passes next tsn_at_change
1235 * on the current primary, the CHANGEOVER_ACTIVE flag SHOULD be
1236 * cleared. The CYCLING_CHANGEOVER flag SHOULD also be cleared for
1237 * all destinations.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001238 * 2) If the SACK contains gap acks and the flag CHANGEOVER_ACTIVE
1239 * is set the receiver of the SACK MUST take the following actions:
1240 *
1241 * A) Initialize the cacc_saw_newack to 0 for all destination
1242 * addresses.
Vlad Yasevichab5216a2008-06-19 18:17:24 -04001243 *
1244 * Only bother if changeover_active is set. Otherwise, this is
1245 * totally suboptimal to do on every SACK.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001246 */
Vlad Yasevichab5216a2008-06-19 18:17:24 -04001247 if (primary->cacc.changeover_active) {
1248 u8 clear_cycling = 0;
1249
1250 if (TSN_lte(primary->cacc.next_tsn_at_change, sack_ctsn)) {
1251 primary->cacc.changeover_active = 0;
1252 clear_cycling = 1;
1253 }
1254
1255 if (clear_cycling || gap_ack_blocks) {
1256 list_for_each_entry(transport, transport_list,
1257 transports) {
1258 if (clear_cycling)
1259 transport->cacc.cycling_changeover = 0;
1260 if (gap_ack_blocks)
1261 transport->cacc.cacc_saw_newack = 0;
1262 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001263 }
1264 }
1265
1266 /* Get the highest TSN in the sack. */
1267 highest_tsn = sack_ctsn;
Vlad Yasevich2cd9b822008-06-19 17:59:13 -04001268 if (gap_ack_blocks)
1269 highest_tsn += ntohs(frags[gap_ack_blocks - 1].gab.end);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001270
Vlad Yasevichbfa0d982010-04-30 22:41:10 -04001271 if (TSN_lt(asoc->highest_sacked, highest_tsn))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001272 asoc->highest_sacked = highest_tsn;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001273
Vlad Yasevichbfa0d982010-04-30 22:41:10 -04001274 highest_new_tsn = sack_ctsn;
Vlad Yasevich2cd9b822008-06-19 17:59:13 -04001275
Linus Torvalds1da177e2005-04-16 15:20:36 -07001276 /* Run through the retransmit queue. Credit bytes received
1277 * and free those chunks that we can.
1278 */
Nicolas Dichteledfee032012-10-03 05:43:22 +00001279 sctp_check_transmitted(q, &q->retransmit, NULL, NULL, sack, &highest_new_tsn);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001280
1281 /* Run through the transmitted queue.
1282 * Credit bytes received and free those chunks which we can.
1283 *
1284 * This is a MASSIVE candidate for optimization.
1285 */
Robert P. J. Day9dbc15f2008-04-12 18:54:24 -07001286 list_for_each_entry(transport, transport_list, transports) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001287 sctp_check_transmitted(q, &transport->transmitted,
Nicolas Dichteledfee032012-10-03 05:43:22 +00001288 transport, &chunk->source, sack,
1289 &highest_new_tsn);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001290 /*
1291 * SFR-CACC algorithm:
1292 * C) Let count_of_newacks be the number of
1293 * destinations for which cacc_saw_newack is set.
1294 */
1295 if (transport->cacc.cacc_saw_newack)
wangweidongcb3f8372013-12-23 12:16:50 +08001296 count_of_newacks++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001297 }
1298
Vlad Yasevichea862c82010-04-30 22:41:10 -04001299 /* Move the Cumulative TSN Ack Point if appropriate. */
1300 if (TSN_lt(asoc->ctsn_ack_point, sack_ctsn)) {
1301 asoc->ctsn_ack_point = sack_ctsn;
1302 accum_moved = 1;
1303 }
1304
Vlad Yasevich2cd9b822008-06-19 17:59:13 -04001305 if (gap_ack_blocks) {
Vlad Yasevichea862c82010-04-30 22:41:10 -04001306
1307 if (asoc->fast_recovery && accum_moved)
1308 highest_new_tsn = highest_tsn;
1309
Vlad Yasevich2cd9b822008-06-19 17:59:13 -04001310 list_for_each_entry(transport, transport_list, transports)
1311 sctp_mark_missing(q, &transport->transmitted, transport,
1312 highest_new_tsn, count_of_newacks);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001313 }
1314
Linus Torvalds1da177e2005-04-16 15:20:36 -07001315 /* Update unack_data field in the assoc. */
1316 sctp_sack_update_unack_data(asoc, sack);
1317
1318 ctsn = asoc->ctsn_ack_point;
1319
1320 /* Throw away stuff rotting on the sack queue. */
1321 list_for_each_safe(lchunk, temp, &q->sacked) {
1322 tchunk = list_entry(lchunk, struct sctp_chunk,
1323 transmitted_list);
1324 tsn = ntohl(tchunk->subh.data_hdr->tsn);
Vlad Yasevich5f9646c2008-02-05 14:23:44 -05001325 if (TSN_lte(tsn, ctsn)) {
1326 list_del_init(&tchunk->transmitted_list);
Xin Long8dbdf1f2016-07-09 19:47:45 +08001327 if (asoc->prsctp_enable &&
1328 SCTP_PR_PRIO_ENABLED(chunk->sinfo.sinfo_flags))
1329 asoc->sent_cnt_removable--;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001330 sctp_chunk_free(tchunk);
Vlad Yasevich5f9646c2008-02-05 14:23:44 -05001331 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001332 }
1333
1334 /* ii) Set rwnd equal to the newly received a_rwnd minus the
1335 * number of bytes still outstanding after processing the
1336 * Cumulative TSN Ack and the Gap Ack Blocks.
1337 */
1338
1339 sack_a_rwnd = ntohl(sack->a_rwnd);
lucien8a0d19c2015-12-05 15:35:36 +08001340 asoc->peer.zero_window_announced = !sack_a_rwnd;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001341 outstanding = q->outstanding_bytes;
1342
1343 if (outstanding < sack_a_rwnd)
1344 sack_a_rwnd -= outstanding;
1345 else
1346 sack_a_rwnd = 0;
1347
1348 asoc->peer.rwnd = sack_a_rwnd;
1349
1350 sctp_generate_fwdtsn(q, sack_ctsn);
1351
Daniel Borkmannbb333812013-06-28 19:49:40 +02001352 pr_debug("%s: sack cumulative tsn ack:0x%x\n", __func__, sack_ctsn);
1353 pr_debug("%s: cumulative tsn ack of assoc:%p is 0x%x, "
1354 "advertised peer ack point:0x%x\n", __func__, asoc, ctsn,
1355 asoc->adv_peer_ack_point);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001356
Vlad Yasevich619a60e2014-01-02 14:39:44 -05001357 return sctp_outq_is_empty(q);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001358}
1359
Vlad Yasevich619a60e2014-01-02 14:39:44 -05001360/* Is the outqueue empty?
1361 * The queue is empty when we have not pending data, no in-flight data
1362 * and nothing pending retransmissions.
1363 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001364int sctp_outq_is_empty(const struct sctp_outq *q)
1365{
Vlad Yasevich619a60e2014-01-02 14:39:44 -05001366 return q->out_qlen == 0 && q->outstanding_bytes == 0 &&
1367 list_empty(&q->retransmit);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001368}
1369
1370/********************************************************************
1371 * 2nd Level Abstractions
1372 ********************************************************************/
1373
1374/* Go through a transport's transmitted list or the association's retransmit
1375 * list and move chunks that are acked by the Cumulative TSN Ack to q->sacked.
1376 * The retransmit list will not have an associated transport.
1377 *
1378 * I added coherent debug information output. --xguo
1379 *
1380 * Instead of printing 'sacked' or 'kept' for each TSN on the
1381 * transmitted_queue, we print a range: SACKED: TSN1-TSN2, TSN3, TSN4-TSN5.
1382 * KEPT TSN6-TSN7, etc.
1383 */
1384static void sctp_check_transmitted(struct sctp_outq *q,
1385 struct list_head *transmitted_queue,
1386 struct sctp_transport *transport,
Nicolas Dichteledfee032012-10-03 05:43:22 +00001387 union sctp_addr *saddr,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001388 struct sctp_sackhdr *sack,
Vlad Yasevichbfa0d982010-04-30 22:41:10 -04001389 __u32 *highest_new_tsn_in_sack)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001390{
1391 struct list_head *lchunk;
1392 struct sctp_chunk *tchunk;
1393 struct list_head tlist;
1394 __u32 tsn;
1395 __u32 sack_ctsn;
1396 __u32 rtt;
1397 __u8 restart_timer = 0;
1398 int bytes_acked = 0;
Vlad Yasevich31b02e12009-09-04 18:21:00 -04001399 int migrate_bytes = 0;
Daniel Borkmann8c2f4142013-07-09 16:17:04 +02001400 bool forward_progress = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001401
Linus Torvalds1da177e2005-04-16 15:20:36 -07001402 sack_ctsn = ntohl(sack->cum_tsn_ack);
1403
1404 INIT_LIST_HEAD(&tlist);
1405
1406 /* The while loop will skip empty transmitted queues. */
1407 while (NULL != (lchunk = sctp_list_dequeue(transmitted_queue))) {
1408 tchunk = list_entry(lchunk, struct sctp_chunk,
1409 transmitted_list);
1410
1411 if (sctp_chunk_abandoned(tchunk)) {
1412 /* Move the chunk to abandoned list. */
1413 sctp_insert_list(&q->abandoned, lchunk);
Vlad Yasevich8c4a2d42007-02-21 02:06:04 -08001414
1415 /* If this chunk has not been acked, stop
1416 * considering it as 'outstanding'.
1417 */
1418 if (!tchunk->tsn_gap_acked) {
Vlad Yasevich31b02e12009-09-04 18:21:00 -04001419 if (tchunk->transport)
1420 tchunk->transport->flight_size -=
1421 sctp_data_size(tchunk);
Vlad Yasevich8c4a2d42007-02-21 02:06:04 -08001422 q->outstanding_bytes -= sctp_data_size(tchunk);
1423 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001424 continue;
1425 }
1426
1427 tsn = ntohl(tchunk->subh.data_hdr->tsn);
1428 if (sctp_acked(sack, tsn)) {
1429 /* If this queue is the retransmit queue, the
1430 * retransmit timer has already reclaimed
1431 * the outstanding bytes for this chunk, so only
1432 * count bytes associated with a transport.
1433 */
1434 if (transport) {
1435 /* If this chunk is being used for RTT
1436 * measurement, calculate the RTT and update
1437 * the RTO using this value.
1438 *
1439 * 6.3.1 C5) Karn's algorithm: RTT measurements
1440 * MUST NOT be made using packets that were
1441 * retransmitted (and thus for which it is
1442 * ambiguous whether the reply was for the
1443 * first instance of the packet or a later
1444 * instance).
1445 */
YOSHIFUJI Hideakid808ad92007-02-09 23:25:18 +09001446 if (!tchunk->tsn_gap_acked &&
Xufeng Zhang6eabca52013-11-25 11:26:57 +08001447 !tchunk->resent &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001448 tchunk->rtt_in_progress) {
Vlad Yasevich4c9f5d52006-06-17 22:56:08 -07001449 tchunk->rtt_in_progress = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001450 rtt = jiffies - tchunk->sent_at;
1451 sctp_transport_update_rto(transport,
1452 rtt);
1453 }
1454 }
Vlad Yasevich31b02e12009-09-04 18:21:00 -04001455
1456 /* If the chunk hasn't been marked as ACKED,
1457 * mark it and account bytes_acked if the
1458 * chunk had a valid transport (it will not
1459 * have a transport if ASCONF had deleted it
1460 * while DATA was outstanding).
1461 */
1462 if (!tchunk->tsn_gap_acked) {
1463 tchunk->tsn_gap_acked = 1;
Chang Xiangzhongd6c41612013-11-21 22:56:28 +01001464 if (TSN_lt(*highest_new_tsn_in_sack, tsn))
1465 *highest_new_tsn_in_sack = tsn;
Vlad Yasevich31b02e12009-09-04 18:21:00 -04001466 bytes_acked += sctp_data_size(tchunk);
1467 if (!tchunk->transport)
1468 migrate_bytes += sctp_data_size(tchunk);
Daniel Borkmann8c2f4142013-07-09 16:17:04 +02001469 forward_progress = true;
Vlad Yasevich31b02e12009-09-04 18:21:00 -04001470 }
1471
YOSHIFUJI Hideakid808ad92007-02-09 23:25:18 +09001472 if (TSN_lte(tsn, sack_ctsn)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001473 /* RFC 2960 6.3.2 Retransmission Timer Rules
1474 *
1475 * R3) Whenever a SACK is received
1476 * that acknowledges the DATA chunk
1477 * with the earliest outstanding TSN
1478 * for that address, restart T3-rtx
1479 * timer for that address with its
1480 * current RTO.
1481 */
1482 restart_timer = 1;
Daniel Borkmann8c2f4142013-07-09 16:17:04 +02001483 forward_progress = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001484
1485 if (!tchunk->tsn_gap_acked) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001486 /*
1487 * SFR-CACC algorithm:
1488 * 2) If the SACK contains gap acks
1489 * and the flag CHANGEOVER_ACTIVE is
1490 * set the receiver of the SACK MUST
1491 * take the following action:
1492 *
1493 * B) For each TSN t being acked that
1494 * has not been acked in any SACK so
1495 * far, set cacc_saw_newack to 1 for
1496 * the destination that the TSN was
1497 * sent to.
1498 */
1499 if (transport &&
1500 sack->num_gap_ack_blocks &&
1501 q->asoc->peer.primary_path->cacc.
1502 changeover_active)
1503 transport->cacc.cacc_saw_newack
1504 = 1;
1505 }
1506
1507 list_add_tail(&tchunk->transmitted_list,
1508 &q->sacked);
1509 } else {
1510 /* RFC2960 7.2.4, sctpimpguide-05 2.8.2
1511 * M2) Each time a SACK arrives reporting
1512 * 'Stray DATA chunk(s)' record the highest TSN
1513 * reported as newly acknowledged, call this
1514 * value 'HighestTSNinSack'. A newly
1515 * acknowledged DATA chunk is one not
1516 * previously acknowledged in a SACK.
1517 *
1518 * When the SCTP sender of data receives a SACK
1519 * chunk that acknowledges, for the first time,
1520 * the receipt of a DATA chunk, all the still
1521 * unacknowledged DATA chunks whose TSN is
1522 * older than that newly acknowledged DATA
1523 * chunk, are qualified as 'Stray DATA chunks'.
1524 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001525 list_add_tail(lchunk, &tlist);
1526 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001527 } else {
1528 if (tchunk->tsn_gap_acked) {
Daniel Borkmannbb333812013-06-28 19:49:40 +02001529 pr_debug("%s: receiver reneged on data TSN:0x%x\n",
1530 __func__, tsn);
1531
Linus Torvalds1da177e2005-04-16 15:20:36 -07001532 tchunk->tsn_gap_acked = 0;
1533
Vlad Yasevich31b02e12009-09-04 18:21:00 -04001534 if (tchunk->transport)
1535 bytes_acked -= sctp_data_size(tchunk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001536
1537 /* RFC 2960 6.3.2 Retransmission Timer Rules
1538 *
1539 * R4) Whenever a SACK is received missing a
1540 * TSN that was previously acknowledged via a
1541 * Gap Ack Block, start T3-rtx for the
1542 * destination address to which the DATA
1543 * chunk was originally
1544 * transmitted if it is not already running.
1545 */
1546 restart_timer = 1;
1547 }
1548
1549 list_add_tail(lchunk, &tlist);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001550 }
1551 }
1552
Linus Torvalds1da177e2005-04-16 15:20:36 -07001553 if (transport) {
1554 if (bytes_acked) {
Thomas Graff8d96052011-07-07 00:28:35 +00001555 struct sctp_association *asoc = transport->asoc;
1556
Vlad Yasevich31b02e12009-09-04 18:21:00 -04001557 /* We may have counted DATA that was migrated
1558 * to this transport due to DEL-IP operation.
1559 * Subtract those bytes, since the were never
1560 * send on this transport and shouldn't be
1561 * credited to this transport.
1562 */
1563 bytes_acked -= migrate_bytes;
1564
Linus Torvalds1da177e2005-04-16 15:20:36 -07001565 /* 8.2. When an outstanding TSN is acknowledged,
1566 * the endpoint shall clear the error counter of
1567 * the destination transport address to which the
1568 * DATA chunk was last sent.
1569 * The association's overall error counter is
1570 * also cleared.
1571 */
1572 transport->error_count = 0;
1573 transport->asoc->overall_error_count = 0;
Daniel Borkmann8c2f4142013-07-09 16:17:04 +02001574 forward_progress = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001575
Thomas Graff8d96052011-07-07 00:28:35 +00001576 /*
1577 * While in SHUTDOWN PENDING, we may have started
1578 * the T5 shutdown guard timer after reaching the
1579 * retransmission limit. Stop that timer as soon
1580 * as the receiver acknowledged any data.
1581 */
1582 if (asoc->state == SCTP_STATE_SHUTDOWN_PENDING &&
1583 del_timer(&asoc->timers
1584 [SCTP_EVENT_TIMEOUT_T5_SHUTDOWN_GUARD]))
1585 sctp_association_put(asoc);
1586
Linus Torvalds1da177e2005-04-16 15:20:36 -07001587 /* Mark the destination transport address as
1588 * active if it is not so marked.
1589 */
Nicolas Dichteledfee032012-10-03 05:43:22 +00001590 if ((transport->state == SCTP_INACTIVE ||
1591 transport->state == SCTP_UNCONFIRMED) &&
1592 sctp_cmp_addr_exact(&transport->ipaddr, saddr)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001593 sctp_assoc_control_transport(
1594 transport->asoc,
1595 transport,
1596 SCTP_TRANSPORT_UP,
1597 SCTP_RECEIVED_SACK);
1598 }
1599
1600 sctp_transport_raise_cwnd(transport, sack_ctsn,
1601 bytes_acked);
1602
1603 transport->flight_size -= bytes_acked;
Gui Jianfeng8b73a072008-04-17 14:22:18 -07001604 if (transport->flight_size == 0)
1605 transport->partial_bytes_acked = 0;
Vlad Yasevich31b02e12009-09-04 18:21:00 -04001606 q->outstanding_bytes -= bytes_acked + migrate_bytes;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001607 } else {
1608 /* RFC 2960 6.1, sctpimpguide-06 2.15.2
1609 * When a sender is doing zero window probing, it
1610 * should not timeout the association if it continues
1611 * to receive new packets from the receiver. The
1612 * reason is that the receiver MAY keep its window
1613 * closed for an indefinite time.
1614 * A sender is doing zero window probing when the
1615 * receiver's advertised window is zero, and there is
1616 * only one data chunk in flight to the receiver.
Thomas Graff8d96052011-07-07 00:28:35 +00001617 *
1618 * Allow the association to timeout while in SHUTDOWN
1619 * PENDING or SHUTDOWN RECEIVED in case the receiver
1620 * stays in zero window mode forever.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001621 */
1622 if (!q->asoc->peer.rwnd &&
1623 !list_empty(&tlist) &&
Thomas Graff8d96052011-07-07 00:28:35 +00001624 (sack_ctsn+2 == q->asoc->next_tsn) &&
1625 q->asoc->state < SCTP_STATE_SHUTDOWN_PENDING) {
Daniel Borkmannbb333812013-06-28 19:49:40 +02001626 pr_debug("%s: sack received for zero window "
1627 "probe:%u\n", __func__, sack_ctsn);
1628
Linus Torvalds1da177e2005-04-16 15:20:36 -07001629 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) {
Ying Xue25cc4ae2013-02-03 20:32:57 +00001641 if (del_timer(&transport->T3_rtx_timer))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001642 sctp_transport_put(transport);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001643 } else if (restart_timer) {
1644 if (!mod_timer(&transport->T3_rtx_timer,
1645 jiffies + transport->rto))
1646 sctp_transport_hold(transport);
1647 }
Daniel Borkmann8c2f4142013-07-09 16:17:04 +02001648
1649 if (forward_progress) {
1650 if (transport->dst)
1651 dst_confirm(transport->dst);
1652 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001653 }
1654
1655 list_splice(&tlist, transmitted_queue);
1656}
1657
1658/* Mark chunks as missing and consequently may get retransmitted. */
1659static void sctp_mark_missing(struct sctp_outq *q,
1660 struct list_head *transmitted_queue,
1661 struct sctp_transport *transport,
1662 __u32 highest_new_tsn_in_sack,
1663 int count_of_newacks)
1664{
1665 struct sctp_chunk *chunk;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001666 __u32 tsn;
1667 char do_fast_retransmit = 0;
Vlad Yasevichea862c82010-04-30 22:41:10 -04001668 struct sctp_association *asoc = q->asoc;
1669 struct sctp_transport *primary = asoc->peer.primary_path;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001670
Robert P. J. Day9dbc15f2008-04-12 18:54:24 -07001671 list_for_each_entry(chunk, transmitted_queue, transmitted_list) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001672
Linus Torvalds1da177e2005-04-16 15:20:36 -07001673 tsn = ntohl(chunk->subh.data_hdr->tsn);
1674
1675 /* RFC 2960 7.2.4, sctpimpguide-05 2.8.2 M3) Examine all
1676 * 'Unacknowledged TSN's', if the TSN number of an
1677 * 'Unacknowledged TSN' is smaller than the 'HighestTSNinSack'
1678 * value, increment the 'TSN.Missing.Report' count on that
1679 * chunk if it has NOT been fast retransmitted or marked for
1680 * fast retransmit already.
1681 */
Neil Hormanc226ef92008-07-25 12:44:09 -04001682 if (chunk->fast_retransmit == SCTP_CAN_FRTX &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001683 !chunk->tsn_gap_acked &&
1684 TSN_lt(tsn, highest_new_tsn_in_sack)) {
1685
1686 /* SFR-CACC may require us to skip marking
1687 * this chunk as missing.
1688 */
Vlad Yasevichf246a7b2011-04-18 19:13:56 +00001689 if (!transport || !sctp_cacc_skip(primary,
1690 chunk->transport,
1691 count_of_newacks, tsn)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001692 chunk->tsn_missing_report++;
1693
Daniel Borkmannbb333812013-06-28 19:49:40 +02001694 pr_debug("%s: tsn:0x%x missing counter:%d\n",
1695 __func__, tsn, chunk->tsn_missing_report);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001696 }
1697 }
1698 /*
1699 * M4) If any DATA chunk is found to have a
1700 * 'TSN.Missing.Report'
Vlad Yasevich27852c22006-02-02 16:57:31 -08001701 * value larger than or equal to 3, mark that chunk for
Linus Torvalds1da177e2005-04-16 15:20:36 -07001702 * retransmission and start the fast retransmit procedure.
1703 */
1704
Vlad Yasevich27852c22006-02-02 16:57:31 -08001705 if (chunk->tsn_missing_report >= 3) {
Neil Hormanc226ef92008-07-25 12:44:09 -04001706 chunk->fast_retransmit = SCTP_NEED_FRTX;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001707 do_fast_retransmit = 1;
1708 }
1709 }
1710
1711 if (transport) {
1712 if (do_fast_retransmit)
1713 sctp_retransmit(q, transport, SCTP_RTXR_FAST_RTX);
1714
Daniel Borkmannbb333812013-06-28 19:49:40 +02001715 pr_debug("%s: transport:%p, cwnd:%d, ssthresh:%d, "
1716 "flight_size:%d, pba:%d\n", __func__, transport,
1717 transport->cwnd, transport->ssthresh,
1718 transport->flight_size, transport->partial_bytes_acked);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001719 }
1720}
1721
1722/* Is the given TSN acked by this packet? */
1723static int sctp_acked(struct sctp_sackhdr *sack, __u32 tsn)
1724{
1725 int i;
1726 sctp_sack_variable_t *frags;
1727 __u16 gap;
1728 __u32 ctsn = ntohl(sack->cum_tsn_ack);
1729
YOSHIFUJI Hideakid808ad92007-02-09 23:25:18 +09001730 if (TSN_lte(tsn, ctsn))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001731 goto pass;
1732
1733 /* 3.3.4 Selective Acknowledgement (SACK) (3):
1734 *
1735 * Gap Ack Blocks:
1736 * These fields contain the Gap Ack Blocks. They are repeated
1737 * for each Gap Ack Block up to the number of Gap Ack Blocks
1738 * defined in the Number of Gap Ack Blocks field. All DATA
1739 * chunks with TSNs greater than or equal to (Cumulative TSN
1740 * Ack + Gap Ack Block Start) and less than or equal to
1741 * (Cumulative TSN Ack + Gap Ack Block End) of each Gap Ack
1742 * Block are assumed to have been received correctly.
1743 */
1744
1745 frags = sack->variable;
1746 gap = tsn - ctsn;
1747 for (i = 0; i < ntohs(sack->num_gap_ack_blocks); ++i) {
1748 if (TSN_lte(ntohs(frags[i].gab.start), gap) &&
1749 TSN_lte(gap, ntohs(frags[i].gab.end)))
1750 goto pass;
1751 }
1752
1753 return 0;
1754pass:
1755 return 1;
1756}
1757
1758static inline int sctp_get_skip_pos(struct sctp_fwdtsn_skip *skiplist,
Al Viro9f81bcd2006-11-20 17:26:34 -08001759 int nskips, __be16 stream)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001760{
1761 int i;
1762
1763 for (i = 0; i < nskips; i++) {
1764 if (skiplist[i].stream == stream)
1765 return i;
1766 }
1767 return i;
1768}
1769
1770/* Create and add a fwdtsn chunk to the outq's control queue if needed. */
1771static void sctp_generate_fwdtsn(struct sctp_outq *q, __u32 ctsn)
1772{
1773 struct sctp_association *asoc = q->asoc;
1774 struct sctp_chunk *ftsn_chunk = NULL;
1775 struct sctp_fwdtsn_skip ftsn_skip_arr[10];
1776 int nskips = 0;
1777 int skip_pos = 0;
1778 __u32 tsn;
1779 struct sctp_chunk *chunk;
1780 struct list_head *lchunk, *temp;
1781
Wei Yongjun76595022009-03-12 09:49:19 +00001782 if (!asoc->peer.prsctp_capable)
1783 return;
1784
Linus Torvalds1da177e2005-04-16 15:20:36 -07001785 /* PR-SCTP C1) Let SackCumAck be the Cumulative TSN ACK carried in the
1786 * received SACK.
YOSHIFUJI Hideakid808ad92007-02-09 23:25:18 +09001787 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07001788 * If (Advanced.Peer.Ack.Point < SackCumAck), then update
1789 * Advanced.Peer.Ack.Point to be equal to SackCumAck.
1790 */
1791 if (TSN_lt(asoc->adv_peer_ack_point, ctsn))
1792 asoc->adv_peer_ack_point = ctsn;
1793
1794 /* PR-SCTP C2) Try to further advance the "Advanced.Peer.Ack.Point"
1795 * locally, that is, to move "Advanced.Peer.Ack.Point" up as long as
1796 * the chunk next in the out-queue space is marked as "abandoned" as
1797 * shown in the following example:
1798 *
1799 * Assuming that a SACK arrived with the Cumulative TSN ACK 102
1800 * and the Advanced.Peer.Ack.Point is updated to this value:
YOSHIFUJI Hideakid808ad92007-02-09 23:25:18 +09001801 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07001802 * out-queue at the end of ==> out-queue after Adv.Ack.Point
1803 * normal SACK processing local advancement
1804 * ... ...
1805 * Adv.Ack.Pt-> 102 acked 102 acked
1806 * 103 abandoned 103 abandoned
1807 * 104 abandoned Adv.Ack.P-> 104 abandoned
1808 * 105 105
1809 * 106 acked 106 acked
1810 * ... ...
1811 *
1812 * In this example, the data sender successfully advanced the
1813 * "Advanced.Peer.Ack.Point" from 102 to 104 locally.
1814 */
1815 list_for_each_safe(lchunk, temp, &q->abandoned) {
1816 chunk = list_entry(lchunk, struct sctp_chunk,
1817 transmitted_list);
1818 tsn = ntohl(chunk->subh.data_hdr->tsn);
1819
1820 /* Remove any chunks in the abandoned queue that are acked by
1821 * the ctsn.
YOSHIFUJI Hideakid808ad92007-02-09 23:25:18 +09001822 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001823 if (TSN_lte(tsn, ctsn)) {
1824 list_del_init(lchunk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001825 sctp_chunk_free(chunk);
1826 } else {
1827 if (TSN_lte(tsn, asoc->adv_peer_ack_point+1)) {
1828 asoc->adv_peer_ack_point = tsn;
1829 if (chunk->chunk_hdr->flags &
1830 SCTP_DATA_UNORDERED)
1831 continue;
1832 skip_pos = sctp_get_skip_pos(&ftsn_skip_arr[0],
1833 nskips,
1834 chunk->subh.data_hdr->stream);
1835 ftsn_skip_arr[skip_pos].stream =
1836 chunk->subh.data_hdr->stream;
1837 ftsn_skip_arr[skip_pos].ssn =
1838 chunk->subh.data_hdr->ssn;
1839 if (skip_pos == nskips)
1840 nskips++;
1841 if (nskips == 10)
1842 break;
1843 } else
1844 break;
1845 }
1846 }
1847
1848 /* PR-SCTP C3) If, after step C1 and C2, the "Advanced.Peer.Ack.Point"
1849 * is greater than the Cumulative TSN ACK carried in the received
1850 * SACK, the data sender MUST send the data receiver a FORWARD TSN
1851 * chunk containing the latest value of the
1852 * "Advanced.Peer.Ack.Point".
1853 *
1854 * C4) For each "abandoned" TSN the sender of the FORWARD TSN SHOULD
1855 * list each stream and sequence number in the forwarded TSN. This
1856 * information will enable the receiver to easily find any
1857 * stranded TSN's waiting on stream reorder queues. Each stream
1858 * SHOULD only be reported once; this means that if multiple
1859 * abandoned messages occur in the same stream then only the
1860 * highest abandoned stream sequence number is reported. If the
1861 * total size of the FORWARD TSN does NOT fit in a single MTU then
1862 * the sender of the FORWARD TSN SHOULD lower the
1863 * Advanced.Peer.Ack.Point to the last TSN that will fit in a
1864 * single MTU.
1865 */
1866 if (asoc->adv_peer_ack_point > ctsn)
1867 ftsn_chunk = sctp_make_fwdtsn(asoc, asoc->adv_peer_ack_point,
YOSHIFUJI Hideakid808ad92007-02-09 23:25:18 +09001868 nskips, &ftsn_skip_arr[0]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001869
1870 if (ftsn_chunk) {
David S. Miller79af02c2005-07-08 21:47:49 -07001871 list_add_tail(&ftsn_chunk->list, &q->control_chunk_list);
Eric W. Biedermanb01a2402012-08-06 08:47:55 +00001872 SCTP_INC_STATS(sock_net(asoc->base.sk), SCTP_MIB_OUTCTRLCHUNKS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001873 }
1874}