transport.c 19.9 KB
Newer Older
1
/* SCTP kernel implementation
Linus Torvalds's avatar
Linus Torvalds committed
2
3
4
5
6
7
 * Copyright (c) 1999-2000 Cisco, Inc.
 * Copyright (c) 1999-2001 Motorola, Inc.
 * Copyright (c) 2001-2003 International Business Machines Corp.
 * Copyright (c) 2001 Intel Corp.
 * Copyright (c) 2001 La Monte H.P. Yarroll
 *
8
 * This file is part of the SCTP kernel implementation
Linus Torvalds's avatar
Linus Torvalds committed
9
10
11
12
13
 *
 * This module provides the abstraction for an SCTP tranport representing
 * a remote transport address.  For local transport addresses, we just use
 * union sctp_addr.
 *
14
 * This SCTP implementation is free software;
Linus Torvalds's avatar
Linus Torvalds committed
15
16
17
18
19
 * you can redistribute it and/or modify it under the terms of
 * the GNU General Public License as published by
 * the Free Software Foundation; either version 2, or (at your option)
 * any later version.
 *
20
 * This SCTP implementation is distributed in the hope that it
Linus Torvalds's avatar
Linus Torvalds committed
21
22
23
24
25
26
 * will be useful, but WITHOUT ANY WARRANTY; without even the implied
 *                 ************************
 * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 * See the GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
27
28
 * along with GNU CC; see the file COPYING.  If not, see
 * <http://www.gnu.org/licenses/>.
Linus Torvalds's avatar
Linus Torvalds committed
29
30
31
 *
 * Please send any bug reports or fixes you make to the
 * email address(es):
32
 *    lksctp developers <linux-sctp@vger.kernel.org>
Linus Torvalds's avatar
Linus Torvalds committed
33
34
35
36
37
38
39
40
41
42
43
 *
 * Written or modified by:
 *    La Monte H.P. Yarroll <piggy@acm.org>
 *    Karl Knutson          <karl@athena.chicago.il.us>
 *    Jon Grimm             <jgrimm@us.ibm.com>
 *    Xingang Guo           <xingang.guo@intel.com>
 *    Hui Huang             <hui.huang@nokia.com>
 *    Sridhar Samudrala	    <sri@us.ibm.com>
 *    Ardelle Fan	    <ardelle.fan@intel.com>
 */

44
45
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

46
#include <linux/slab.h>
Linus Torvalds's avatar
Linus Torvalds committed
47
#include <linux/types.h>
48
#include <linux/random.h>
Linus Torvalds's avatar
Linus Torvalds committed
49
50
51
52
53
54
#include <net/sctp/sctp.h>
#include <net/sctp/sm.h>

/* 1st Level Abstractions.  */

/* Initialize a new transport from provided memory.  */
55
56
static struct sctp_transport *sctp_transport_init(struct net *net,
						  struct sctp_transport *peer,
Linus Torvalds's avatar
Linus Torvalds committed
57
						  const union sctp_addr *addr,
58
						  gfp_t gfp)
Linus Torvalds's avatar
Linus Torvalds committed
59
60
61
62
63
64
{
	/* Copy in the address.  */
	peer->ipaddr = *addr;
	peer->af_specific = sctp_get_af_specific(addr->sa.sa_family);
	memset(&peer->saddr, 0, sizeof(union sctp_addr));

65
66
	peer->sack_generation = 0;

Linus Torvalds's avatar
Linus Torvalds committed
67
68
69
70
71
72
	/* From 6.3.1 RTO Calculation:
	 *
	 * C1) Until an RTT measurement has been made for a packet sent to the
	 * given destination transport address, set RTO to the protocol
	 * parameter 'RTO.Initial'.
	 */
73
	peer->rto = msecs_to_jiffies(net->sctp.rto_initial);
Linus Torvalds's avatar
Linus Torvalds committed
74

75
	peer->last_time_heard = ktime_set(0, 0);
Linus Torvalds's avatar
Linus Torvalds committed
76
77
	peer->last_time_ecne_reduced = jiffies;

78
79
80
	peer->param_flags = SPP_HB_DISABLE |
			    SPP_PMTUD_ENABLE |
			    SPP_SACKDELAY_ENABLE;
Linus Torvalds's avatar
Linus Torvalds committed
81
82

	/* Initialize the default path max_retrans.  */
83
84
	peer->pathmaxrxt  = net->sctp.max_retrans_path;
	peer->pf_retrans  = net->sctp.pf_retrans;
Linus Torvalds's avatar
Linus Torvalds committed
85
86
87
88
89

	INIT_LIST_HEAD(&peer->transmitted);
	INIT_LIST_HEAD(&peer->send_ready);
	INIT_LIST_HEAD(&peer->transports);

90
91
92
93
	setup_timer(&peer->T3_rtx_timer, sctp_generate_t3_rtx_event,
			(unsigned long)peer);
	setup_timer(&peer->hb_timer, sctp_generate_heartbeat_event,
			(unsigned long)peer);
94
95
	setup_timer(&peer->proto_unreach_timer,
		    sctp_generate_proto_unreach_event, (unsigned long)peer);
Linus Torvalds's avatar
Linus Torvalds committed
96

97
98
99
	/* Initialize the 64-bit random nonce sent with heartbeat. */
	get_random_bytes(&peer->hb_nonce, sizeof(peer->hb_nonce));

Linus Torvalds's avatar
Linus Torvalds committed
100
101
102
103
104
105
	atomic_set(&peer->refcnt, 1);

	return peer;
}

/* Allocate and initialize a new transport.  */
106
107
struct sctp_transport *sctp_transport_new(struct net *net,
					  const union sctp_addr *addr,
108
					  gfp_t gfp)
Linus Torvalds's avatar
Linus Torvalds committed
109
{
110
	struct sctp_transport *transport;
Linus Torvalds's avatar
Linus Torvalds committed
111

112
	transport = kzalloc(sizeof(*transport), gfp);
Linus Torvalds's avatar
Linus Torvalds committed
113
114
115
	if (!transport)
		goto fail;

116
	if (!sctp_transport_init(net, transport, addr, gfp))
Linus Torvalds's avatar
Linus Torvalds committed
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
		goto fail_init;

	SCTP_DBG_OBJCNT_INC(transport);

	return transport;

fail_init:
	kfree(transport);

fail:
	return NULL;
}

/* This transport is no longer needed.  Free up if possible, or
 * delay until it last reference count.
 */
void sctp_transport_free(struct sctp_transport *transport)
{
	/* Try to delete the heartbeat timer.  */
	if (del_timer(&transport->hb_timer))
		sctp_transport_put(transport);

	/* Delete the T3_rtx timer if it's active.
	 * There is no point in not doing this now and letting
	 * structure hang around in memory since we know
	 * the tranport is going away.
	 */
144
	if (del_timer(&transport->T3_rtx_timer))
Linus Torvalds's avatar
Linus Torvalds committed
145
146
		sctp_transport_put(transport);

147
	/* Delete the ICMP proto unreachable timer if it's active. */
148
	if (del_timer(&transport->proto_unreach_timer))
149
		sctp_association_put(transport->asoc);
Linus Torvalds's avatar
Linus Torvalds committed
150
151
152
153

	sctp_transport_put(transport);
}

154
static void sctp_transport_destroy_rcu(struct rcu_head *head)
Linus Torvalds's avatar
Linus Torvalds committed
155
{
156
	struct sctp_transport *transport;
Linus Torvalds's avatar
Linus Torvalds committed
157

158
	transport = container_of(head, struct sctp_transport, rcu);
Linus Torvalds's avatar
Linus Torvalds committed
159
160
161
162
163
164

	dst_release(transport->dst);
	kfree(transport);
	SCTP_DBG_OBJCNT_DEC(transport);
}

165
166
167
168
169
/* Destroy the transport data structure.
 * Assumes there are no more users of this structure.
 */
static void sctp_transport_destroy(struct sctp_transport *transport)
{
170
	if (unlikely(atomic_read(&transport->refcnt))) {
171
172
173
		WARN(1, "Attempt to destroy undead transport %p!\n", transport);
		return;
	}
174

175
176
177
178
	sctp_packet_free(&transport->packet);

	if (transport->asoc)
		sctp_association_put(transport->asoc);
179
180

	call_rcu(&transport->rcu, sctp_transport_destroy_rcu);
181
182
}

Linus Torvalds's avatar
Linus Torvalds committed
183
184
185
/* Start T3_rtx timer if it is not already running and update the heartbeat
 * timer.  This routine is called every time a DATA chunk is sent.
 */
186
void sctp_transport_reset_t3_rtx(struct sctp_transport *transport)
Linus Torvalds's avatar
Linus Torvalds committed
187
188
189
190
191
192
193
194
195
{
	/* RFC 2960 6.3.2 Retransmission Timer Rules
	 *
	 * R1) Every time a DATA chunk is sent to any address(including a
	 * retransmission), if the T3-rtx timer of that address is not running
	 * start it running so that it will expire after the RTO of that
	 * address.
	 */

196
	if (!timer_pending(&transport->T3_rtx_timer))
Linus Torvalds's avatar
Linus Torvalds committed
197
198
199
		if (!mod_timer(&transport->T3_rtx_timer,
			       jiffies + transport->rto))
			sctp_transport_hold(transport);
200
201
202
203
204
}

void sctp_transport_reset_hb_timer(struct sctp_transport *transport)
{
	unsigned long expires;
Linus Torvalds's avatar
Linus Torvalds committed
205
206

	/* When a data chunk is sent, reset the heartbeat interval.  */
207
208
209
210
211
	expires = jiffies + sctp_transport_timeout(transport);
	if (time_before(transport->hb_timer.expires, expires) &&
	    !mod_timer(&transport->hb_timer,
		       expires + prandom_u32_max(transport->rto)))
		sctp_transport_hold(transport);
Linus Torvalds's avatar
Linus Torvalds committed
212
213
214
215
216
217
218
219
220
221
222
223
224
225
}

/* This transport has been assigned to an association.
 * Initialize fields from the association or from the sock itself.
 * Register the reference count in the association.
 */
void sctp_transport_set_owner(struct sctp_transport *transport,
			      struct sctp_association *asoc)
{
	transport->asoc = asoc;
	sctp_association_hold(asoc);
}

/* Initialize the pmtu of a transport. */
226
void sctp_transport_pmtu(struct sctp_transport *transport, struct sock *sk)
Linus Torvalds's avatar
Linus Torvalds committed
227
{
228
	/* If we don't have a fresh route, look one up */
229
	if (!transport->dst || transport->dst->obsolete) {
230
231
		dst_release(transport->dst);
		transport->af_specific->get_dst(transport, &transport->saddr,
232
						&transport->fl, sk);
233
	}
Linus Torvalds's avatar
Linus Torvalds committed
234

235
	if (transport->dst) {
236
		transport->pathmtu = SCTP_TRUNC4(dst_mtu(transport->dst));
Linus Torvalds's avatar
Linus Torvalds committed
237
	} else
238
		transport->pathmtu = SCTP_DEFAULT_MAXSEGMENT;
Linus Torvalds's avatar
Linus Torvalds committed
239
240
}

241
void sctp_transport_update_pmtu(struct sock *sk, struct sctp_transport *t, u32 pmtu)
242
243
244
245
{
	struct dst_entry *dst;

	if (unlikely(pmtu < SCTP_DEFAULT_MINSEGMENT)) {
246
247
248
		pr_warn("%s: Reported pmtu %d too low, using default minimum of %d\n",
			__func__, pmtu,
			SCTP_DEFAULT_MINSEGMENT);
249
250
251
252
253
254
255
256
257
		/* Use default minimum segment size and disable
		 * pmtu discovery on this transport.
		 */
		t->pathmtu = SCTP_DEFAULT_MINSEGMENT;
	} else {
		t->pathmtu = pmtu;
	}

	dst = sctp_transport_dst_check(t);
258
259
260
261
	if (!dst)
		t->af_specific->get_dst(t, &t->saddr, &t->fl, sk);

	if (dst) {
262
		dst->ops->update_pmtu(dst, sk, NULL, pmtu);
263
264
265
266
267

		dst = sctp_transport_dst_check(t);
		if (!dst)
			t->af_specific->get_dst(t, &t->saddr, &t->fl, sk);
	}
268
269
}

Linus Torvalds's avatar
Linus Torvalds committed
270
271
272
273
274
275
276
277
278
/* Caches the dst entry and source address for a transport's destination
 * address.
 */
void sctp_transport_route(struct sctp_transport *transport,
			  union sctp_addr *saddr, struct sctp_sock *opt)
{
	struct sctp_association *asoc = transport->asoc;
	struct sctp_af *af = transport->af_specific;

279
	af->get_dst(transport, saddr, &transport->fl, sctp_opt2sk(opt));
Linus Torvalds's avatar
Linus Torvalds committed
280
281
282
283

	if (saddr)
		memcpy(&transport->saddr, saddr, sizeof(union sctp_addr));
	else
284
		af->get_saddr(opt, transport, &transport->fl);
Linus Torvalds's avatar
Linus Torvalds committed
285

286
287
288
	if ((transport->param_flags & SPP_PMTUD_DISABLE) && transport->pathmtu) {
		return;
	}
289
	if (transport->dst) {
290
		transport->pathmtu = SCTP_TRUNC4(dst_mtu(transport->dst));
Linus Torvalds's avatar
Linus Torvalds committed
291
292
293

		/* Initialize sk->sk_rcv_saddr, if the transport is the
		 * association's active path for getsockname().
294
		 */
295
296
		if (asoc && (!asoc->peer.primary_path ||
				(transport == asoc->peer.active_path)))
297
298
			opt->pf->to_sk_saddr(&transport->saddr,
					     asoc->base.sk);
Linus Torvalds's avatar
Linus Torvalds committed
299
	} else
300
		transport->pathmtu = SCTP_DEFAULT_MAXSEGMENT;
Linus Torvalds's avatar
Linus Torvalds committed
301
302
303
}

/* Hold a reference to a transport.  */
304
int sctp_transport_hold(struct sctp_transport *transport)
Linus Torvalds's avatar
Linus Torvalds committed
305
{
306
	return atomic_add_unless(&transport->refcnt, 1, 0);
Linus Torvalds's avatar
Linus Torvalds committed
307
308
309
310
311
312
313
314
315
316
317
318
319
320
}

/* Release a reference to a transport and clean up
 * if there are no more references.
 */
void sctp_transport_put(struct sctp_transport *transport)
{
	if (atomic_dec_and_test(&transport->refcnt))
		sctp_transport_destroy(transport);
}

/* Update transport's RTO based on the newly calculated RTT. */
void sctp_transport_update_rto(struct sctp_transport *tp, __u32 rtt)
{
321
322
323
	if (unlikely(!tp->rto_pending))
		/* We should not be doing any RTO updates unless rto_pending is set.  */
		pr_debug("%s: rto_pending not set on transport %p!\n", __func__, tp);
Linus Torvalds's avatar
Linus Torvalds committed
324
325

	if (tp->rttvar || tp->srtt) {
326
		struct net *net = sock_net(tp->asoc->base.sk);
Linus Torvalds's avatar
Linus Torvalds committed
327
328
329
330
331
332
333
334
335
336
337
		/* 6.3.1 C3) When a new RTT measurement R' is made, set
		 * RTTVAR <- (1 - RTO.Beta) * RTTVAR + RTO.Beta * |SRTT - R'|
		 * SRTT <- (1 - RTO.Alpha) * SRTT + RTO.Alpha * R'
		 */

		/* Note:  The above algorithm has been rewritten to
		 * express rto_beta and rto_alpha as inverse powers
		 * of two.
		 * For example, assuming the default value of RTO.Alpha of
		 * 1/8, rto_alpha would be expressed as 3.
		 */
338
		tp->rttvar = tp->rttvar - (tp->rttvar >> net->sctp.rto_beta)
Andrew Morton's avatar
Andrew Morton committed
339
			+ (((__u32)abs((__s64)tp->srtt - (__s64)rtt)) >> net->sctp.rto_beta);
340
341
		tp->srtt = tp->srtt - (tp->srtt >> net->sctp.rto_alpha)
			+ (rtt >> net->sctp.rto_alpha);
Linus Torvalds's avatar
Linus Torvalds committed
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
	} else {
		/* 6.3.1 C2) When the first RTT measurement R is made, set
		 * SRTT <- R, RTTVAR <- R/2.
		 */
		tp->srtt = rtt;
		tp->rttvar = rtt >> 1;
	}

	/* 6.3.1 G1) Whenever RTTVAR is computed, if RTTVAR = 0, then
	 * adjust RTTVAR <- G, where G is the CLOCK GRANULARITY.
	 */
	if (tp->rttvar == 0)
		tp->rttvar = SCTP_CLOCK_GRANULARITY;

	/* 6.3.1 C3) After the computation, update RTO <- SRTT + 4 * RTTVAR. */
	tp->rto = tp->srtt + (tp->rttvar << 2);

	/* 6.3.1 C6) Whenever RTO is computed, if it is less than RTO.Min
	 * seconds then it is rounded up to RTO.Min seconds.
	 */
	if (tp->rto < tp->asoc->rto_min)
		tp->rto = tp->asoc->rto_min;

	/* 6.3.1 C7) A maximum value may be placed on RTO provided it is
	 * at least RTO.max seconds.
	 */
	if (tp->rto > tp->asoc->rto_max)
		tp->rto = tp->asoc->rto_max;

371
	sctp_max_rto(tp->asoc, tp);
Linus Torvalds's avatar
Linus Torvalds committed
372
373
374
375
376
377
378
	tp->rtt = rtt;

	/* Reset rto_pending so that a new RTT measurement is started when a
	 * new data chunk is sent.
	 */
	tp->rto_pending = 0;

379
380
	pr_debug("%s: transport:%p, rtt:%d, srtt:%d rttvar:%d, rto:%ld\n",
		 __func__, tp, rtt, tp->srtt, tp->rttvar, tp->rto);
Linus Torvalds's avatar
Linus Torvalds committed
381
382
383
384
385
386
387
388
}

/* This routine updates the transport's cwnd and partial_bytes_acked
 * parameters based on the bytes acked in the received SACK.
 */
void sctp_transport_raise_cwnd(struct sctp_transport *transport,
			       __u32 sack_ctsn, __u32 bytes_acked)
{
389
	struct sctp_association *asoc = transport->asoc;
Linus Torvalds's avatar
Linus Torvalds committed
390
391
392
393
394
	__u32 cwnd, ssthresh, flight_size, pba, pmtu;

	cwnd = transport->cwnd;
	flight_size = transport->flight_size;

395
	/* See if we need to exit Fast Recovery first */
396
397
398
	if (asoc->fast_recovery &&
	    TSN_lte(asoc->fast_recovery_exit, sack_ctsn))
		asoc->fast_recovery = 0;
399

Linus Torvalds's avatar
Linus Torvalds committed
400
	/* The appropriate cwnd increase algorithm is performed if, and only
401
	 * if the cumulative TSN whould advanced and the congestion window is
Linus Torvalds's avatar
Linus Torvalds committed
402
403
	 * being fully utilized.
	 */
404
	if (TSN_lte(sack_ctsn, transport->asoc->ctsn_ack_point) ||
Linus Torvalds's avatar
Linus Torvalds committed
405
406
407
408
409
	    (flight_size < cwnd))
		return;

	ssthresh = transport->ssthresh;
	pba = transport->partial_bytes_acked;
410
	pmtu = transport->asoc->pathmtu;
Linus Torvalds's avatar
Linus Torvalds committed
411
412

	if (cwnd <= ssthresh) {
413
414
415
416
417
418
419
420
421
422
423
424
425
		/* RFC 4960 7.2.1
		 * o  When cwnd is less than or equal to ssthresh, an SCTP
		 *    endpoint MUST use the slow-start algorithm to increase
		 *    cwnd only if the current congestion window is being fully
		 *    utilized, an incoming SACK advances the Cumulative TSN
		 *    Ack Point, and the data sender is not in Fast Recovery.
		 *    Only when these three conditions are met can the cwnd be
		 *    increased; otherwise, the cwnd MUST not be increased.
		 *    If these conditions are met, then cwnd MUST be increased
		 *    by, at most, the lesser of 1) the total size of the
		 *    previously outstanding DATA chunk(s) acknowledged, and
		 *    2) the destination's path MTU.  This upper bound protects
		 *    against the ACK-Splitting attack outlined in [SAVAGE99].
Linus Torvalds's avatar
Linus Torvalds committed
426
		 */
427
		if (asoc->fast_recovery)
428
429
			return;

Linus Torvalds's avatar
Linus Torvalds committed
430
431
432
433
		if (bytes_acked > pmtu)
			cwnd += pmtu;
		else
			cwnd += bytes_acked;
434
435
436
437
438

		pr_debug("%s: slow start: transport:%p, bytes_acked:%d, "
			 "cwnd:%d, ssthresh:%d, flight_size:%d, pba:%d\n",
			 __func__, transport, bytes_acked, cwnd, ssthresh,
			 flight_size, pba);
Linus Torvalds's avatar
Linus Torvalds committed
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
	} else {
		/* RFC 2960 7.2.2 Whenever cwnd is greater than ssthresh,
		 * upon each SACK arrival that advances the Cumulative TSN Ack
		 * Point, increase partial_bytes_acked by the total number of
		 * bytes of all new chunks acknowledged in that SACK including
		 * chunks acknowledged by the new Cumulative TSN Ack and by
		 * Gap Ack Blocks.
		 *
		 * When partial_bytes_acked is equal to or greater than cwnd
		 * and before the arrival of the SACK the sender had cwnd or
		 * more bytes of data outstanding (i.e., before arrival of the
		 * SACK, flightsize was greater than or equal to cwnd),
		 * increase cwnd by MTU, and reset partial_bytes_acked to
		 * (partial_bytes_acked - cwnd).
		 */
		pba += bytes_acked;
		if (pba >= cwnd) {
			cwnd += pmtu;
			pba = ((cwnd < pba) ? (pba - cwnd) : 0);
		}
459
460
461
462
463
464

		pr_debug("%s: congestion avoidance: transport:%p, "
			 "bytes_acked:%d, cwnd:%d, ssthresh:%d, "
			 "flight_size:%d, pba:%d\n", __func__,
			 transport, bytes_acked, cwnd, ssthresh,
			 flight_size, pba);
Linus Torvalds's avatar
Linus Torvalds committed
465
466
467
468
469
470
471
472
473
474
475
476
	}

	transport->cwnd = cwnd;
	transport->partial_bytes_acked = pba;
}

/* This routine is used to lower the transport's cwnd when congestion is
 * detected.
 */
void sctp_transport_lower_cwnd(struct sctp_transport *transport,
			       sctp_lower_cwnd_t reason)
{
477
478
	struct sctp_association *asoc = transport->asoc;

Linus Torvalds's avatar
Linus Torvalds committed
479
480
481
482
483
484
485
486
487
488
	switch (reason) {
	case SCTP_LOWER_CWND_T3_RTX:
		/* RFC 2960 Section 7.2.3, sctpimpguide
		 * When the T3-rtx timer expires on an address, SCTP should
		 * perform slow start by:
		 *      ssthresh = max(cwnd/2, 4*MTU)
		 *      cwnd = 1*MTU
		 *      partial_bytes_acked = 0
		 */
		transport->ssthresh = max(transport->cwnd/2,
489
490
					  4*asoc->pathmtu);
		transport->cwnd = asoc->pathmtu;
491

492
493
		/* T3-rtx also clears fast recovery */
		asoc->fast_recovery = 0;
Linus Torvalds's avatar
Linus Torvalds committed
494
495
496
497
498
499
500
		break;

	case SCTP_LOWER_CWND_FAST_RTX:
		/* RFC 2960 7.2.4 Adjust the ssthresh and cwnd of the
		 * destination address(es) to which the missing DATA chunks
		 * were last sent, according to the formula described in
		 * Section 7.2.3.
501
502
		 *
		 * RFC 2960 7.2.3, sctpimpguide Upon detection of packet
Linus Torvalds's avatar
Linus Torvalds committed
503
504
505
506
507
508
		 * losses from SACK (see Section 7.2.4), An endpoint
		 * should do the following:
		 *      ssthresh = max(cwnd/2, 4*MTU)
		 *      cwnd = ssthresh
		 *      partial_bytes_acked = 0
		 */
509
		if (asoc->fast_recovery)
510
511
512
			return;

		/* Mark Fast recovery */
513
514
		asoc->fast_recovery = 1;
		asoc->fast_recovery_exit = asoc->next_tsn - 1;
515

Linus Torvalds's avatar
Linus Torvalds committed
516
		transport->ssthresh = max(transport->cwnd/2,
517
					  4*asoc->pathmtu);
Linus Torvalds's avatar
Linus Torvalds committed
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
		transport->cwnd = transport->ssthresh;
		break;

	case SCTP_LOWER_CWND_ECNE:
		/* RFC 2481 Section 6.1.2.
		 * If the sender receives an ECN-Echo ACK packet
		 * then the sender knows that congestion was encountered in the
		 * network on the path from the sender to the receiver. The
		 * indication of congestion should be treated just as a
		 * congestion loss in non-ECN Capable TCP. That is, the TCP
		 * source halves the congestion window "cwnd" and reduces the
		 * slow start threshold "ssthresh".
		 * A critical condition is that TCP does not react to
		 * congestion indications more than once every window of
		 * data (or more loosely more than once every round-trip time).
		 */
534
535
		if (time_after(jiffies, transport->last_time_ecne_reduced +
					transport->rtt)) {
Linus Torvalds's avatar
Linus Torvalds committed
536
			transport->ssthresh = max(transport->cwnd/2,
537
						  4*asoc->pathmtu);
Linus Torvalds's avatar
Linus Torvalds committed
538
539
540
541
542
543
544
545
546
547
548
549
550
551
			transport->cwnd = transport->ssthresh;
			transport->last_time_ecne_reduced = jiffies;
		}
		break;

	case SCTP_LOWER_CWND_INACTIVE:
		/* RFC 2960 Section 7.2.1, sctpimpguide
		 * When the endpoint does not transmit data on a given
		 * transport address, the cwnd of the transport address
		 * should be adjusted to max(cwnd/2, 4*MTU) per RTO.
		 * NOTE: Although the draft recommends that this check needs
		 * to be done every RTO interval, we do it every hearbeat
		 * interval.
		 */
552
		transport->cwnd = max(transport->cwnd/2,
553
					 4*asoc->pathmtu);
Linus Torvalds's avatar
Linus Torvalds committed
554
		break;
555
	}
Linus Torvalds's avatar
Linus Torvalds committed
556
557

	transport->partial_bytes_acked = 0;
558
559
560
561

	pr_debug("%s: transport:%p, reason:%d, cwnd:%d, ssthresh:%d\n",
		 __func__, transport, reason, transport->cwnd,
		 transport->ssthresh);
Linus Torvalds's avatar
Linus Torvalds committed
562
563
}

564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
/* Apply Max.Burst limit to the congestion window:
 * sctpimpguide-05 2.14.2
 * D) When the time comes for the sender to
 * transmit new DATA chunks, the protocol parameter Max.Burst MUST
 * first be applied to limit how many new DATA chunks may be sent.
 * The limit is applied by adjusting cwnd as follows:
 * 	if ((flightsize+ Max.Burst * MTU) < cwnd)
 * 		cwnd = flightsize + Max.Burst * MTU
 */

void sctp_transport_burst_limited(struct sctp_transport *t)
{
	struct sctp_association *asoc = t->asoc;
	u32 old_cwnd = t->cwnd;
	u32 max_burst_bytes;

580
	if (t->burst_limited || asoc->max_burst == 0)
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
		return;

	max_burst_bytes = t->flight_size + (asoc->max_burst * asoc->pathmtu);
	if (max_burst_bytes < old_cwnd) {
		t->cwnd = max_burst_bytes;
		t->burst_limited = old_cwnd;
	}
}

/* Restore the old cwnd congestion window, after the burst had it's
 * desired effect.
 */
void sctp_transport_burst_reset(struct sctp_transport *t)
{
	if (t->burst_limited) {
		t->cwnd = t->burst_limited;
		t->burst_limited = 0;
	}
}

Linus Torvalds's avatar
Linus Torvalds committed
601
/* What is the next timeout value for this transport? */
602
unsigned long sctp_transport_timeout(struct sctp_transport *trans)
Linus Torvalds's avatar
Linus Torvalds committed
603
{
604
	/* RTO + timer slack +/- 50% of RTO */
605
	unsigned long timeout = trans->rto >> 1;
606
607
608
609
610

	if (trans->state != SCTP_UNCONFIRMED &&
	    trans->state != SCTP_PF)
		timeout += trans->hbinterval;

611
	return timeout;
Linus Torvalds's avatar
Linus Torvalds committed
612
}
613
614
615
616
617
618
619
620
621
622
623
624

/* Reset transport variables to their initial values */
void sctp_transport_reset(struct sctp_transport *t)
{
	struct sctp_association *asoc = t->asoc;

	/* RFC 2960 (bis), Section 5.2.4
	 * All the congestion control parameters (e.g., cwnd, ssthresh)
	 * related to this peer MUST be reset to their initial values
	 * (see Section 6.2.1)
	 */
	t->cwnd = min(4*asoc->pathmtu, max_t(__u32, 2*asoc->pathmtu, 4380));
625
	t->burst_limited = 0;
626
	t->ssthresh = asoc->peer.i.a_rwnd;
627
	t->rto = asoc->rto_initial;
628
	sctp_max_rto(asoc, t);
629
630
631
632
633
634
635
636
637
638
639
	t->rtt = 0;
	t->srtt = 0;
	t->rttvar = 0;

	/* Reset these additional varibles so that we have a clean
	 * slate.
	 */
	t->partial_bytes_acked = 0;
	t->flight_size = 0;
	t->error_count = 0;
	t->rto_pending = 0;
640
	t->hb_sent = 0;
641
642
643
644
645
646
647

	/* Initialize the state information for SFR-CACC */
	t->cacc.changeover_active = 0;
	t->cacc.cycling_changeover = 0;
	t->cacc.next_tsn_at_change = 0;
	t->cacc.cacc_saw_newack = 0;
}
648
649
650
651
652

/* Schedule retransmission on the given transport */
void sctp_transport_immediate_rtx(struct sctp_transport *t)
{
	/* Stop pending T3_rtx_timer */
653
	if (del_timer(&t->T3_rtx_timer))
654
		sctp_transport_put(t);
655

656
657
658
659
660
661
	sctp_retransmit(&t->asoc->outqueue, t, SCTP_RTXR_T3_RTX);
	if (!timer_pending(&t->T3_rtx_timer)) {
		if (!mod_timer(&t->T3_rtx_timer, jiffies + t->rto))
			sctp_transport_hold(t);
	}
}