blob: 59268f6e2c36a0b32ac6b768dea15b7b6be0021d [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
25 * along with GNU CC; see the file COPYING. If not, write to
26 * the Free Software Foundation, 59 Temple Place - Suite 330,
27 * Boston, MA 02111-1307, USA.
28 *
29 * Please send any bug reports or fixes you make to the
30 * email address(es):
Daniel Borkmann91705c62013-07-23 14:51:47 +020031 * lksctp developers <linux-sctp@vger.kernel.org>
Linus Torvalds1da177e2005-04-16 15:20:36 -070032 *
Linus Torvalds1da177e2005-04-16 15:20:36 -070033 * Written or modified by:
34 * La Monte H.P. Yarroll <piggy@acm.org>
35 * Karl Knutson <karl@athena.chicago.il.us>
36 * Perry Melange <pmelange@null.cc.uic.edu>
37 * Xingang Guo <xingang.guo@intel.com>
38 * Hui Huang <hui.huang@nokia.com>
39 * Sridhar Samudrala <sri@us.ibm.com>
40 * Jon Grimm <jgrimm@us.ibm.com>
Linus Torvalds1da177e2005-04-16 15:20:36 -070041 */
42
Joe Perches145ce502010-08-24 13:21:08 +000043#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
44
Linus Torvalds1da177e2005-04-16 15:20:36 -070045#include <linux/types.h>
46#include <linux/list.h> /* For struct list_head */
47#include <linux/socket.h>
48#include <linux/ip.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090049#include <linux/slab.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070050#include <net/sock.h> /* For skb_set_owner_w */
51
52#include <net/sctp/sctp.h>
53#include <net/sctp/sm.h>
54
55/* Declare internal functions here. */
56static int sctp_acked(struct sctp_sackhdr *sack, __u32 tsn);
57static void sctp_check_transmitted(struct sctp_outq *q,
58 struct list_head *transmitted_queue,
59 struct sctp_transport *transport,
Nicolas Dichteledfee032012-10-03 05:43:22 +000060 union sctp_addr *saddr,
Linus Torvalds1da177e2005-04-16 15:20:36 -070061 struct sctp_sackhdr *sack,
Vlad Yasevichbfa0d982010-04-30 22:41:10 -040062 __u32 *highest_new_tsn);
Linus Torvalds1da177e2005-04-16 15:20:36 -070063
64static void sctp_mark_missing(struct sctp_outq *q,
65 struct list_head *transmitted_queue,
66 struct sctp_transport *transport,
67 __u32 highest_new_tsn,
68 int count_of_newacks);
69
70static void sctp_generate_fwdtsn(struct sctp_outq *q, __u32 sack_ctsn);
71
Adrian Bunkabd0b1982008-07-22 14:20:45 -070072static int sctp_outq_flush(struct sctp_outq *q, int rtx_timeout);
73
Linus Torvalds1da177e2005-04-16 15:20:36 -070074/* Add data to the front of the queue. */
75static inline void sctp_outq_head_data(struct sctp_outq *q,
76 struct sctp_chunk *ch)
77{
David S. Miller79af02c2005-07-08 21:47:49 -070078 list_add(&ch->list, &q->out_chunk_list);
Linus Torvalds1da177e2005-04-16 15:20:36 -070079 q->out_qlen += ch->skb->len;
Linus Torvalds1da177e2005-04-16 15:20:36 -070080}
81
82/* Take data from the front of the queue. */
83static inline struct sctp_chunk *sctp_outq_dequeue_data(struct sctp_outq *q)
84{
David S. Miller79af02c2005-07-08 21:47:49 -070085 struct sctp_chunk *ch = NULL;
86
87 if (!list_empty(&q->out_chunk_list)) {
88 struct list_head *entry = q->out_chunk_list.next;
89
90 ch = list_entry(entry, struct sctp_chunk, list);
91 list_del_init(entry);
Linus Torvalds1da177e2005-04-16 15:20:36 -070092 q->out_qlen -= ch->skb->len;
David S. Miller79af02c2005-07-08 21:47:49 -070093 }
Linus Torvalds1da177e2005-04-16 15:20:36 -070094 return ch;
95}
96/* Add data chunk to the end of the queue. */
97static inline void sctp_outq_tail_data(struct sctp_outq *q,
98 struct sctp_chunk *ch)
99{
David S. Miller79af02c2005-07-08 21:47:49 -0700100 list_add_tail(&ch->list, &q->out_chunk_list);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700101 q->out_qlen += ch->skb->len;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700102}
103
104/*
105 * SFR-CACC algorithm:
106 * D) If count_of_newacks is greater than or equal to 2
107 * and t was not sent to the current primary then the
108 * sender MUST NOT increment missing report count for t.
109 */
110static inline int sctp_cacc_skip_3_1_d(struct sctp_transport *primary,
111 struct sctp_transport *transport,
112 int count_of_newacks)
113{
114 if (count_of_newacks >=2 && transport != primary)
115 return 1;
116 return 0;
117}
118
119/*
120 * SFR-CACC algorithm:
121 * F) If count_of_newacks is less than 2, let d be the
122 * destination to which t was sent. If cacc_saw_newack
123 * is 0 for destination d, then the sender MUST NOT
124 * increment missing report count for t.
125 */
126static inline int sctp_cacc_skip_3_1_f(struct sctp_transport *transport,
127 int count_of_newacks)
128{
Vlad Yasevichf246a7b2011-04-18 19:13:56 +0000129 if (count_of_newacks < 2 &&
130 (transport && !transport->cacc.cacc_saw_newack))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700131 return 1;
132 return 0;
133}
134
135/*
136 * SFR-CACC algorithm:
137 * 3.1) If CYCLING_CHANGEOVER is 0, the sender SHOULD
138 * execute steps C, D, F.
139 *
140 * C has been implemented in sctp_outq_sack
141 */
142static inline int sctp_cacc_skip_3_1(struct sctp_transport *primary,
143 struct sctp_transport *transport,
144 int count_of_newacks)
145{
146 if (!primary->cacc.cycling_changeover) {
147 if (sctp_cacc_skip_3_1_d(primary, transport, count_of_newacks))
148 return 1;
149 if (sctp_cacc_skip_3_1_f(transport, count_of_newacks))
150 return 1;
151 return 0;
152 }
153 return 0;
154}
155
156/*
157 * SFR-CACC algorithm:
158 * 3.2) Else if CYCLING_CHANGEOVER is 1, and t is less
159 * than next_tsn_at_change of the current primary, then
160 * the sender MUST NOT increment missing report count
161 * for t.
162 */
163static inline int sctp_cacc_skip_3_2(struct sctp_transport *primary, __u32 tsn)
164{
165 if (primary->cacc.cycling_changeover &&
166 TSN_lt(tsn, primary->cacc.next_tsn_at_change))
167 return 1;
168 return 0;
169}
170
171/*
172 * SFR-CACC algorithm:
173 * 3) If the missing report count for TSN t is to be
174 * incremented according to [RFC2960] and
175 * [SCTP_STEWART-2002], and CHANGEOVER_ACTIVE is set,
Lucas De Marchi25985ed2011-03-30 22:57:33 -0300176 * then the sender MUST further execute steps 3.1 and
Linus Torvalds1da177e2005-04-16 15:20:36 -0700177 * 3.2 to determine if the missing report count for
178 * TSN t SHOULD NOT be incremented.
179 *
180 * 3.3) If 3.1 and 3.2 do not dictate that the missing
181 * report count for t should not be incremented, then
Lucas De Marchi25985ed2011-03-30 22:57:33 -0300182 * the sender SHOULD increment missing report count for
Linus Torvalds1da177e2005-04-16 15:20:36 -0700183 * t (according to [RFC2960] and [SCTP_STEWART_2002]).
184 */
185static inline int sctp_cacc_skip(struct sctp_transport *primary,
186 struct sctp_transport *transport,
187 int count_of_newacks,
188 __u32 tsn)
189{
190 if (primary->cacc.changeover_active &&
Joe Perchesf64f9e72009-11-29 16:55:45 -0800191 (sctp_cacc_skip_3_1(primary, transport, count_of_newacks) ||
192 sctp_cacc_skip_3_2(primary, tsn)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700193 return 1;
194 return 0;
195}
196
197/* Initialize an existing sctp_outq. This does the boring stuff.
198 * You still need to define handlers if you really want to DO
199 * something with this structure...
200 */
201void sctp_outq_init(struct sctp_association *asoc, struct sctp_outq *q)
202{
Neil Hormanc5c77742013-06-12 14:26:44 -0400203 memset(q, 0, sizeof(struct sctp_outq));
204
Linus Torvalds1da177e2005-04-16 15:20:36 -0700205 q->asoc = asoc;
David S. Miller79af02c2005-07-08 21:47:49 -0700206 INIT_LIST_HEAD(&q->out_chunk_list);
207 INIT_LIST_HEAD(&q->control_chunk_list);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700208 INIT_LIST_HEAD(&q->retransmit);
209 INIT_LIST_HEAD(&q->sacked);
210 INIT_LIST_HEAD(&q->abandoned);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700211}
212
213/* Free the outqueue structure and any related pending chunks.
214 */
Neil Horman2f94aab2013-01-17 11:15:08 +0000215static void __sctp_outq_teardown(struct sctp_outq *q)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700216{
217 struct sctp_transport *transport;
Robert P. J. Day9dbc15f2008-04-12 18:54:24 -0700218 struct list_head *lchunk, *temp;
David S. Miller79af02c2005-07-08 21:47:49 -0700219 struct sctp_chunk *chunk, *tmp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700220
221 /* Throw away unacknowledged chunks. */
Robert P. J. Day9dbc15f2008-04-12 18:54:24 -0700222 list_for_each_entry(transport, &q->asoc->peer.transport_addr_list,
223 transports) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700224 while ((lchunk = sctp_list_dequeue(&transport->transmitted)) != NULL) {
225 chunk = list_entry(lchunk, struct sctp_chunk,
226 transmitted_list);
227 /* Mark as part of a failed message. */
228 sctp_chunk_fail(chunk, q->error);
229 sctp_chunk_free(chunk);
230 }
231 }
232
233 /* Throw away chunks that have been gap ACKed. */
234 list_for_each_safe(lchunk, temp, &q->sacked) {
235 list_del_init(lchunk);
236 chunk = list_entry(lchunk, struct sctp_chunk,
237 transmitted_list);
238 sctp_chunk_fail(chunk, q->error);
239 sctp_chunk_free(chunk);
240 }
241
242 /* Throw away any chunks in the retransmit queue. */
243 list_for_each_safe(lchunk, temp, &q->retransmit) {
244 list_del_init(lchunk);
245 chunk = list_entry(lchunk, struct sctp_chunk,
246 transmitted_list);
247 sctp_chunk_fail(chunk, q->error);
248 sctp_chunk_free(chunk);
249 }
250
251 /* Throw away any chunks that are in the abandoned queue. */
252 list_for_each_safe(lchunk, temp, &q->abandoned) {
253 list_del_init(lchunk);
254 chunk = list_entry(lchunk, struct sctp_chunk,
255 transmitted_list);
256 sctp_chunk_fail(chunk, q->error);
257 sctp_chunk_free(chunk);
258 }
259
260 /* Throw away any leftover data chunks. */
261 while ((chunk = sctp_outq_dequeue_data(q)) != NULL) {
262
263 /* Mark as send failure. */
264 sctp_chunk_fail(chunk, q->error);
265 sctp_chunk_free(chunk);
266 }
267
Linus Torvalds1da177e2005-04-16 15:20:36 -0700268 /* Throw away any leftover control chunks. */
David S. Miller79af02c2005-07-08 21:47:49 -0700269 list_for_each_entry_safe(chunk, tmp, &q->control_chunk_list, list) {
270 list_del_init(&chunk->list);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700271 sctp_chunk_free(chunk);
David S. Miller79af02c2005-07-08 21:47:49 -0700272 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700273}
274
Neil Horman2f94aab2013-01-17 11:15:08 +0000275void sctp_outq_teardown(struct sctp_outq *q)
276{
277 __sctp_outq_teardown(q);
278 sctp_outq_init(q->asoc, q);
279}
280
Linus Torvalds1da177e2005-04-16 15:20:36 -0700281/* Free the outqueue structure and any related pending chunks. */
282void sctp_outq_free(struct sctp_outq *q)
283{
284 /* Throw away leftover chunks. */
Neil Horman2f94aab2013-01-17 11:15:08 +0000285 __sctp_outq_teardown(q);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700286}
287
288/* Put a new chunk in an sctp_outq. */
289int sctp_outq_tail(struct sctp_outq *q, struct sctp_chunk *chunk)
290{
Eric W. Biedermanb01a2402012-08-06 08:47:55 +0000291 struct net *net = sock_net(q->asoc->base.sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700292 int error = 0;
293
Daniel Borkmannbb333812013-06-28 19:49:40 +0200294 pr_debug("%s: outq:%p, chunk:%p[%s]\n", __func__, q, chunk,
295 chunk && chunk->chunk_hdr ?
296 sctp_cname(SCTP_ST_CHUNK(chunk->chunk_hdr->type)) :
297 "illegal chunk");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700298
299 /* If it is data, queue it up, otherwise, send it
300 * immediately.
301 */
Shan Weiec7b9512010-04-30 22:41:09 -0400302 if (sctp_chunk_is_data(chunk)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700303 /* Is it OK to queue data chunks? */
304 /* From 9. Termination of Association
305 *
306 * When either endpoint performs a shutdown, the
307 * association on each peer will stop accepting new
308 * data from its user and only deliver data in queue
309 * at the time of sending or receiving the SHUTDOWN
310 * chunk.
311 */
312 switch (q->asoc->state) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700313 case SCTP_STATE_CLOSED:
314 case SCTP_STATE_SHUTDOWN_PENDING:
315 case SCTP_STATE_SHUTDOWN_SENT:
316 case SCTP_STATE_SHUTDOWN_RECEIVED:
317 case SCTP_STATE_SHUTDOWN_ACK_SENT:
318 /* Cannot send after transport endpoint shutdown */
319 error = -ESHUTDOWN;
320 break;
321
322 default:
Daniel Borkmannbb333812013-06-28 19:49:40 +0200323 pr_debug("%s: outqueueing: outq:%p, chunk:%p[%s])\n",
324 __func__, q, chunk, chunk && chunk->chunk_hdr ?
325 sctp_cname(SCTP_ST_CHUNK(chunk->chunk_hdr->type)) :
326 "illegal chunk");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700327
328 sctp_outq_tail_data(q, chunk);
329 if (chunk->chunk_hdr->flags & SCTP_DATA_UNORDERED)
Eric W. Biedermanb01a2402012-08-06 08:47:55 +0000330 SCTP_INC_STATS(net, SCTP_MIB_OUTUNORDERCHUNKS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700331 else
Eric W. Biedermanb01a2402012-08-06 08:47:55 +0000332 SCTP_INC_STATS(net, SCTP_MIB_OUTORDERCHUNKS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700333 break;
Stephen Hemminger3ff50b72007-04-20 17:09:22 -0700334 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700335 } else {
David S. Miller79af02c2005-07-08 21:47:49 -0700336 list_add_tail(&chunk->list, &q->control_chunk_list);
Eric W. Biedermanb01a2402012-08-06 08:47:55 +0000337 SCTP_INC_STATS(net, SCTP_MIB_OUTCTRLCHUNKS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700338 }
339
340 if (error < 0)
341 return error;
342
343 if (!q->cork)
344 error = sctp_outq_flush(q, 0);
345
346 return error;
347}
348
349/* Insert a chunk into the sorted list based on the TSNs. The retransmit list
350 * and the abandoned list are in ascending order.
351 */
352static void sctp_insert_list(struct list_head *head, struct list_head *new)
353{
354 struct list_head *pos;
355 struct sctp_chunk *nchunk, *lchunk;
356 __u32 ntsn, ltsn;
357 int done = 0;
358
359 nchunk = list_entry(new, struct sctp_chunk, transmitted_list);
360 ntsn = ntohl(nchunk->subh.data_hdr->tsn);
361
362 list_for_each(pos, head) {
363 lchunk = list_entry(pos, struct sctp_chunk, transmitted_list);
364 ltsn = ntohl(lchunk->subh.data_hdr->tsn);
365 if (TSN_lt(ntsn, ltsn)) {
366 list_add(new, pos->prev);
367 done = 1;
368 break;
369 }
370 }
371 if (!done)
YOSHIFUJI Hideakid808ad92007-02-09 23:25:18 +0900372 list_add_tail(new, head);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700373}
374
375/* Mark all the eligible packets on a transport for retransmission. */
376void sctp_retransmit_mark(struct sctp_outq *q,
377 struct sctp_transport *transport,
Vlad Yasevichb6157d82007-10-24 15:59:16 -0400378 __u8 reason)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700379{
380 struct list_head *lchunk, *ltemp;
381 struct sctp_chunk *chunk;
382
383 /* Walk through the specified transmitted queue. */
384 list_for_each_safe(lchunk, ltemp, &transport->transmitted) {
385 chunk = list_entry(lchunk, struct sctp_chunk,
386 transmitted_list);
387
388 /* If the chunk is abandoned, move it to abandoned list. */
389 if (sctp_chunk_abandoned(chunk)) {
390 list_del_init(lchunk);
391 sctp_insert_list(&q->abandoned, lchunk);
Vlad Yasevich8c4a2d42007-02-21 02:06:04 -0800392
393 /* If this chunk has not been previousely acked,
394 * stop considering it 'outstanding'. Our peer
395 * will most likely never see it since it will
396 * not be retransmitted
397 */
398 if (!chunk->tsn_gap_acked) {
Vlad Yasevich31b02e12009-09-04 18:21:00 -0400399 if (chunk->transport)
400 chunk->transport->flight_size -=
401 sctp_data_size(chunk);
Vlad Yasevich8c4a2d42007-02-21 02:06:04 -0800402 q->outstanding_bytes -= sctp_data_size(chunk);
Thomas Grafa76c0ad2011-12-19 04:11:40 +0000403 q->asoc->peer.rwnd += sctp_data_size(chunk);
Vlad Yasevich8c4a2d42007-02-21 02:06:04 -0800404 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700405 continue;
406 }
407
Vlad Yasevichb6157d82007-10-24 15:59:16 -0400408 /* If we are doing retransmission due to a timeout or pmtu
409 * discovery, only the chunks that are not yet acked should
410 * be added to the retransmit queue.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700411 */
Vlad Yasevichb6157d82007-10-24 15:59:16 -0400412 if ((reason == SCTP_RTXR_FAST_RTX &&
Neil Hormanc226ef92008-07-25 12:44:09 -0400413 (chunk->fast_retransmit == SCTP_NEED_FRTX)) ||
Vlad Yasevichb6157d82007-10-24 15:59:16 -0400414 (reason != SCTP_RTXR_FAST_RTX && !chunk->tsn_gap_acked)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700415 /* RFC 2960 6.2.1 Processing a Received SACK
416 *
417 * C) Any time a DATA chunk is marked for
418 * retransmission (via either T3-rtx timer expiration
419 * (Section 6.3.3) or via fast retransmit
420 * (Section 7.2.4)), add the data size of those
421 * chunks to the rwnd.
422 */
Thomas Grafa76c0ad2011-12-19 04:11:40 +0000423 q->asoc->peer.rwnd += sctp_data_size(chunk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700424 q->outstanding_bytes -= sctp_data_size(chunk);
Vlad Yasevich31b02e12009-09-04 18:21:00 -0400425 if (chunk->transport)
426 transport->flight_size -= sctp_data_size(chunk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700427
428 /* sctpimpguide-05 Section 2.8.2
429 * M5) If a T3-rtx timer expires, the
430 * 'TSN.Missing.Report' of all affected TSNs is set
431 * to 0.
432 */
433 chunk->tsn_missing_report = 0;
434
435 /* If a chunk that is being used for RTT measurement
436 * has to be retransmitted, we cannot use this chunk
437 * anymore for RTT measurements. Reset rto_pending so
438 * that a new RTT measurement is started when a new
439 * data chunk is sent.
440 */
441 if (chunk->rtt_in_progress) {
442 chunk->rtt_in_progress = 0;
443 transport->rto_pending = 0;
444 }
445
Xufeng Zhang6eabca52013-11-25 11:26:57 +0800446 chunk->resent = 1;
447
Linus Torvalds1da177e2005-04-16 15:20:36 -0700448 /* Move the chunk to the retransmit queue. The chunks
449 * on the retransmit queue are always kept in order.
450 */
451 list_del_init(lchunk);
452 sctp_insert_list(&q->retransmit, lchunk);
453 }
454 }
455
Daniel Borkmannbb333812013-06-28 19:49:40 +0200456 pr_debug("%s: transport:%p, reason:%d, cwnd:%d, ssthresh:%d, "
457 "flight_size:%d, pba:%d\n", __func__, transport, reason,
458 transport->cwnd, transport->ssthresh, transport->flight_size,
459 transport->partial_bytes_acked);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700460}
461
462/* Mark all the eligible packets on a transport for retransmission and force
463 * one packet out.
464 */
465void sctp_retransmit(struct sctp_outq *q, struct sctp_transport *transport,
466 sctp_retransmit_reason_t reason)
467{
Eric W. Biedermanb01a2402012-08-06 08:47:55 +0000468 struct net *net = sock_net(q->asoc->base.sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700469 int error = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700470
471 switch(reason) {
472 case SCTP_RTXR_T3_RTX:
Eric W. Biedermanb01a2402012-08-06 08:47:55 +0000473 SCTP_INC_STATS(net, SCTP_MIB_T3_RETRANSMITS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700474 sctp_transport_lower_cwnd(transport, SCTP_LOWER_CWND_T3_RTX);
475 /* Update the retran path if the T3-rtx timer has expired for
476 * the current retran path.
477 */
478 if (transport == transport->asoc->peer.retran_path)
479 sctp_assoc_update_retran_path(transport->asoc);
Neil Horman58fbbed2008-02-29 11:40:56 -0800480 transport->asoc->rtx_data_chunks +=
481 transport->asoc->unack_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700482 break;
483 case SCTP_RTXR_FAST_RTX:
Eric W. Biedermanb01a2402012-08-06 08:47:55 +0000484 SCTP_INC_STATS(net, SCTP_MIB_FAST_RETRANSMITS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700485 sctp_transport_lower_cwnd(transport, SCTP_LOWER_CWND_FAST_RTX);
Vlad Yasevich62aeaff2008-06-04 12:39:11 -0700486 q->fast_rtx = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700487 break;
488 case SCTP_RTXR_PMTUD:
Eric W. Biedermanb01a2402012-08-06 08:47:55 +0000489 SCTP_INC_STATS(net, SCTP_MIB_PMTUD_RETRANSMITS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700490 break;
Vlad Yasevichb6157d82007-10-24 15:59:16 -0400491 case SCTP_RTXR_T1_RTX:
Eric W. Biedermanb01a2402012-08-06 08:47:55 +0000492 SCTP_INC_STATS(net, SCTP_MIB_T1_RETRANSMITS);
Neil Horman58fbbed2008-02-29 11:40:56 -0800493 transport->asoc->init_retries++;
Vlad Yasevichb6157d82007-10-24 15:59:16 -0400494 break;
Sridhar Samudralaac0b0462006-08-22 00:15:33 -0700495 default:
496 BUG();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700497 }
498
Vlad Yasevichb6157d82007-10-24 15:59:16 -0400499 sctp_retransmit_mark(q, transport, reason);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700500
501 /* PR-SCTP A5) Any time the T3-rtx timer expires, on any destination,
502 * the sender SHOULD try to advance the "Advanced.Peer.Ack.Point" by
503 * following the procedures outlined in C1 - C5.
504 */
Vlad Yasevich8b750ce2008-06-04 12:39:36 -0700505 if (reason == SCTP_RTXR_T3_RTX)
506 sctp_generate_fwdtsn(q, q->asoc->ctsn_ack_point);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700507
Vlad Yasevich8b750ce2008-06-04 12:39:36 -0700508 /* Flush the queues only on timeout, since fast_rtx is only
509 * triggered during sack processing and the queue
510 * will be flushed at the end.
511 */
512 if (reason != SCTP_RTXR_FAST_RTX)
513 error = sctp_outq_flush(q, /* rtx_timeout */ 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700514
515 if (error)
516 q->asoc->base.sk->sk_err = -error;
517}
518
519/*
520 * Transmit DATA chunks on the retransmit queue. Upon return from
521 * sctp_outq_flush_rtx() the packet 'pkt' may contain chunks which
522 * need to be transmitted by the caller.
523 * We assume that pkt->transport has already been set.
524 *
525 * The return value is a normal kernel error return value.
526 */
527static int sctp_outq_flush_rtx(struct sctp_outq *q, struct sctp_packet *pkt,
528 int rtx_timeout, int *start_timer)
529{
530 struct list_head *lqueue;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700531 struct sctp_transport *transport = pkt->transport;
532 sctp_xmit_t status;
533 struct sctp_chunk *chunk, *chunk1;
Vlad Yasevich62aeaff2008-06-04 12:39:11 -0700534 int fast_rtx;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700535 int error = 0;
Vlad Yasevich62aeaff2008-06-04 12:39:11 -0700536 int timer = 0;
Vlad Yasevich8b750ce2008-06-04 12:39:36 -0700537 int done = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700538
Linus Torvalds1da177e2005-04-16 15:20:36 -0700539 lqueue = &q->retransmit;
Vlad Yasevich62aeaff2008-06-04 12:39:11 -0700540 fast_rtx = q->fast_rtx;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700541
Vlad Yasevich8b750ce2008-06-04 12:39:36 -0700542 /* This loop handles time-out retransmissions, fast retransmissions,
543 * and retransmissions due to opening of whindow.
544 *
545 * RFC 2960 6.3.3 Handle T3-rtx Expiration
Linus Torvalds1da177e2005-04-16 15:20:36 -0700546 *
547 * E3) Determine how many of the earliest (i.e., lowest TSN)
548 * outstanding DATA chunks for the address for which the
549 * T3-rtx has expired will fit into a single packet, subject
550 * to the MTU constraint for the path corresponding to the
551 * destination transport address to which the retransmission
552 * is being sent (this may be different from the address for
553 * which the timer expires [see Section 6.4]). Call this value
554 * K. Bundle and retransmit those K DATA chunks in a single
555 * packet to the destination endpoint.
556 *
557 * [Just to be painfully clear, if we are retransmitting
558 * because a timeout just happened, we should send only ONE
559 * packet of retransmitted data.]
Vlad Yasevich8b750ce2008-06-04 12:39:36 -0700560 *
561 * For fast retransmissions we also send only ONE packet. However,
562 * if we are just flushing the queue due to open window, we'll
563 * try to send as much as possible.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700564 */
Vlad Yasevich8b750ce2008-06-04 12:39:36 -0700565 list_for_each_entry_safe(chunk, chunk1, lqueue, transmitted_list) {
Wei Yongjun4c6a6f42011-04-19 21:32:28 +0000566 /* If the chunk is abandoned, move it to abandoned list. */
567 if (sctp_chunk_abandoned(chunk)) {
568 list_del_init(&chunk->transmitted_list);
569 sctp_insert_list(&q->abandoned,
570 &chunk->transmitted_list);
571 continue;
572 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700573
574 /* Make sure that Gap Acked TSNs are not retransmitted. A
575 * simple approach is just to move such TSNs out of the
576 * way and into a 'transmitted' queue and skip to the
577 * next chunk.
578 */
579 if (chunk->tsn_gap_acked) {
Wei Yongjun54a27922012-09-03 23:58:16 +0000580 list_move_tail(&chunk->transmitted_list,
581 &transport->transmitted);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700582 continue;
583 }
584
Vlad Yasevich8b750ce2008-06-04 12:39:36 -0700585 /* If we are doing fast retransmit, ignore non-fast_rtransmit
586 * chunks
587 */
588 if (fast_rtx && !chunk->fast_retransmit)
589 continue;
590
Wei Yongjunbc4f8412010-04-30 22:38:53 -0400591redo:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700592 /* Attempt to append this chunk to the packet. */
593 status = sctp_packet_append_chunk(pkt, chunk);
594
595 switch (status) {
596 case SCTP_XMIT_PMTU_FULL:
Wei Yongjunbc4f8412010-04-30 22:38:53 -0400597 if (!pkt->has_data && !pkt->has_cookie_echo) {
598 /* If this packet did not contain DATA then
599 * retransmission did not happen, so do it
600 * again. We'll ignore the error here since
601 * control chunks are already freed so there
602 * is nothing we can do.
603 */
604 sctp_packet_transmit(pkt);
605 goto redo;
606 }
607
Linus Torvalds1da177e2005-04-16 15:20:36 -0700608 /* Send this packet. */
Vlad Yasevich62aeaff2008-06-04 12:39:11 -0700609 error = sctp_packet_transmit(pkt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700610
611 /* If we are retransmitting, we should only
612 * send a single packet.
Vlad Yasevichf246a7b2011-04-18 19:13:56 +0000613 * Otherwise, try appending this chunk again.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700614 */
Vlad Yasevich8b750ce2008-06-04 12:39:36 -0700615 if (rtx_timeout || fast_rtx)
616 done = 1;
Vlad Yasevichf246a7b2011-04-18 19:13:56 +0000617 else
618 goto redo;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700619
Vlad Yasevich8b750ce2008-06-04 12:39:36 -0700620 /* Bundle next chunk in the next round. */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700621 break;
622
623 case SCTP_XMIT_RWND_FULL:
YOSHIFUJI Hideakid808ad92007-02-09 23:25:18 +0900624 /* Send this packet. */
Vlad Yasevich62aeaff2008-06-04 12:39:11 -0700625 error = sctp_packet_transmit(pkt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700626
627 /* Stop sending DATA as there is no more room
628 * at the receiver.
629 */
Vlad Yasevich8b750ce2008-06-04 12:39:36 -0700630 done = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700631 break;
632
633 case SCTP_XMIT_NAGLE_DELAY:
YOSHIFUJI Hideakid808ad92007-02-09 23:25:18 +0900634 /* Send this packet. */
Vlad Yasevich62aeaff2008-06-04 12:39:11 -0700635 error = sctp_packet_transmit(pkt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700636
637 /* Stop sending DATA because of nagle delay. */
Vlad Yasevich8b750ce2008-06-04 12:39:36 -0700638 done = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700639 break;
640
641 default:
642 /* The append was successful, so add this chunk to
643 * the transmitted list.
644 */
Wei Yongjun54a27922012-09-03 23:58:16 +0000645 list_move_tail(&chunk->transmitted_list,
646 &transport->transmitted);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700647
YOSHIFUJI Hideakid808ad92007-02-09 23:25:18 +0900648 /* Mark the chunk as ineligible for fast retransmit
Linus Torvalds1da177e2005-04-16 15:20:36 -0700649 * after it is retransmitted.
650 */
Neil Hormanc226ef92008-07-25 12:44:09 -0400651 if (chunk->fast_retransmit == SCTP_NEED_FRTX)
652 chunk->fast_retransmit = SCTP_DONT_FRTX;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700653
Michele Baldessari196d6752012-12-01 04:49:42 +0000654 q->asoc->stats.rtxchunks++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700655 break;
Stephen Hemminger3ff50b72007-04-20 17:09:22 -0700656 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700657
Vlad Yasevich62aeaff2008-06-04 12:39:11 -0700658 /* Set the timer if there were no errors */
659 if (!error && !timer)
660 timer = 1;
661
Vlad Yasevich8b750ce2008-06-04 12:39:36 -0700662 if (done)
663 break;
664 }
665
666 /* If we are here due to a retransmit timeout or a fast
667 * retransmit and if there are any chunks left in the retransmit
668 * queue that could not fit in the PMTU sized packet, they need
669 * to be marked as ineligible for a subsequent fast retransmit.
670 */
671 if (rtx_timeout || fast_rtx) {
672 list_for_each_entry(chunk1, lqueue, transmitted_list) {
Neil Hormanc226ef92008-07-25 12:44:09 -0400673 if (chunk1->fast_retransmit == SCTP_NEED_FRTX)
674 chunk1->fast_retransmit = SCTP_DONT_FRTX;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700675 }
676 }
677
Vlad Yasevich62aeaff2008-06-04 12:39:11 -0700678 *start_timer = timer;
679
680 /* Clear fast retransmit hint */
681 if (fast_rtx)
682 q->fast_rtx = 0;
683
Linus Torvalds1da177e2005-04-16 15:20:36 -0700684 return error;
685}
686
687/* Cork the outqueue so queued chunks are really queued. */
688int sctp_outq_uncork(struct sctp_outq *q)
689{
Vlad Yasevich7d54dc62007-11-09 11:43:41 -0500690 if (q->cork)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700691 q->cork = 0;
Daniel Borkmanndacda322013-04-16 11:07:14 +0000692
693 return sctp_outq_flush(q, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700694}
695
Vlad Yasevich2e3216c2008-06-19 16:08:18 -0700696
Linus Torvalds1da177e2005-04-16 15:20:36 -0700697/*
698 * Try to flush an outqueue.
699 *
700 * Description: Send everything in q which we legally can, subject to
701 * congestion limitations.
702 * * Note: This function can be called from multiple contexts so appropriate
703 * locking concerns must be made. Today we use the sock lock to protect
704 * this function.
705 */
Adrian Bunkabd0b1982008-07-22 14:20:45 -0700706static int sctp_outq_flush(struct sctp_outq *q, int rtx_timeout)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700707{
708 struct sctp_packet *packet;
709 struct sctp_packet singleton;
710 struct sctp_association *asoc = q->asoc;
711 __u16 sport = asoc->base.bind_addr.port;
712 __u16 dport = asoc->peer.port;
713 __u32 vtag = asoc->peer.i.init_tag;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700714 struct sctp_transport *transport = NULL;
715 struct sctp_transport *new_transport;
David S. Miller79af02c2005-07-08 21:47:49 -0700716 struct sctp_chunk *chunk, *tmp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700717 sctp_xmit_t status;
718 int error = 0;
719 int start_timer = 0;
Vlad Yasevich2e3216c2008-06-19 16:08:18 -0700720 int one_packet = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700721
722 /* These transports have chunks to send. */
723 struct list_head transport_list;
724 struct list_head *ltransport;
725
726 INIT_LIST_HEAD(&transport_list);
727 packet = NULL;
728
729 /*
730 * 6.10 Bundling
731 * ...
732 * When bundling control chunks with DATA chunks, an
733 * endpoint MUST place control chunks first in the outbound
734 * SCTP packet. The transmitter MUST transmit DATA chunks
735 * within a SCTP packet in increasing order of TSN.
736 * ...
737 */
738
David S. Miller79af02c2005-07-08 21:47:49 -0700739 list_for_each_entry_safe(chunk, tmp, &q->control_chunk_list, list) {
Michio Honda8a07eb02011-04-26 20:19:36 +0900740 /* RFC 5061, 5.3
741 * F1) This means that until such time as the ASCONF
742 * containing the add is acknowledged, the sender MUST
743 * NOT use the new IP address as a source for ANY SCTP
744 * packet except on carrying an ASCONF Chunk.
745 */
746 if (asoc->src_out_of_asoc_ok &&
747 chunk->chunk_hdr->type != SCTP_CID_ASCONF)
748 continue;
749
David S. Miller79af02c2005-07-08 21:47:49 -0700750 list_del_init(&chunk->list);
751
Linus Torvalds1da177e2005-04-16 15:20:36 -0700752 /* Pick the right transport to use. */
753 new_transport = chunk->transport;
754
755 if (!new_transport) {
Vlad Yasevicha08de642007-12-20 14:11:47 -0800756 /*
757 * If we have a prior transport pointer, see if
758 * the destination address of the chunk
759 * matches the destination address of the
760 * current transport. If not a match, then
761 * try to look up the transport with a given
762 * destination address. We do this because
763 * after processing ASCONFs, we may have new
764 * transports created.
765 */
766 if (transport &&
767 sctp_cmp_addr_exact(&chunk->dest,
768 &transport->ipaddr))
769 new_transport = transport;
770 else
771 new_transport = sctp_assoc_lookup_paddr(asoc,
772 &chunk->dest);
773
774 /* if we still don't have a new transport, then
775 * use the current active path.
776 */
777 if (!new_transport)
778 new_transport = asoc->peer.active_path;
Sridhar Samudralaad8fec12006-07-21 14:48:50 -0700779 } else if ((new_transport->state == SCTP_INACTIVE) ||
Neil Horman5aa93bc2012-07-21 07:56:07 +0000780 (new_transport->state == SCTP_UNCONFIRMED) ||
781 (new_transport->state == SCTP_PF)) {
Frank Filz3f7a87d2005-06-20 13:14:57 -0700782 /* If the chunk is Heartbeat or Heartbeat Ack,
783 * send it to chunk->transport, even if it's
Linus Torvalds1da177e2005-04-16 15:20:36 -0700784 * inactive.
785 *
786 * 3.3.6 Heartbeat Acknowledgement:
YOSHIFUJI Hideakid808ad92007-02-09 23:25:18 +0900787 * ...
Linus Torvalds1da177e2005-04-16 15:20:36 -0700788 * A HEARTBEAT ACK is always sent to the source IP
789 * address of the IP datagram containing the
790 * HEARTBEAT chunk to which this ack is responding.
YOSHIFUJI Hideakid808ad92007-02-09 23:25:18 +0900791 * ...
Vlad Yasevicha08de642007-12-20 14:11:47 -0800792 *
793 * ASCONF_ACKs also must be sent to the source.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700794 */
795 if (chunk->chunk_hdr->type != SCTP_CID_HEARTBEAT &&
Vlad Yasevicha08de642007-12-20 14:11:47 -0800796 chunk->chunk_hdr->type != SCTP_CID_HEARTBEAT_ACK &&
797 chunk->chunk_hdr->type != SCTP_CID_ASCONF_ACK)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700798 new_transport = asoc->peer.active_path;
799 }
800
801 /* Are we switching transports?
802 * Take care of transport locks.
803 */
804 if (new_transport != transport) {
805 transport = new_transport;
806 if (list_empty(&transport->send_ready)) {
807 list_add_tail(&transport->send_ready,
808 &transport_list);
809 }
810 packet = &transport->packet;
811 sctp_packet_config(packet, vtag,
812 asoc->peer.ecn_capable);
813 }
814
815 switch (chunk->chunk_hdr->type) {
816 /*
817 * 6.10 Bundling
818 * ...
819 * An endpoint MUST NOT bundle INIT, INIT ACK or SHUTDOWN
820 * COMPLETE with any other chunks. [Send them immediately.]
821 */
822 case SCTP_CID_INIT:
823 case SCTP_CID_INIT_ACK:
824 case SCTP_CID_SHUTDOWN_COMPLETE:
825 sctp_packet_init(&singleton, transport, sport, dport);
826 sctp_packet_config(&singleton, vtag, 0);
827 sctp_packet_append_chunk(&singleton, chunk);
828 error = sctp_packet_transmit(&singleton);
829 if (error < 0)
830 return error;
831 break;
832
833 case SCTP_CID_ABORT:
Gui Jianfengf4ad85c2008-04-12 18:39:34 -0700834 if (sctp_test_T_bit(chunk)) {
835 packet->vtag = asoc->c.my_vtag;
836 }
Vlad Yasevich2e3216c2008-06-19 16:08:18 -0700837 /* The following chunks are "response" chunks, i.e.
838 * they are generated in response to something we
839 * received. If we are sending these, then we can
840 * send only 1 packet containing these chunks.
841 */
842 case SCTP_CID_HEARTBEAT_ACK:
843 case SCTP_CID_SHUTDOWN_ACK:
844 case SCTP_CID_COOKIE_ACK:
845 case SCTP_CID_COOKIE_ECHO:
846 case SCTP_CID_ERROR:
847 case SCTP_CID_ECN_CWR:
848 case SCTP_CID_ASCONF_ACK:
849 one_packet = 1;
Lucas De Marchi25985ed2011-03-30 22:57:33 -0300850 /* Fall through */
Vlad Yasevich2e3216c2008-06-19 16:08:18 -0700851
Linus Torvalds1da177e2005-04-16 15:20:36 -0700852 case SCTP_CID_SACK:
853 case SCTP_CID_HEARTBEAT:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700854 case SCTP_CID_SHUTDOWN:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700855 case SCTP_CID_ECN_ECNE:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700856 case SCTP_CID_ASCONF:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700857 case SCTP_CID_FWD_TSN:
Vlad Yasevich2e3216c2008-06-19 16:08:18 -0700858 status = sctp_packet_transmit_chunk(packet, chunk,
859 one_packet);
860 if (status != SCTP_XMIT_OK) {
861 /* put the chunk back */
862 list_add(&chunk->list, &q->control_chunk_list);
Michele Baldessari196d6752012-12-01 04:49:42 +0000863 } else {
864 asoc->stats.octrlchunks++;
Wei Yongjunbd69b982010-04-30 21:42:43 -0400865 /* PR-SCTP C5) If a FORWARD TSN is sent, the
866 * sender MUST assure that at least one T3-rtx
867 * timer is running.
868 */
Michele Baldessari196d6752012-12-01 04:49:42 +0000869 if (chunk->chunk_hdr->type == SCTP_CID_FWD_TSN)
870 sctp_transport_reset_timers(transport);
Vlad Yasevich2e3216c2008-06-19 16:08:18 -0700871 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700872 break;
873
874 default:
875 /* We built a chunk with an illegal type! */
876 BUG();
Stephen Hemminger3ff50b72007-04-20 17:09:22 -0700877 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700878 }
879
Michio Honda8a07eb02011-04-26 20:19:36 +0900880 if (q->asoc->src_out_of_asoc_ok)
881 goto sctp_flush_out;
882
Linus Torvalds1da177e2005-04-16 15:20:36 -0700883 /* Is it OK to send data chunks? */
884 switch (asoc->state) {
885 case SCTP_STATE_COOKIE_ECHOED:
886 /* Only allow bundling when this packet has a COOKIE-ECHO
887 * chunk.
888 */
889 if (!packet || !packet->has_cookie_echo)
890 break;
891
892 /* fallthru */
893 case SCTP_STATE_ESTABLISHED:
894 case SCTP_STATE_SHUTDOWN_PENDING:
895 case SCTP_STATE_SHUTDOWN_RECEIVED:
896 /*
897 * RFC 2960 6.1 Transmission of DATA Chunks
898 *
899 * C) When the time comes for the sender to transmit,
900 * before sending new DATA chunks, the sender MUST
901 * first transmit any outstanding DATA chunks which
902 * are marked for retransmission (limited by the
903 * current cwnd).
904 */
905 if (!list_empty(&q->retransmit)) {
Michio Hondaf207c052011-06-16 10:54:23 +0900906 if (asoc->peer.retran_path->state == SCTP_UNCONFIRMED)
907 goto sctp_flush_out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700908 if (transport == asoc->peer.retran_path)
909 goto retran;
910
911 /* Switch transports & prepare the packet. */
912
913 transport = asoc->peer.retran_path;
914
915 if (list_empty(&transport->send_ready)) {
916 list_add_tail(&transport->send_ready,
917 &transport_list);
918 }
919
920 packet = &transport->packet;
921 sctp_packet_config(packet, vtag,
922 asoc->peer.ecn_capable);
923 retran:
924 error = sctp_outq_flush_rtx(q, packet,
925 rtx_timeout, &start_timer);
926
927 if (start_timer)
Vlad Yasevichd9efc222010-04-30 22:41:09 -0400928 sctp_transport_reset_timers(transport);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700929
930 /* This can happen on COOKIE-ECHO resend. Only
931 * one chunk can get bundled with a COOKIE-ECHO.
932 */
933 if (packet->has_cookie_echo)
934 goto sctp_flush_out;
935
936 /* Don't send new data if there is still data
937 * waiting to retransmit.
938 */
939 if (!list_empty(&q->retransmit))
940 goto sctp_flush_out;
941 }
942
Vlad Yasevich46d5a802009-11-23 15:54:00 -0500943 /* Apply Max.Burst limitation to the current transport in
944 * case it will be used for new data. We are going to
945 * rest it before we return, but we want to apply the limit
946 * to the currently queued data.
947 */
948 if (transport)
949 sctp_transport_burst_limited(transport);
950
Linus Torvalds1da177e2005-04-16 15:20:36 -0700951 /* Finally, transmit new packets. */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700952 while ((chunk = sctp_outq_dequeue_data(q)) != NULL) {
953 /* RFC 2960 6.5 Every DATA chunk MUST carry a valid
954 * stream identifier.
955 */
956 if (chunk->sinfo.sinfo_stream >=
957 asoc->c.sinit_num_ostreams) {
958
959 /* Mark as failed send. */
960 sctp_chunk_fail(chunk, SCTP_ERROR_INV_STRM);
961 sctp_chunk_free(chunk);
962 continue;
963 }
964
965 /* Has this chunk expired? */
966 if (sctp_chunk_abandoned(chunk)) {
967 sctp_chunk_fail(chunk, 0);
968 sctp_chunk_free(chunk);
969 continue;
970 }
971
972 /* If there is a specified transport, use it.
973 * Otherwise, we want to use the active path.
974 */
975 new_transport = chunk->transport;
Frank Filz3f7a87d2005-06-20 13:14:57 -0700976 if (!new_transport ||
Sridhar Samudralaad8fec12006-07-21 14:48:50 -0700977 ((new_transport->state == SCTP_INACTIVE) ||
Neil Horman5aa93bc2012-07-21 07:56:07 +0000978 (new_transport->state == SCTP_UNCONFIRMED) ||
979 (new_transport->state == SCTP_PF)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700980 new_transport = asoc->peer.active_path;
Michio Hondaf207c052011-06-16 10:54:23 +0900981 if (new_transport->state == SCTP_UNCONFIRMED)
982 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700983
984 /* Change packets if necessary. */
985 if (new_transport != transport) {
986 transport = new_transport;
987
988 /* Schedule to have this transport's
989 * packet flushed.
990 */
991 if (list_empty(&transport->send_ready)) {
992 list_add_tail(&transport->send_ready,
993 &transport_list);
994 }
995
996 packet = &transport->packet;
997 sctp_packet_config(packet, vtag,
998 asoc->peer.ecn_capable);
Vlad Yasevich46d5a802009-11-23 15:54:00 -0500999 /* We've switched transports, so apply the
1000 * Burst limit to the new transport.
1001 */
1002 sctp_transport_burst_limited(transport);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001003 }
1004
Daniel Borkmannbb333812013-06-28 19:49:40 +02001005 pr_debug("%s: outq:%p, chunk:%p[%s], tx-tsn:0x%x skb->head:%p "
1006 "skb->users:%d\n",
1007 __func__, q, chunk, chunk && chunk->chunk_hdr ?
1008 sctp_cname(SCTP_ST_CHUNK(chunk->chunk_hdr->type)) :
1009 "illegal chunk", ntohl(chunk->subh.data_hdr->tsn),
1010 chunk->skb ? chunk->skb->head : NULL, chunk->skb ?
1011 atomic_read(&chunk->skb->users) : -1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001012
1013 /* Add the chunk to the packet. */
Vlad Yasevich2e3216c2008-06-19 16:08:18 -07001014 status = sctp_packet_transmit_chunk(packet, chunk, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001015
1016 switch (status) {
1017 case SCTP_XMIT_PMTU_FULL:
1018 case SCTP_XMIT_RWND_FULL:
1019 case SCTP_XMIT_NAGLE_DELAY:
1020 /* We could not append this chunk, so put
1021 * the chunk back on the output queue.
1022 */
Daniel Borkmannbb333812013-06-28 19:49:40 +02001023 pr_debug("%s: could not transmit tsn:0x%x, status:%d\n",
1024 __func__, ntohl(chunk->subh.data_hdr->tsn),
1025 status);
1026
Linus Torvalds1da177e2005-04-16 15:20:36 -07001027 sctp_outq_head_data(q, chunk);
1028 goto sctp_flush_out;
1029 break;
1030
1031 case SCTP_XMIT_OK:
Wei Yongjunb93d6472009-11-23 15:53:56 -05001032 /* The sender is in the SHUTDOWN-PENDING state,
1033 * The sender MAY set the I-bit in the DATA
1034 * chunk header.
1035 */
1036 if (asoc->state == SCTP_STATE_SHUTDOWN_PENDING)
1037 chunk->chunk_hdr->flags |= SCTP_DATA_SACK_IMM;
Michele Baldessari196d6752012-12-01 04:49:42 +00001038 if (chunk->chunk_hdr->flags & SCTP_DATA_UNORDERED)
1039 asoc->stats.ouodchunks++;
1040 else
1041 asoc->stats.oodchunks++;
Wei Yongjunb93d6472009-11-23 15:53:56 -05001042
Linus Torvalds1da177e2005-04-16 15:20:36 -07001043 break;
1044
1045 default:
1046 BUG();
1047 }
1048
YOSHIFUJI Hideakid808ad92007-02-09 23:25:18 +09001049 /* BUG: We assume that the sctp_packet_transmit()
Linus Torvalds1da177e2005-04-16 15:20:36 -07001050 * call below will succeed all the time and add the
1051 * chunk to the transmitted list and restart the
1052 * timers.
1053 * It is possible that the call can fail under OOM
1054 * conditions.
1055 *
1056 * Is this really a problem? Won't this behave
1057 * like a lost TSN?
1058 */
1059 list_add_tail(&chunk->transmitted_list,
1060 &transport->transmitted);
1061
Vlad Yasevichd9efc222010-04-30 22:41:09 -04001062 sctp_transport_reset_timers(transport);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001063
Linus Torvalds1da177e2005-04-16 15:20:36 -07001064 /* Only let one DATA chunk get bundled with a
1065 * COOKIE-ECHO chunk.
1066 */
1067 if (packet->has_cookie_echo)
1068 goto sctp_flush_out;
1069 }
1070 break;
1071
1072 default:
1073 /* Do nothing. */
1074 break;
1075 }
1076
1077sctp_flush_out:
1078
1079 /* Before returning, examine all the transports touched in
1080 * this call. Right now, we bluntly force clear all the
1081 * transports. Things might change after we implement Nagle.
1082 * But such an examination is still required.
1083 *
1084 * --xguo
1085 */
1086 while ((ltransport = sctp_list_dequeue(&transport_list)) != NULL ) {
1087 struct sctp_transport *t = list_entry(ltransport,
1088 struct sctp_transport,
1089 send_ready);
1090 packet = &t->packet;
1091 if (!sctp_packet_empty(packet))
1092 error = sctp_packet_transmit(packet);
Vlad Yasevich46d5a802009-11-23 15:54:00 -05001093
1094 /* Clear the burst limited state, if any */
1095 sctp_transport_burst_reset(t);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001096 }
1097
1098 return error;
1099}
1100
1101/* Update unack_data based on the incoming SACK chunk */
1102static void sctp_sack_update_unack_data(struct sctp_association *assoc,
1103 struct sctp_sackhdr *sack)
1104{
1105 sctp_sack_variable_t *frags;
1106 __u16 unack_data;
1107 int i;
1108
1109 unack_data = assoc->next_tsn - assoc->ctsn_ack_point - 1;
1110
1111 frags = sack->variable;
1112 for (i = 0; i < ntohs(sack->num_gap_ack_blocks); i++) {
1113 unack_data -= ((ntohs(frags[i].gab.end) -
1114 ntohs(frags[i].gab.start) + 1));
1115 }
1116
1117 assoc->unack_data = unack_data;
1118}
1119
Linus Torvalds1da177e2005-04-16 15:20:36 -07001120/* This is where we REALLY process a SACK.
1121 *
1122 * Process the SACK against the outqueue. Mostly, this just frees
1123 * things off the transmitted queue.
1124 */
Nicolas Dichteledfee032012-10-03 05:43:22 +00001125int sctp_outq_sack(struct sctp_outq *q, struct sctp_chunk *chunk)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001126{
1127 struct sctp_association *asoc = q->asoc;
Nicolas Dichteledfee032012-10-03 05:43:22 +00001128 struct sctp_sackhdr *sack = chunk->subh.sack_hdr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001129 struct sctp_transport *transport;
1130 struct sctp_chunk *tchunk = NULL;
Robert P. J. Day9dbc15f2008-04-12 18:54:24 -07001131 struct list_head *lchunk, *transport_list, *temp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001132 sctp_sack_variable_t *frags = sack->variable;
1133 __u32 sack_ctsn, ctsn, tsn;
1134 __u32 highest_tsn, highest_new_tsn;
1135 __u32 sack_a_rwnd;
Eric Dumazet95c96172012-04-15 05:58:06 +00001136 unsigned int outstanding;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001137 struct sctp_transport *primary = asoc->peer.primary_path;
1138 int count_of_newacks = 0;
Vlad Yasevich2cd9b822008-06-19 17:59:13 -04001139 int gap_ack_blocks;
Vlad Yasevichea862c82010-04-30 22:41:10 -04001140 u8 accum_moved = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001141
1142 /* Grab the association's destination address list. */
1143 transport_list = &asoc->peer.transport_addr_list;
1144
1145 sack_ctsn = ntohl(sack->cum_tsn_ack);
Vlad Yasevich2cd9b822008-06-19 17:59:13 -04001146 gap_ack_blocks = ntohs(sack->num_gap_ack_blocks);
Michele Baldessari196d6752012-12-01 04:49:42 +00001147 asoc->stats.gapcnt += gap_ack_blocks;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001148 /*
1149 * SFR-CACC algorithm:
1150 * On receipt of a SACK the sender SHOULD execute the
1151 * following statements.
1152 *
1153 * 1) If the cumulative ack in the SACK passes next tsn_at_change
1154 * on the current primary, the CHANGEOVER_ACTIVE flag SHOULD be
1155 * cleared. The CYCLING_CHANGEOVER flag SHOULD also be cleared for
1156 * all destinations.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001157 * 2) If the SACK contains gap acks and the flag CHANGEOVER_ACTIVE
1158 * is set the receiver of the SACK MUST take the following actions:
1159 *
1160 * A) Initialize the cacc_saw_newack to 0 for all destination
1161 * addresses.
Vlad Yasevichab5216a2008-06-19 18:17:24 -04001162 *
1163 * Only bother if changeover_active is set. Otherwise, this is
1164 * totally suboptimal to do on every SACK.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001165 */
Vlad Yasevichab5216a2008-06-19 18:17:24 -04001166 if (primary->cacc.changeover_active) {
1167 u8 clear_cycling = 0;
1168
1169 if (TSN_lte(primary->cacc.next_tsn_at_change, sack_ctsn)) {
1170 primary->cacc.changeover_active = 0;
1171 clear_cycling = 1;
1172 }
1173
1174 if (clear_cycling || gap_ack_blocks) {
1175 list_for_each_entry(transport, transport_list,
1176 transports) {
1177 if (clear_cycling)
1178 transport->cacc.cycling_changeover = 0;
1179 if (gap_ack_blocks)
1180 transport->cacc.cacc_saw_newack = 0;
1181 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001182 }
1183 }
1184
1185 /* Get the highest TSN in the sack. */
1186 highest_tsn = sack_ctsn;
Vlad Yasevich2cd9b822008-06-19 17:59:13 -04001187 if (gap_ack_blocks)
1188 highest_tsn += ntohs(frags[gap_ack_blocks - 1].gab.end);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001189
Vlad Yasevichbfa0d982010-04-30 22:41:10 -04001190 if (TSN_lt(asoc->highest_sacked, highest_tsn))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001191 asoc->highest_sacked = highest_tsn;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001192
Vlad Yasevichbfa0d982010-04-30 22:41:10 -04001193 highest_new_tsn = sack_ctsn;
Vlad Yasevich2cd9b822008-06-19 17:59:13 -04001194
Linus Torvalds1da177e2005-04-16 15:20:36 -07001195 /* Run through the retransmit queue. Credit bytes received
1196 * and free those chunks that we can.
1197 */
Nicolas Dichteledfee032012-10-03 05:43:22 +00001198 sctp_check_transmitted(q, &q->retransmit, NULL, NULL, sack, &highest_new_tsn);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001199
1200 /* Run through the transmitted queue.
1201 * Credit bytes received and free those chunks which we can.
1202 *
1203 * This is a MASSIVE candidate for optimization.
1204 */
Robert P. J. Day9dbc15f2008-04-12 18:54:24 -07001205 list_for_each_entry(transport, transport_list, transports) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001206 sctp_check_transmitted(q, &transport->transmitted,
Nicolas Dichteledfee032012-10-03 05:43:22 +00001207 transport, &chunk->source, sack,
1208 &highest_new_tsn);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001209 /*
1210 * SFR-CACC algorithm:
1211 * C) Let count_of_newacks be the number of
1212 * destinations for which cacc_saw_newack is set.
1213 */
1214 if (transport->cacc.cacc_saw_newack)
1215 count_of_newacks ++;
1216 }
1217
Vlad Yasevichea862c82010-04-30 22:41:10 -04001218 /* Move the Cumulative TSN Ack Point if appropriate. */
1219 if (TSN_lt(asoc->ctsn_ack_point, sack_ctsn)) {
1220 asoc->ctsn_ack_point = sack_ctsn;
1221 accum_moved = 1;
1222 }
1223
Vlad Yasevich2cd9b822008-06-19 17:59:13 -04001224 if (gap_ack_blocks) {
Vlad Yasevichea862c82010-04-30 22:41:10 -04001225
1226 if (asoc->fast_recovery && accum_moved)
1227 highest_new_tsn = highest_tsn;
1228
Vlad Yasevich2cd9b822008-06-19 17:59:13 -04001229 list_for_each_entry(transport, transport_list, transports)
1230 sctp_mark_missing(q, &transport->transmitted, transport,
1231 highest_new_tsn, count_of_newacks);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001232 }
1233
Linus Torvalds1da177e2005-04-16 15:20:36 -07001234 /* Update unack_data field in the assoc. */
1235 sctp_sack_update_unack_data(asoc, sack);
1236
1237 ctsn = asoc->ctsn_ack_point;
1238
1239 /* Throw away stuff rotting on the sack queue. */
1240 list_for_each_safe(lchunk, temp, &q->sacked) {
1241 tchunk = list_entry(lchunk, struct sctp_chunk,
1242 transmitted_list);
1243 tsn = ntohl(tchunk->subh.data_hdr->tsn);
Vlad Yasevich5f9646c2008-02-05 14:23:44 -05001244 if (TSN_lte(tsn, ctsn)) {
1245 list_del_init(&tchunk->transmitted_list);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001246 sctp_chunk_free(tchunk);
Vlad Yasevich5f9646c2008-02-05 14:23:44 -05001247 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001248 }
1249
1250 /* ii) Set rwnd equal to the newly received a_rwnd minus the
1251 * number of bytes still outstanding after processing the
1252 * Cumulative TSN Ack and the Gap Ack Blocks.
1253 */
1254
1255 sack_a_rwnd = ntohl(sack->a_rwnd);
1256 outstanding = q->outstanding_bytes;
1257
1258 if (outstanding < sack_a_rwnd)
1259 sack_a_rwnd -= outstanding;
1260 else
1261 sack_a_rwnd = 0;
1262
1263 asoc->peer.rwnd = sack_a_rwnd;
1264
1265 sctp_generate_fwdtsn(q, sack_ctsn);
1266
Daniel Borkmannbb333812013-06-28 19:49:40 +02001267 pr_debug("%s: sack cumulative tsn ack:0x%x\n", __func__, sack_ctsn);
1268 pr_debug("%s: cumulative tsn ack of assoc:%p is 0x%x, "
1269 "advertised peer ack point:0x%x\n", __func__, asoc, ctsn,
1270 asoc->adv_peer_ack_point);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001271
Vlad Yasevich619a60e2014-01-02 14:39:44 -05001272 return sctp_outq_is_empty(q);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001273}
1274
Vlad Yasevich619a60e2014-01-02 14:39:44 -05001275/* Is the outqueue empty?
1276 * The queue is empty when we have not pending data, no in-flight data
1277 * and nothing pending retransmissions.
1278 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001279int sctp_outq_is_empty(const struct sctp_outq *q)
1280{
Vlad Yasevich619a60e2014-01-02 14:39:44 -05001281 return q->out_qlen == 0 && q->outstanding_bytes == 0 &&
1282 list_empty(&q->retransmit);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001283}
1284
1285/********************************************************************
1286 * 2nd Level Abstractions
1287 ********************************************************************/
1288
1289/* Go through a transport's transmitted list or the association's retransmit
1290 * list and move chunks that are acked by the Cumulative TSN Ack to q->sacked.
1291 * The retransmit list will not have an associated transport.
1292 *
1293 * I added coherent debug information output. --xguo
1294 *
1295 * Instead of printing 'sacked' or 'kept' for each TSN on the
1296 * transmitted_queue, we print a range: SACKED: TSN1-TSN2, TSN3, TSN4-TSN5.
1297 * KEPT TSN6-TSN7, etc.
1298 */
1299static void sctp_check_transmitted(struct sctp_outq *q,
1300 struct list_head *transmitted_queue,
1301 struct sctp_transport *transport,
Nicolas Dichteledfee032012-10-03 05:43:22 +00001302 union sctp_addr *saddr,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001303 struct sctp_sackhdr *sack,
Vlad Yasevichbfa0d982010-04-30 22:41:10 -04001304 __u32 *highest_new_tsn_in_sack)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001305{
1306 struct list_head *lchunk;
1307 struct sctp_chunk *tchunk;
1308 struct list_head tlist;
1309 __u32 tsn;
1310 __u32 sack_ctsn;
1311 __u32 rtt;
1312 __u8 restart_timer = 0;
1313 int bytes_acked = 0;
Vlad Yasevich31b02e12009-09-04 18:21:00 -04001314 int migrate_bytes = 0;
Daniel Borkmann8c2f4142013-07-09 16:17:04 +02001315 bool forward_progress = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001316
Linus Torvalds1da177e2005-04-16 15:20:36 -07001317 sack_ctsn = ntohl(sack->cum_tsn_ack);
1318
1319 INIT_LIST_HEAD(&tlist);
1320
1321 /* The while loop will skip empty transmitted queues. */
1322 while (NULL != (lchunk = sctp_list_dequeue(transmitted_queue))) {
1323 tchunk = list_entry(lchunk, struct sctp_chunk,
1324 transmitted_list);
1325
1326 if (sctp_chunk_abandoned(tchunk)) {
1327 /* Move the chunk to abandoned list. */
1328 sctp_insert_list(&q->abandoned, lchunk);
Vlad Yasevich8c4a2d42007-02-21 02:06:04 -08001329
1330 /* If this chunk has not been acked, stop
1331 * considering it as 'outstanding'.
1332 */
1333 if (!tchunk->tsn_gap_acked) {
Vlad Yasevich31b02e12009-09-04 18:21:00 -04001334 if (tchunk->transport)
1335 tchunk->transport->flight_size -=
1336 sctp_data_size(tchunk);
Vlad Yasevich8c4a2d42007-02-21 02:06:04 -08001337 q->outstanding_bytes -= sctp_data_size(tchunk);
1338 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001339 continue;
1340 }
1341
1342 tsn = ntohl(tchunk->subh.data_hdr->tsn);
1343 if (sctp_acked(sack, tsn)) {
1344 /* If this queue is the retransmit queue, the
1345 * retransmit timer has already reclaimed
1346 * the outstanding bytes for this chunk, so only
1347 * count bytes associated with a transport.
1348 */
1349 if (transport) {
1350 /* If this chunk is being used for RTT
1351 * measurement, calculate the RTT and update
1352 * the RTO using this value.
1353 *
1354 * 6.3.1 C5) Karn's algorithm: RTT measurements
1355 * MUST NOT be made using packets that were
1356 * retransmitted (and thus for which it is
1357 * ambiguous whether the reply was for the
1358 * first instance of the packet or a later
1359 * instance).
1360 */
YOSHIFUJI Hideakid808ad92007-02-09 23:25:18 +09001361 if (!tchunk->tsn_gap_acked &&
Xufeng Zhang6eabca52013-11-25 11:26:57 +08001362 !tchunk->resent &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001363 tchunk->rtt_in_progress) {
Vlad Yasevich4c9f5d52006-06-17 22:56:08 -07001364 tchunk->rtt_in_progress = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001365 rtt = jiffies - tchunk->sent_at;
1366 sctp_transport_update_rto(transport,
1367 rtt);
1368 }
1369 }
Vlad Yasevich31b02e12009-09-04 18:21:00 -04001370
1371 /* If the chunk hasn't been marked as ACKED,
1372 * mark it and account bytes_acked if the
1373 * chunk had a valid transport (it will not
1374 * have a transport if ASCONF had deleted it
1375 * while DATA was outstanding).
1376 */
1377 if (!tchunk->tsn_gap_acked) {
1378 tchunk->tsn_gap_acked = 1;
Chang Xiangzhongd6c41612013-11-21 22:56:28 +01001379 if (TSN_lt(*highest_new_tsn_in_sack, tsn))
1380 *highest_new_tsn_in_sack = tsn;
Vlad Yasevich31b02e12009-09-04 18:21:00 -04001381 bytes_acked += sctp_data_size(tchunk);
1382 if (!tchunk->transport)
1383 migrate_bytes += sctp_data_size(tchunk);
Daniel Borkmann8c2f4142013-07-09 16:17:04 +02001384 forward_progress = true;
Vlad Yasevich31b02e12009-09-04 18:21:00 -04001385 }
1386
YOSHIFUJI Hideakid808ad92007-02-09 23:25:18 +09001387 if (TSN_lte(tsn, sack_ctsn)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001388 /* RFC 2960 6.3.2 Retransmission Timer Rules
1389 *
1390 * R3) Whenever a SACK is received
1391 * that acknowledges the DATA chunk
1392 * with the earliest outstanding TSN
1393 * for that address, restart T3-rtx
1394 * timer for that address with its
1395 * current RTO.
1396 */
1397 restart_timer = 1;
Daniel Borkmann8c2f4142013-07-09 16:17:04 +02001398 forward_progress = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001399
1400 if (!tchunk->tsn_gap_acked) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001401 /*
1402 * SFR-CACC algorithm:
1403 * 2) If the SACK contains gap acks
1404 * and the flag CHANGEOVER_ACTIVE is
1405 * set the receiver of the SACK MUST
1406 * take the following action:
1407 *
1408 * B) For each TSN t being acked that
1409 * has not been acked in any SACK so
1410 * far, set cacc_saw_newack to 1 for
1411 * the destination that the TSN was
1412 * sent to.
1413 */
1414 if (transport &&
1415 sack->num_gap_ack_blocks &&
1416 q->asoc->peer.primary_path->cacc.
1417 changeover_active)
1418 transport->cacc.cacc_saw_newack
1419 = 1;
1420 }
1421
1422 list_add_tail(&tchunk->transmitted_list,
1423 &q->sacked);
1424 } else {
1425 /* RFC2960 7.2.4, sctpimpguide-05 2.8.2
1426 * M2) Each time a SACK arrives reporting
1427 * 'Stray DATA chunk(s)' record the highest TSN
1428 * reported as newly acknowledged, call this
1429 * value 'HighestTSNinSack'. A newly
1430 * acknowledged DATA chunk is one not
1431 * previously acknowledged in a SACK.
1432 *
1433 * When the SCTP sender of data receives a SACK
1434 * chunk that acknowledges, for the first time,
1435 * the receipt of a DATA chunk, all the still
1436 * unacknowledged DATA chunks whose TSN is
1437 * older than that newly acknowledged DATA
1438 * chunk, are qualified as 'Stray DATA chunks'.
1439 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001440 list_add_tail(lchunk, &tlist);
1441 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001442 } else {
1443 if (tchunk->tsn_gap_acked) {
Daniel Borkmannbb333812013-06-28 19:49:40 +02001444 pr_debug("%s: receiver reneged on data TSN:0x%x\n",
1445 __func__, tsn);
1446
Linus Torvalds1da177e2005-04-16 15:20:36 -07001447 tchunk->tsn_gap_acked = 0;
1448
Vlad Yasevich31b02e12009-09-04 18:21:00 -04001449 if (tchunk->transport)
1450 bytes_acked -= sctp_data_size(tchunk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001451
1452 /* RFC 2960 6.3.2 Retransmission Timer Rules
1453 *
1454 * R4) Whenever a SACK is received missing a
1455 * TSN that was previously acknowledged via a
1456 * Gap Ack Block, start T3-rtx for the
1457 * destination address to which the DATA
1458 * chunk was originally
1459 * transmitted if it is not already running.
1460 */
1461 restart_timer = 1;
1462 }
1463
1464 list_add_tail(lchunk, &tlist);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001465 }
1466 }
1467
Linus Torvalds1da177e2005-04-16 15:20:36 -07001468 if (transport) {
1469 if (bytes_acked) {
Thomas Graff8d96052011-07-07 00:28:35 +00001470 struct sctp_association *asoc = transport->asoc;
1471
Vlad Yasevich31b02e12009-09-04 18:21:00 -04001472 /* We may have counted DATA that was migrated
1473 * to this transport due to DEL-IP operation.
1474 * Subtract those bytes, since the were never
1475 * send on this transport and shouldn't be
1476 * credited to this transport.
1477 */
1478 bytes_acked -= migrate_bytes;
1479
Linus Torvalds1da177e2005-04-16 15:20:36 -07001480 /* 8.2. When an outstanding TSN is acknowledged,
1481 * the endpoint shall clear the error counter of
1482 * the destination transport address to which the
1483 * DATA chunk was last sent.
1484 * The association's overall error counter is
1485 * also cleared.
1486 */
1487 transport->error_count = 0;
1488 transport->asoc->overall_error_count = 0;
Daniel Borkmann8c2f4142013-07-09 16:17:04 +02001489 forward_progress = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001490
Thomas Graff8d96052011-07-07 00:28:35 +00001491 /*
1492 * While in SHUTDOWN PENDING, we may have started
1493 * the T5 shutdown guard timer after reaching the
1494 * retransmission limit. Stop that timer as soon
1495 * as the receiver acknowledged any data.
1496 */
1497 if (asoc->state == SCTP_STATE_SHUTDOWN_PENDING &&
1498 del_timer(&asoc->timers
1499 [SCTP_EVENT_TIMEOUT_T5_SHUTDOWN_GUARD]))
1500 sctp_association_put(asoc);
1501
Linus Torvalds1da177e2005-04-16 15:20:36 -07001502 /* Mark the destination transport address as
1503 * active if it is not so marked.
1504 */
Nicolas Dichteledfee032012-10-03 05:43:22 +00001505 if ((transport->state == SCTP_INACTIVE ||
1506 transport->state == SCTP_UNCONFIRMED) &&
1507 sctp_cmp_addr_exact(&transport->ipaddr, saddr)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001508 sctp_assoc_control_transport(
1509 transport->asoc,
1510 transport,
1511 SCTP_TRANSPORT_UP,
1512 SCTP_RECEIVED_SACK);
1513 }
1514
1515 sctp_transport_raise_cwnd(transport, sack_ctsn,
1516 bytes_acked);
1517
1518 transport->flight_size -= bytes_acked;
Gui Jianfeng8b73a072008-04-17 14:22:18 -07001519 if (transport->flight_size == 0)
1520 transport->partial_bytes_acked = 0;
Vlad Yasevich31b02e12009-09-04 18:21:00 -04001521 q->outstanding_bytes -= bytes_acked + migrate_bytes;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001522 } else {
1523 /* RFC 2960 6.1, sctpimpguide-06 2.15.2
1524 * When a sender is doing zero window probing, it
1525 * should not timeout the association if it continues
1526 * to receive new packets from the receiver. The
1527 * reason is that the receiver MAY keep its window
1528 * closed for an indefinite time.
1529 * A sender is doing zero window probing when the
1530 * receiver's advertised window is zero, and there is
1531 * only one data chunk in flight to the receiver.
Thomas Graff8d96052011-07-07 00:28:35 +00001532 *
1533 * Allow the association to timeout while in SHUTDOWN
1534 * PENDING or SHUTDOWN RECEIVED in case the receiver
1535 * stays in zero window mode forever.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001536 */
1537 if (!q->asoc->peer.rwnd &&
1538 !list_empty(&tlist) &&
Thomas Graff8d96052011-07-07 00:28:35 +00001539 (sack_ctsn+2 == q->asoc->next_tsn) &&
1540 q->asoc->state < SCTP_STATE_SHUTDOWN_PENDING) {
Daniel Borkmannbb333812013-06-28 19:49:40 +02001541 pr_debug("%s: sack received for zero window "
1542 "probe:%u\n", __func__, sack_ctsn);
1543
Linus Torvalds1da177e2005-04-16 15:20:36 -07001544 q->asoc->overall_error_count = 0;
1545 transport->error_count = 0;
1546 }
1547 }
1548
1549 /* RFC 2960 6.3.2 Retransmission Timer Rules
1550 *
1551 * R2) Whenever all outstanding data sent to an address have
1552 * been acknowledged, turn off the T3-rtx timer of that
1553 * address.
1554 */
1555 if (!transport->flight_size) {
Ying Xue25cc4ae2013-02-03 20:32:57 +00001556 if (del_timer(&transport->T3_rtx_timer))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001557 sctp_transport_put(transport);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001558 } else if (restart_timer) {
1559 if (!mod_timer(&transport->T3_rtx_timer,
1560 jiffies + transport->rto))
1561 sctp_transport_hold(transport);
1562 }
Daniel Borkmann8c2f4142013-07-09 16:17:04 +02001563
1564 if (forward_progress) {
1565 if (transport->dst)
1566 dst_confirm(transport->dst);
1567 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001568 }
1569
1570 list_splice(&tlist, transmitted_queue);
1571}
1572
1573/* Mark chunks as missing and consequently may get retransmitted. */
1574static void sctp_mark_missing(struct sctp_outq *q,
1575 struct list_head *transmitted_queue,
1576 struct sctp_transport *transport,
1577 __u32 highest_new_tsn_in_sack,
1578 int count_of_newacks)
1579{
1580 struct sctp_chunk *chunk;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001581 __u32 tsn;
1582 char do_fast_retransmit = 0;
Vlad Yasevichea862c82010-04-30 22:41:10 -04001583 struct sctp_association *asoc = q->asoc;
1584 struct sctp_transport *primary = asoc->peer.primary_path;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001585
Robert P. J. Day9dbc15f2008-04-12 18:54:24 -07001586 list_for_each_entry(chunk, transmitted_queue, transmitted_list) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001587
Linus Torvalds1da177e2005-04-16 15:20:36 -07001588 tsn = ntohl(chunk->subh.data_hdr->tsn);
1589
1590 /* RFC 2960 7.2.4, sctpimpguide-05 2.8.2 M3) Examine all
1591 * 'Unacknowledged TSN's', if the TSN number of an
1592 * 'Unacknowledged TSN' is smaller than the 'HighestTSNinSack'
1593 * value, increment the 'TSN.Missing.Report' count on that
1594 * chunk if it has NOT been fast retransmitted or marked for
1595 * fast retransmit already.
1596 */
Neil Hormanc226ef92008-07-25 12:44:09 -04001597 if (chunk->fast_retransmit == SCTP_CAN_FRTX &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001598 !chunk->tsn_gap_acked &&
1599 TSN_lt(tsn, highest_new_tsn_in_sack)) {
1600
1601 /* SFR-CACC may require us to skip marking
1602 * this chunk as missing.
1603 */
Vlad Yasevichf246a7b2011-04-18 19:13:56 +00001604 if (!transport || !sctp_cacc_skip(primary,
1605 chunk->transport,
1606 count_of_newacks, tsn)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001607 chunk->tsn_missing_report++;
1608
Daniel Borkmannbb333812013-06-28 19:49:40 +02001609 pr_debug("%s: tsn:0x%x missing counter:%d\n",
1610 __func__, tsn, chunk->tsn_missing_report);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001611 }
1612 }
1613 /*
1614 * M4) If any DATA chunk is found to have a
1615 * 'TSN.Missing.Report'
Vlad Yasevich27852c22006-02-02 16:57:31 -08001616 * value larger than or equal to 3, mark that chunk for
Linus Torvalds1da177e2005-04-16 15:20:36 -07001617 * retransmission and start the fast retransmit procedure.
1618 */
1619
Vlad Yasevich27852c22006-02-02 16:57:31 -08001620 if (chunk->tsn_missing_report >= 3) {
Neil Hormanc226ef92008-07-25 12:44:09 -04001621 chunk->fast_retransmit = SCTP_NEED_FRTX;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001622 do_fast_retransmit = 1;
1623 }
1624 }
1625
1626 if (transport) {
1627 if (do_fast_retransmit)
1628 sctp_retransmit(q, transport, SCTP_RTXR_FAST_RTX);
1629
Daniel Borkmannbb333812013-06-28 19:49:40 +02001630 pr_debug("%s: transport:%p, cwnd:%d, ssthresh:%d, "
1631 "flight_size:%d, pba:%d\n", __func__, transport,
1632 transport->cwnd, transport->ssthresh,
1633 transport->flight_size, transport->partial_bytes_acked);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001634 }
1635}
1636
1637/* Is the given TSN acked by this packet? */
1638static int sctp_acked(struct sctp_sackhdr *sack, __u32 tsn)
1639{
1640 int i;
1641 sctp_sack_variable_t *frags;
1642 __u16 gap;
1643 __u32 ctsn = ntohl(sack->cum_tsn_ack);
1644
YOSHIFUJI Hideakid808ad92007-02-09 23:25:18 +09001645 if (TSN_lte(tsn, ctsn))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001646 goto pass;
1647
1648 /* 3.3.4 Selective Acknowledgement (SACK) (3):
1649 *
1650 * Gap Ack Blocks:
1651 * These fields contain the Gap Ack Blocks. They are repeated
1652 * for each Gap Ack Block up to the number of Gap Ack Blocks
1653 * defined in the Number of Gap Ack Blocks field. All DATA
1654 * chunks with TSNs greater than or equal to (Cumulative TSN
1655 * Ack + Gap Ack Block Start) and less than or equal to
1656 * (Cumulative TSN Ack + Gap Ack Block End) of each Gap Ack
1657 * Block are assumed to have been received correctly.
1658 */
1659
1660 frags = sack->variable;
1661 gap = tsn - ctsn;
1662 for (i = 0; i < ntohs(sack->num_gap_ack_blocks); ++i) {
1663 if (TSN_lte(ntohs(frags[i].gab.start), gap) &&
1664 TSN_lte(gap, ntohs(frags[i].gab.end)))
1665 goto pass;
1666 }
1667
1668 return 0;
1669pass:
1670 return 1;
1671}
1672
1673static inline int sctp_get_skip_pos(struct sctp_fwdtsn_skip *skiplist,
Al Viro9f81bcd2006-11-20 17:26:34 -08001674 int nskips, __be16 stream)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001675{
1676 int i;
1677
1678 for (i = 0; i < nskips; i++) {
1679 if (skiplist[i].stream == stream)
1680 return i;
1681 }
1682 return i;
1683}
1684
1685/* Create and add a fwdtsn chunk to the outq's control queue if needed. */
1686static void sctp_generate_fwdtsn(struct sctp_outq *q, __u32 ctsn)
1687{
1688 struct sctp_association *asoc = q->asoc;
1689 struct sctp_chunk *ftsn_chunk = NULL;
1690 struct sctp_fwdtsn_skip ftsn_skip_arr[10];
1691 int nskips = 0;
1692 int skip_pos = 0;
1693 __u32 tsn;
1694 struct sctp_chunk *chunk;
1695 struct list_head *lchunk, *temp;
1696
Wei Yongjun76595022009-03-12 09:49:19 +00001697 if (!asoc->peer.prsctp_capable)
1698 return;
1699
Linus Torvalds1da177e2005-04-16 15:20:36 -07001700 /* PR-SCTP C1) Let SackCumAck be the Cumulative TSN ACK carried in the
1701 * received SACK.
YOSHIFUJI Hideakid808ad92007-02-09 23:25:18 +09001702 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07001703 * If (Advanced.Peer.Ack.Point < SackCumAck), then update
1704 * Advanced.Peer.Ack.Point to be equal to SackCumAck.
1705 */
1706 if (TSN_lt(asoc->adv_peer_ack_point, ctsn))
1707 asoc->adv_peer_ack_point = ctsn;
1708
1709 /* PR-SCTP C2) Try to further advance the "Advanced.Peer.Ack.Point"
1710 * locally, that is, to move "Advanced.Peer.Ack.Point" up as long as
1711 * the chunk next in the out-queue space is marked as "abandoned" as
1712 * shown in the following example:
1713 *
1714 * Assuming that a SACK arrived with the Cumulative TSN ACK 102
1715 * and the Advanced.Peer.Ack.Point is updated to this value:
YOSHIFUJI Hideakid808ad92007-02-09 23:25:18 +09001716 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07001717 * out-queue at the end of ==> out-queue after Adv.Ack.Point
1718 * normal SACK processing local advancement
1719 * ... ...
1720 * Adv.Ack.Pt-> 102 acked 102 acked
1721 * 103 abandoned 103 abandoned
1722 * 104 abandoned Adv.Ack.P-> 104 abandoned
1723 * 105 105
1724 * 106 acked 106 acked
1725 * ... ...
1726 *
1727 * In this example, the data sender successfully advanced the
1728 * "Advanced.Peer.Ack.Point" from 102 to 104 locally.
1729 */
1730 list_for_each_safe(lchunk, temp, &q->abandoned) {
1731 chunk = list_entry(lchunk, struct sctp_chunk,
1732 transmitted_list);
1733 tsn = ntohl(chunk->subh.data_hdr->tsn);
1734
1735 /* Remove any chunks in the abandoned queue that are acked by
1736 * the ctsn.
YOSHIFUJI Hideakid808ad92007-02-09 23:25:18 +09001737 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001738 if (TSN_lte(tsn, ctsn)) {
1739 list_del_init(lchunk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001740 sctp_chunk_free(chunk);
1741 } else {
1742 if (TSN_lte(tsn, asoc->adv_peer_ack_point+1)) {
1743 asoc->adv_peer_ack_point = tsn;
1744 if (chunk->chunk_hdr->flags &
1745 SCTP_DATA_UNORDERED)
1746 continue;
1747 skip_pos = sctp_get_skip_pos(&ftsn_skip_arr[0],
1748 nskips,
1749 chunk->subh.data_hdr->stream);
1750 ftsn_skip_arr[skip_pos].stream =
1751 chunk->subh.data_hdr->stream;
1752 ftsn_skip_arr[skip_pos].ssn =
1753 chunk->subh.data_hdr->ssn;
1754 if (skip_pos == nskips)
1755 nskips++;
1756 if (nskips == 10)
1757 break;
1758 } else
1759 break;
1760 }
1761 }
1762
1763 /* PR-SCTP C3) If, after step C1 and C2, the "Advanced.Peer.Ack.Point"
1764 * is greater than the Cumulative TSN ACK carried in the received
1765 * SACK, the data sender MUST send the data receiver a FORWARD TSN
1766 * chunk containing the latest value of the
1767 * "Advanced.Peer.Ack.Point".
1768 *
1769 * C4) For each "abandoned" TSN the sender of the FORWARD TSN SHOULD
1770 * list each stream and sequence number in the forwarded TSN. This
1771 * information will enable the receiver to easily find any
1772 * stranded TSN's waiting on stream reorder queues. Each stream
1773 * SHOULD only be reported once; this means that if multiple
1774 * abandoned messages occur in the same stream then only the
1775 * highest abandoned stream sequence number is reported. If the
1776 * total size of the FORWARD TSN does NOT fit in a single MTU then
1777 * the sender of the FORWARD TSN SHOULD lower the
1778 * Advanced.Peer.Ack.Point to the last TSN that will fit in a
1779 * single MTU.
1780 */
1781 if (asoc->adv_peer_ack_point > ctsn)
1782 ftsn_chunk = sctp_make_fwdtsn(asoc, asoc->adv_peer_ack_point,
YOSHIFUJI Hideakid808ad92007-02-09 23:25:18 +09001783 nskips, &ftsn_skip_arr[0]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001784
1785 if (ftsn_chunk) {
David S. Miller79af02c2005-07-08 21:47:49 -07001786 list_add_tail(&ftsn_chunk->list, &q->control_chunk_list);
Eric W. Biedermanb01a2402012-08-06 08:47:55 +00001787 SCTP_INC_STATS(sock_net(asoc->base.sk), SCTP_MIB_OUTCTRLCHUNKS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001788 }
1789}