2006-03-21 02:41:47 +01:00
|
|
|
/*
|
|
|
|
* net/dccp/ccids/ccid2.c
|
|
|
|
*
|
|
|
|
* Copyright (c) 2005, 2006 Andrea Bittau <a.bittau@cs.ucl.ac.uk>
|
|
|
|
*
|
|
|
|
* Changes to meet Linux coding standards, and DCCP infrastructure fixes.
|
|
|
|
*
|
|
|
|
* Copyright (c) 2006 Arnaldo Carvalho de Melo <acme@conectiva.com.br>
|
|
|
|
*
|
|
|
|
* This program is free software; 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 of the License, or
|
|
|
|
* (at your option) any later version.
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope that it 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
|
|
|
|
* along with this program; if not, write to the Free Software
|
|
|
|
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
2006-10-25 01:17:51 +02:00
|
|
|
* This implementation should follow RFC 4341
|
2006-03-21 02:41:47 +01:00
|
|
|
*/
|
2008-09-04 07:30:19 +02:00
|
|
|
#include "../feat.h"
|
2006-03-21 02:41:47 +01:00
|
|
|
#include "../ccid.h"
|
|
|
|
#include "../dccp.h"
|
|
|
|
#include "ccid2.h"
|
|
|
|
|
|
|
|
|
2006-09-19 22:12:44 +02:00
|
|
|
#ifdef CONFIG_IP_DCCP_CCID2_DEBUG
|
2006-11-20 21:26:03 +01:00
|
|
|
static int ccid2_debug;
|
|
|
|
#define ccid2_pr_debug(format, a...) DCCP_PR_DEBUG(ccid2_debug, format, ##a)
|
2006-03-21 02:41:47 +01:00
|
|
|
#else
|
2006-11-20 21:26:03 +01:00
|
|
|
#define ccid2_pr_debug(format, a...)
|
2006-03-21 02:41:47 +01:00
|
|
|
#endif
|
|
|
|
|
2007-10-04 23:41:00 +02:00
|
|
|
static int ccid2_hc_tx_alloc_seq(struct ccid2_hc_tx_sock *hctx)
|
2006-09-19 22:13:37 +02:00
|
|
|
{
|
|
|
|
struct ccid2_seq *seqp;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
/* check if we have space to preserve the pointer to the buffer */
|
2008-09-04 07:30:19 +02:00
|
|
|
if (hctx->seqbufc >= sizeof(hctx->seqbuf) / sizeof(struct ccid2_seq *))
|
2006-09-19 22:13:37 +02:00
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
/* allocate buffer and initialize linked list */
|
2007-10-04 23:41:00 +02:00
|
|
|
seqp = kmalloc(CCID2_SEQBUF_LEN * sizeof(struct ccid2_seq), gfp_any());
|
2006-09-19 22:13:37 +02:00
|
|
|
if (seqp == NULL)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
2007-10-04 23:41:00 +02:00
|
|
|
for (i = 0; i < (CCID2_SEQBUF_LEN - 1); i++) {
|
2006-09-19 22:13:37 +02:00
|
|
|
seqp[i].ccid2s_next = &seqp[i + 1];
|
|
|
|
seqp[i + 1].ccid2s_prev = &seqp[i];
|
|
|
|
}
|
2007-10-04 23:41:00 +02:00
|
|
|
seqp[CCID2_SEQBUF_LEN - 1].ccid2s_next = seqp;
|
|
|
|
seqp->ccid2s_prev = &seqp[CCID2_SEQBUF_LEN - 1];
|
2006-09-19 22:13:37 +02:00
|
|
|
|
|
|
|
/* This is the first allocation. Initiate the head and tail. */
|
2008-09-04 07:30:19 +02:00
|
|
|
if (hctx->seqbufc == 0)
|
|
|
|
hctx->seqh = hctx->seqt = seqp;
|
2006-09-19 22:13:37 +02:00
|
|
|
else {
|
|
|
|
/* link the existing list with the one we just created */
|
2008-09-04 07:30:19 +02:00
|
|
|
hctx->seqh->ccid2s_next = seqp;
|
|
|
|
seqp->ccid2s_prev = hctx->seqh;
|
2006-09-19 22:13:37 +02:00
|
|
|
|
2008-09-04 07:30:19 +02:00
|
|
|
hctx->seqt->ccid2s_prev = &seqp[CCID2_SEQBUF_LEN - 1];
|
|
|
|
seqp[CCID2_SEQBUF_LEN - 1].ccid2s_next = hctx->seqt;
|
2006-09-19 22:13:37 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/* store the original pointer to the buffer so we can free it */
|
2008-09-04 07:30:19 +02:00
|
|
|
hctx->seqbuf[hctx->seqbufc] = seqp;
|
|
|
|
hctx->seqbufc++;
|
2006-09-19 22:13:37 +02:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-11-28 22:55:06 +01:00
|
|
|
static int ccid2_hc_tx_send_packet(struct sock *sk, struct sk_buff *skb)
|
2006-03-21 02:41:47 +01:00
|
|
|
{
|
2008-09-04 07:30:19 +02:00
|
|
|
if (ccid2_cwnd_network_limited(ccid2_hc_tx_sk(sk)))
|
|
|
|
return CCID_PACKET_WILL_DEQUEUE_LATER;
|
|
|
|
return CCID_PACKET_SEND_AT_ONCE;
|
2006-03-21 02:41:47 +01:00
|
|
|
}
|
|
|
|
|
2007-11-25 00:32:53 +01:00
|
|
|
static void ccid2_change_l_ack_ratio(struct sock *sk, u32 val)
|
2006-03-21 02:41:47 +01:00
|
|
|
{
|
|
|
|
struct dccp_sock *dp = dccp_sk(sk);
|
2008-09-04 07:30:19 +02:00
|
|
|
u32 max_ratio = DIV_ROUND_UP(ccid2_hc_tx_sk(sk)->cwnd, 2);
|
2007-11-25 00:40:24 +01:00
|
|
|
|
2006-03-21 02:41:47 +01:00
|
|
|
/*
|
2007-11-25 00:40:24 +01:00
|
|
|
* Ensure that Ack Ratio does not exceed ceil(cwnd/2), which is (2) from
|
|
|
|
* RFC 4341, 6.1.2. We ignore the statement that Ack Ratio 2 is always
|
|
|
|
* acceptable since this causes starvation/deadlock whenever cwnd < 2.
|
|
|
|
* The same problem arises when Ack Ratio is 0 (ie. Ack Ratio disabled).
|
2006-03-21 02:41:47 +01:00
|
|
|
*/
|
2007-11-25 00:40:24 +01:00
|
|
|
if (val == 0 || val > max_ratio) {
|
|
|
|
DCCP_WARN("Limiting Ack Ratio (%u) to %u\n", val, max_ratio);
|
|
|
|
val = max_ratio;
|
2006-03-21 02:41:47 +01:00
|
|
|
}
|
2008-09-04 07:30:19 +02:00
|
|
|
if (val > DCCPF_ACK_RATIO_MAX)
|
|
|
|
val = DCCPF_ACK_RATIO_MAX;
|
2006-03-21 02:41:47 +01:00
|
|
|
|
2007-11-25 00:40:24 +01:00
|
|
|
if (val == dp->dccps_l_ack_ratio)
|
|
|
|
return;
|
|
|
|
|
2007-11-25 00:32:53 +01:00
|
|
|
ccid2_pr_debug("changing local ack ratio to %u\n", val);
|
2006-03-21 02:41:47 +01:00
|
|
|
dp->dccps_l_ack_ratio = val;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void ccid2_hc_tx_rto_expire(unsigned long data)
|
|
|
|
{
|
|
|
|
struct sock *sk = (struct sock *)data;
|
|
|
|
struct ccid2_hc_tx_sock *hctx = ccid2_hc_tx_sk(sk);
|
2008-09-04 07:30:19 +02:00
|
|
|
const bool sender_was_blocked = ccid2_cwnd_network_limited(hctx);
|
2006-03-21 02:41:47 +01:00
|
|
|
|
|
|
|
bh_lock_sock(sk);
|
|
|
|
if (sock_owned_by_user(sk)) {
|
2008-09-04 07:30:19 +02:00
|
|
|
sk_reset_timer(sk, &hctx->rtotimer, jiffies + HZ / 5);
|
2006-03-21 02:41:47 +01:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
ccid2_pr_debug("RTO_EXPIRE\n");
|
|
|
|
|
|
|
|
/* back-off timer */
|
2008-09-04 07:30:19 +02:00
|
|
|
hctx->rto <<= 1;
|
dccp ccid-2: Replace broken RTT estimator with better algorithm
The current CCID-2 RTT estimator code is in parts broken and lags behind the
suggestions in RFC2988 of using scaled variants for SRTT/RTTVAR.
That code is replaced by the present patch, which reuses the Linux TCP RTT
estimator code - reasons for this code duplication are given below.
Further details:
----------------
1. The minimum RTO of previously one second has been replaced with TCP's, since
RFC4341, sec. 5 says that the minimum of 1 sec. (suggested in RFC2988, 2.4)
is not necessary. Instead, the TCP_RTO_MIN is used, which agrees with DCCP's
concept of a default RTT (RFC 4340, 3.4).
2. The maximum RTO has been set to DCCP_RTO_MAX (64 sec), which agrees with
RFC2988, (2.5).
3. De-inlined the function ccid2_new_ack().
4. Added a FIXME: the RTT is sampled several times per Ack Vector, which will
give the wrong estimate. It should be replaced with one sample per Ack.
However, at the moment this can not be resolved easily, since
- it depends on TX history code (which also needs some work),
- the cleanest solution is not to use the `sent' time at all (saves 4 bytes
per entry) and use DCCP timestamps / elapsed time to estimated the RTT,
which however is non-trivial to get right (but needs to be done).
Reasons for reusing the Linux TCP estimator algorithm:
------------------------------------------------------
Some time was spent to find a better alternative, using basic RFC2988 as a first
step. Further analysis and experimentation showed that the Linux TCP RTO
estimator is superior to a basic RFC2988 implementation. A summary is on
http://www.erg.abdn.ac.uk/users/gerrit/dccp/notes/ccid2/rto_estimator/
In addition, this estimator fared well in a recent empirical evaluation:
Rewaskar, Sushant, Jasleen Kaur and F. Donelson Smith.
A Performance Study of Loss Detection/Recovery in Real-world TCP
Implementations. Proceedings of 15th IEEE International
Conference on Network Protocols (ICNP-07). 2007.
Thus there is significant benefit in reusing the existing TCP code.
Signed-off-by: Gerrit Renker <gerrit@erg.abdn.ac.uk>
2008-09-04 07:30:19 +02:00
|
|
|
if (hctx->rto > DCCP_RTO_MAX)
|
|
|
|
hctx->rto = DCCP_RTO_MAX;
|
2006-03-21 02:41:47 +01:00
|
|
|
|
|
|
|
/* adjust pipe, cwnd etc */
|
2008-09-04 07:30:19 +02:00
|
|
|
hctx->ssthresh = hctx->cwnd / 2;
|
|
|
|
if (hctx->ssthresh < 2)
|
|
|
|
hctx->ssthresh = 2;
|
|
|
|
hctx->cwnd = 1;
|
|
|
|
hctx->pipe = 0;
|
2006-03-21 02:41:47 +01:00
|
|
|
|
|
|
|
/* clear state about stuff we sent */
|
2008-09-04 07:30:19 +02:00
|
|
|
hctx->seqt = hctx->seqh;
|
|
|
|
hctx->packets_acked = 0;
|
2006-03-21 02:41:47 +01:00
|
|
|
|
|
|
|
/* clear ack ratio state. */
|
2008-09-04 07:30:19 +02:00
|
|
|
hctx->rpseq = 0;
|
|
|
|
hctx->rpdupack = -1;
|
2006-03-21 02:41:47 +01:00
|
|
|
ccid2_change_l_ack_ratio(sk, 1);
|
2008-09-04 07:30:19 +02:00
|
|
|
|
|
|
|
/* if we were blocked before, we may now send cwnd=1 packet */
|
|
|
|
if (sender_was_blocked)
|
|
|
|
tasklet_schedule(&dccp_sk(sk)->dccps_xmitlet);
|
2008-09-04 07:30:19 +02:00
|
|
|
/* restart backed-off timer */
|
|
|
|
sk_reset_timer(sk, &hctx->rtotimer, jiffies + hctx->rto);
|
2006-03-21 02:41:47 +01:00
|
|
|
out:
|
|
|
|
bh_unlock_sock(sk);
|
2006-03-21 02:57:52 +01:00
|
|
|
sock_put(sk);
|
2006-03-21 02:41:47 +01:00
|
|
|
}
|
|
|
|
|
2008-09-04 07:30:19 +02:00
|
|
|
static void ccid2_hc_tx_packet_sent(struct sock *sk, unsigned int len)
|
2006-03-21 02:41:47 +01:00
|
|
|
{
|
|
|
|
struct dccp_sock *dp = dccp_sk(sk);
|
|
|
|
struct ccid2_hc_tx_sock *hctx = ccid2_hc_tx_sk(sk);
|
2006-09-19 22:13:37 +02:00
|
|
|
struct ccid2_seq *next;
|
2006-03-21 02:41:47 +01:00
|
|
|
|
2008-09-04 07:30:19 +02:00
|
|
|
hctx->pipe++;
|
2006-03-21 02:41:47 +01:00
|
|
|
|
2008-09-04 07:30:19 +02:00
|
|
|
hctx->seqh->ccid2s_seq = dp->dccps_gss;
|
|
|
|
hctx->seqh->ccid2s_acked = 0;
|
|
|
|
hctx->seqh->ccid2s_sent = jiffies;
|
2006-03-21 02:41:47 +01:00
|
|
|
|
2008-09-04 07:30:19 +02:00
|
|
|
next = hctx->seqh->ccid2s_next;
|
2006-09-19 22:13:37 +02:00
|
|
|
/* check if we need to alloc more space */
|
2008-09-04 07:30:19 +02:00
|
|
|
if (next == hctx->seqt) {
|
2007-10-04 23:41:26 +02:00
|
|
|
if (ccid2_hc_tx_alloc_seq(hctx)) {
|
|
|
|
DCCP_CRIT("packet history - out of memory!");
|
|
|
|
/* FIXME: find a more graceful way to bail out */
|
|
|
|
return;
|
|
|
|
}
|
2008-09-04 07:30:19 +02:00
|
|
|
next = hctx->seqh->ccid2s_next;
|
|
|
|
BUG_ON(next == hctx->seqt);
|
2006-03-21 02:41:47 +01:00
|
|
|
}
|
2008-09-04 07:30:19 +02:00
|
|
|
hctx->seqh = next;
|
2006-09-19 22:13:37 +02:00
|
|
|
|
2008-09-04 07:30:19 +02:00
|
|
|
ccid2_pr_debug("cwnd=%d pipe=%d\n", hctx->cwnd, hctx->pipe);
|
2006-03-21 02:41:47 +01:00
|
|
|
|
2007-11-25 00:58:33 +01:00
|
|
|
/*
|
|
|
|
* FIXME: The code below is broken and the variables have been removed
|
|
|
|
* from the socket struct. The `ackloss' variable was always set to 0,
|
|
|
|
* and with arsent there are several problems:
|
|
|
|
* (i) it doesn't just count the number of Acks, but all sent packets;
|
|
|
|
* (ii) it is expressed in # of packets, not # of windows, so the
|
|
|
|
* comparison below uses the wrong formula: Appendix A of RFC 4341
|
|
|
|
* comes up with the number K = cwnd / (R^2 - R) of consecutive windows
|
|
|
|
* of data with no lost or marked Ack packets. If arsent were the # of
|
|
|
|
* consecutive Acks received without loss, then Ack Ratio needs to be
|
|
|
|
* decreased by 1 when
|
|
|
|
* arsent >= K * cwnd / R = cwnd^2 / (R^3 - R^2)
|
|
|
|
* where cwnd / R is the number of Acks received per window of data
|
|
|
|
* (cf. RFC 4341, App. A). The problems are that
|
|
|
|
* - arsent counts other packets as well;
|
|
|
|
* - the comparison uses a formula different from RFC 4341;
|
|
|
|
* - computing a cubic/quadratic equation each time is too complicated.
|
|
|
|
* Hence a different algorithm is needed.
|
|
|
|
*/
|
|
|
|
#if 0
|
2006-03-21 02:41:47 +01:00
|
|
|
/* Ack Ratio. Need to maintain a concept of how many windows we sent */
|
2008-09-04 07:30:19 +02:00
|
|
|
hctx->arsent++;
|
2006-03-21 02:41:47 +01:00
|
|
|
/* We had an ack loss in this window... */
|
2008-09-04 07:30:19 +02:00
|
|
|
if (hctx->ackloss) {
|
|
|
|
if (hctx->arsent >= hctx->cwnd) {
|
|
|
|
hctx->arsent = 0;
|
|
|
|
hctx->ackloss = 0;
|
2006-03-21 02:41:47 +01:00
|
|
|
}
|
2006-03-21 07:05:37 +01:00
|
|
|
} else {
|
|
|
|
/* No acks lost up to now... */
|
2006-03-21 02:41:47 +01:00
|
|
|
/* decrease ack ratio if enough packets were sent */
|
|
|
|
if (dp->dccps_l_ack_ratio > 1) {
|
|
|
|
/* XXX don't calculate denominator each time */
|
2006-03-21 07:05:37 +01:00
|
|
|
int denom = dp->dccps_l_ack_ratio * dp->dccps_l_ack_ratio -
|
|
|
|
dp->dccps_l_ack_ratio;
|
2006-03-21 02:41:47 +01:00
|
|
|
|
2008-09-04 07:30:19 +02:00
|
|
|
denom = hctx->cwnd * hctx->cwnd / denom;
|
2006-03-21 02:41:47 +01:00
|
|
|
|
2008-09-04 07:30:19 +02:00
|
|
|
if (hctx->arsent >= denom) {
|
2006-03-21 02:41:47 +01:00
|
|
|
ccid2_change_l_ack_ratio(sk, dp->dccps_l_ack_ratio - 1);
|
2008-09-04 07:30:19 +02:00
|
|
|
hctx->arsent = 0;
|
2006-03-21 02:41:47 +01:00
|
|
|
}
|
2006-03-21 07:05:37 +01:00
|
|
|
} else {
|
|
|
|
/* we can't increase ack ratio further [1] */
|
2008-09-04 07:30:19 +02:00
|
|
|
hctx->arsent = 0; /* or maybe set it to cwnd*/
|
2006-03-21 02:41:47 +01:00
|
|
|
}
|
|
|
|
}
|
2007-11-25 00:58:33 +01:00
|
|
|
#endif
|
2006-03-21 02:41:47 +01:00
|
|
|
|
|
|
|
/* setup RTO timer */
|
2008-09-04 07:30:19 +02:00
|
|
|
if (!timer_pending(&hctx->rtotimer))
|
2008-09-04 07:30:19 +02:00
|
|
|
sk_reset_timer(sk, &hctx->rtotimer, jiffies + hctx->rto);
|
2006-03-21 07:05:37 +01:00
|
|
|
|
2006-09-19 22:12:44 +02:00
|
|
|
#ifdef CONFIG_IP_DCCP_CCID2_DEBUG
|
2006-03-21 02:41:47 +01:00
|
|
|
do {
|
2008-09-04 07:30:19 +02:00
|
|
|
struct ccid2_seq *seqp = hctx->seqt;
|
2006-03-21 02:41:47 +01:00
|
|
|
|
2008-09-04 07:30:19 +02:00
|
|
|
while (seqp != hctx->seqh) {
|
2006-03-21 02:41:47 +01:00
|
|
|
ccid2_pr_debug("out seq=%llu acked=%d time=%lu\n",
|
2006-12-10 19:01:18 +01:00
|
|
|
(unsigned long long)seqp->ccid2s_seq,
|
2006-10-30 01:03:30 +01:00
|
|
|
seqp->ccid2s_acked, seqp->ccid2s_sent);
|
2006-03-21 02:41:47 +01:00
|
|
|
seqp = seqp->ccid2s_next;
|
|
|
|
}
|
2006-03-21 07:05:37 +01:00
|
|
|
} while (0);
|
2006-03-21 02:41:47 +01:00
|
|
|
ccid2_pr_debug("=========\n");
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
dccp ccid-2: Replace broken RTT estimator with better algorithm
The current CCID-2 RTT estimator code is in parts broken and lags behind the
suggestions in RFC2988 of using scaled variants for SRTT/RTTVAR.
That code is replaced by the present patch, which reuses the Linux TCP RTT
estimator code - reasons for this code duplication are given below.
Further details:
----------------
1. The minimum RTO of previously one second has been replaced with TCP's, since
RFC4341, sec. 5 says that the minimum of 1 sec. (suggested in RFC2988, 2.4)
is not necessary. Instead, the TCP_RTO_MIN is used, which agrees with DCCP's
concept of a default RTT (RFC 4340, 3.4).
2. The maximum RTO has been set to DCCP_RTO_MAX (64 sec), which agrees with
RFC2988, (2.5).
3. De-inlined the function ccid2_new_ack().
4. Added a FIXME: the RTT is sampled several times per Ack Vector, which will
give the wrong estimate. It should be replaced with one sample per Ack.
However, at the moment this can not be resolved easily, since
- it depends on TX history code (which also needs some work),
- the cleanest solution is not to use the `sent' time at all (saves 4 bytes
per entry) and use DCCP timestamps / elapsed time to estimated the RTT,
which however is non-trivial to get right (but needs to be done).
Reasons for reusing the Linux TCP estimator algorithm:
------------------------------------------------------
Some time was spent to find a better alternative, using basic RFC2988 as a first
step. Further analysis and experimentation showed that the Linux TCP RTO
estimator is superior to a basic RFC2988 implementation. A summary is on
http://www.erg.abdn.ac.uk/users/gerrit/dccp/notes/ccid2/rto_estimator/
In addition, this estimator fared well in a recent empirical evaluation:
Rewaskar, Sushant, Jasleen Kaur and F. Donelson Smith.
A Performance Study of Loss Detection/Recovery in Real-world TCP
Implementations. Proceedings of 15th IEEE International
Conference on Network Protocols (ICNP-07). 2007.
Thus there is significant benefit in reusing the existing TCP code.
Signed-off-by: Gerrit Renker <gerrit@erg.abdn.ac.uk>
2008-09-04 07:30:19 +02:00
|
|
|
/**
|
|
|
|
* ccid2_rtt_estimator - Sample RTT and compute RTO using RFC2988 algorithm
|
|
|
|
* This code is almost identical with TCP's tcp_rtt_estimator(), since
|
|
|
|
* - it has a higher sampling frequency (recommended by RFC 1323),
|
|
|
|
* - the RTO does not collapse into RTT due to RTTVAR going towards zero,
|
|
|
|
* - it is simple (cf. more complex proposals such as Eifel timer or research
|
|
|
|
* which suggests that the gain should be set according to window size),
|
|
|
|
* - in tests it was found to work well with CCID2 [gerrit].
|
|
|
|
*/
|
|
|
|
static void ccid2_rtt_estimator(struct sock *sk, const long mrtt)
|
|
|
|
{
|
|
|
|
struct ccid2_hc_tx_sock *hctx = ccid2_hc_tx_sk(sk);
|
|
|
|
long m = mrtt ? : 1;
|
|
|
|
|
|
|
|
if (hctx->srtt == 0) {
|
|
|
|
/* First measurement m */
|
|
|
|
hctx->srtt = m << 3;
|
|
|
|
hctx->mdev = m << 1;
|
|
|
|
|
|
|
|
hctx->mdev_max = max(TCP_RTO_MIN, hctx->mdev);
|
|
|
|
hctx->rttvar = hctx->mdev_max;
|
|
|
|
hctx->rtt_seq = dccp_sk(sk)->dccps_gss;
|
|
|
|
} else {
|
|
|
|
/* Update scaled SRTT as SRTT += 1/8 * (m - SRTT) */
|
|
|
|
m -= (hctx->srtt >> 3);
|
|
|
|
hctx->srtt += m;
|
|
|
|
|
|
|
|
/* Similarly, update scaled mdev with regard to |m| */
|
|
|
|
if (m < 0) {
|
|
|
|
m = -m;
|
|
|
|
m -= (hctx->mdev >> 2);
|
|
|
|
/*
|
|
|
|
* This neutralises RTO increase when RTT < SRTT - mdev
|
|
|
|
* (see P. Sarolahti, A. Kuznetsov,"Congestion Control
|
|
|
|
* in Linux TCP", USENIX 2002, pp. 49-62).
|
|
|
|
*/
|
|
|
|
if (m > 0)
|
|
|
|
m >>= 3;
|
|
|
|
} else {
|
|
|
|
m -= (hctx->mdev >> 2);
|
|
|
|
}
|
|
|
|
hctx->mdev += m;
|
|
|
|
|
|
|
|
if (hctx->mdev > hctx->mdev_max) {
|
|
|
|
hctx->mdev_max = hctx->mdev;
|
|
|
|
if (hctx->mdev_max > hctx->rttvar)
|
|
|
|
hctx->rttvar = hctx->mdev_max;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Decay RTTVAR at most once per flight, exploiting that
|
|
|
|
* 1) pipe <= cwnd <= Sequence_Window = W (RFC 4340, 7.5.2)
|
|
|
|
* 2) AWL = GSS-W+1 <= GAR <= GSS (RFC 4340, 7.5.1)
|
|
|
|
* GAR is a useful bound for FlightSize = pipe, AWL is probably
|
|
|
|
* too low as it over-estimates pipe.
|
|
|
|
*/
|
|
|
|
if (after48(dccp_sk(sk)->dccps_gar, hctx->rtt_seq)) {
|
|
|
|
if (hctx->mdev_max < hctx->rttvar)
|
|
|
|
hctx->rttvar -= (hctx->rttvar -
|
|
|
|
hctx->mdev_max) >> 2;
|
|
|
|
hctx->rtt_seq = dccp_sk(sk)->dccps_gss;
|
|
|
|
hctx->mdev_max = TCP_RTO_MIN;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Set RTO from SRTT and RTTVAR
|
|
|
|
* Clock granularity is ignored since the minimum error for RTTVAR is
|
|
|
|
* clamped to 50msec (corresponding to HZ=20). This leads to a minimum
|
|
|
|
* RTO of 200msec. This agrees with TCP and RFC 4341, 5.: "Because DCCP
|
|
|
|
* does not retransmit data, DCCP does not require TCP's recommended
|
|
|
|
* minimum timeout of one second".
|
|
|
|
*/
|
|
|
|
hctx->rto = (hctx->srtt >> 3) + hctx->rttvar;
|
|
|
|
|
|
|
|
if (hctx->rto > DCCP_RTO_MAX)
|
|
|
|
hctx->rto = DCCP_RTO_MAX;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void ccid2_new_ack(struct sock *sk, struct ccid2_seq *seqp,
|
|
|
|
unsigned int *maxincr)
|
2006-03-21 02:41:47 +01:00
|
|
|
{
|
|
|
|
struct ccid2_hc_tx_sock *hctx = ccid2_hc_tx_sk(sk);
|
|
|
|
|
2008-09-04 07:30:19 +02:00
|
|
|
if (hctx->cwnd < hctx->ssthresh) {
|
|
|
|
if (*maxincr > 0 && ++hctx->packets_acked == 2) {
|
|
|
|
hctx->cwnd += 1;
|
|
|
|
*maxincr -= 1;
|
|
|
|
hctx->packets_acked = 0;
|
2006-03-21 02:41:47 +01:00
|
|
|
}
|
2008-09-04 07:30:19 +02:00
|
|
|
} else if (++hctx->packets_acked >= hctx->cwnd) {
|
|
|
|
hctx->cwnd += 1;
|
|
|
|
hctx->packets_acked = 0;
|
2006-03-21 02:41:47 +01:00
|
|
|
}
|
dccp ccid-2: Replace broken RTT estimator with better algorithm
The current CCID-2 RTT estimator code is in parts broken and lags behind the
suggestions in RFC2988 of using scaled variants for SRTT/RTTVAR.
That code is replaced by the present patch, which reuses the Linux TCP RTT
estimator code - reasons for this code duplication are given below.
Further details:
----------------
1. The minimum RTO of previously one second has been replaced with TCP's, since
RFC4341, sec. 5 says that the minimum of 1 sec. (suggested in RFC2988, 2.4)
is not necessary. Instead, the TCP_RTO_MIN is used, which agrees with DCCP's
concept of a default RTT (RFC 4340, 3.4).
2. The maximum RTO has been set to DCCP_RTO_MAX (64 sec), which agrees with
RFC2988, (2.5).
3. De-inlined the function ccid2_new_ack().
4. Added a FIXME: the RTT is sampled several times per Ack Vector, which will
give the wrong estimate. It should be replaced with one sample per Ack.
However, at the moment this can not be resolved easily, since
- it depends on TX history code (which also needs some work),
- the cleanest solution is not to use the `sent' time at all (saves 4 bytes
per entry) and use DCCP timestamps / elapsed time to estimated the RTT,
which however is non-trivial to get right (but needs to be done).
Reasons for reusing the Linux TCP estimator algorithm:
------------------------------------------------------
Some time was spent to find a better alternative, using basic RFC2988 as a first
step. Further analysis and experimentation showed that the Linux TCP RTO
estimator is superior to a basic RFC2988 implementation. A summary is on
http://www.erg.abdn.ac.uk/users/gerrit/dccp/notes/ccid2/rto_estimator/
In addition, this estimator fared well in a recent empirical evaluation:
Rewaskar, Sushant, Jasleen Kaur and F. Donelson Smith.
A Performance Study of Loss Detection/Recovery in Real-world TCP
Implementations. Proceedings of 15th IEEE International
Conference on Network Protocols (ICNP-07). 2007.
Thus there is significant benefit in reusing the existing TCP code.
Signed-off-by: Gerrit Renker <gerrit@erg.abdn.ac.uk>
2008-09-04 07:30:19 +02:00
|
|
|
/*
|
|
|
|
* FIXME: RTT is sampled several times per acknowledgment (for each
|
|
|
|
* entry in the Ack Vector), instead of once per Ack (as in TCP SACK).
|
|
|
|
* This causes the RTT to be over-estimated, since the older entries
|
|
|
|
* in the Ack Vector have earlier sending times.
|
|
|
|
* The cleanest solution is to not use the ccid2s_sent field at all
|
|
|
|
* and instead use DCCP timestamps - need to be resolved at some time.
|
|
|
|
*/
|
|
|
|
ccid2_rtt_estimator(sk, jiffies - seqp->ccid2s_sent);
|
2006-03-21 02:41:47 +01:00
|
|
|
}
|
|
|
|
|
2007-11-25 00:40:24 +01:00
|
|
|
static void ccid2_congestion_event(struct sock *sk, struct ccid2_seq *seqp)
|
2006-09-19 22:14:43 +02:00
|
|
|
{
|
2007-11-25 00:40:24 +01:00
|
|
|
struct ccid2_hc_tx_sock *hctx = ccid2_hc_tx_sk(sk);
|
|
|
|
|
2008-09-04 07:30:19 +02:00
|
|
|
if (time_before(seqp->ccid2s_sent, hctx->last_cong)) {
|
2006-09-19 22:14:43 +02:00
|
|
|
ccid2_pr_debug("Multiple losses in an RTT---treating as one\n");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2008-09-04 07:30:19 +02:00
|
|
|
hctx->last_cong = jiffies;
|
2006-09-19 22:14:43 +02:00
|
|
|
|
2008-09-04 07:30:19 +02:00
|
|
|
hctx->cwnd = hctx->cwnd / 2 ? : 1U;
|
|
|
|
hctx->ssthresh = max(hctx->cwnd, 2U);
|
2007-11-25 00:40:24 +01:00
|
|
|
|
|
|
|
/* Avoid spurious timeouts resulting from Ack Ratio > cwnd */
|
2008-09-04 07:30:19 +02:00
|
|
|
if (dccp_sk(sk)->dccps_l_ack_ratio > hctx->cwnd)
|
|
|
|
ccid2_change_l_ack_ratio(sk, hctx->cwnd);
|
2006-09-19 22:14:43 +02:00
|
|
|
}
|
|
|
|
|
2008-09-04 07:30:19 +02:00
|
|
|
static int ccid2_hc_tx_parse_options(struct sock *sk, u8 packet_type,
|
|
|
|
u8 option, u8 *optval, u8 optlen)
|
|
|
|
{
|
|
|
|
struct ccid2_hc_tx_sock *hctx = ccid2_hc_tx_sk(sk);
|
|
|
|
|
|
|
|
switch (option) {
|
|
|
|
case DCCPO_ACK_VECTOR_0:
|
|
|
|
case DCCPO_ACK_VECTOR_1:
|
|
|
|
return dccp_ackvec_parsed_add(&hctx->av_chunks, optval, optlen,
|
|
|
|
option - DCCPO_ACK_VECTOR_0);
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-03-21 02:41:47 +01:00
|
|
|
static void ccid2_hc_tx_packet_recv(struct sock *sk, struct sk_buff *skb)
|
|
|
|
{
|
|
|
|
struct dccp_sock *dp = dccp_sk(sk);
|
|
|
|
struct ccid2_hc_tx_sock *hctx = ccid2_hc_tx_sk(sk);
|
2008-09-04 07:30:19 +02:00
|
|
|
const bool sender_was_blocked = ccid2_cwnd_network_limited(hctx);
|
2008-09-04 07:30:19 +02:00
|
|
|
struct dccp_ackvec_parsed *avp;
|
2006-03-21 02:41:47 +01:00
|
|
|
u64 ackno, seqno;
|
|
|
|
struct ccid2_seq *seqp;
|
|
|
|
int done = 0;
|
|
|
|
unsigned int maxincr = 0;
|
|
|
|
|
|
|
|
/* check reverse path congestion */
|
|
|
|
seqno = DCCP_SKB_CB(skb)->dccpd_seq;
|
|
|
|
|
|
|
|
/* XXX this whole "algorithm" is broken. Need to fix it to keep track
|
|
|
|
* of the seqnos of the dupacks so that rpseq and rpdupack are correct
|
|
|
|
* -sorbo.
|
|
|
|
*/
|
|
|
|
/* need to bootstrap */
|
2008-09-04 07:30:19 +02:00
|
|
|
if (hctx->rpdupack == -1) {
|
|
|
|
hctx->rpdupack = 0;
|
|
|
|
hctx->rpseq = seqno;
|
2006-03-21 07:05:37 +01:00
|
|
|
} else {
|
2006-03-21 02:41:47 +01:00
|
|
|
/* check if packet is consecutive */
|
2008-09-04 07:30:19 +02:00
|
|
|
if (dccp_delta_seqno(hctx->rpseq, seqno) == 1)
|
|
|
|
hctx->rpseq = seqno;
|
2006-03-21 02:41:47 +01:00
|
|
|
/* it's a later packet */
|
2008-09-04 07:30:19 +02:00
|
|
|
else if (after48(seqno, hctx->rpseq)) {
|
|
|
|
hctx->rpdupack++;
|
2006-03-21 02:41:47 +01:00
|
|
|
|
|
|
|
/* check if we got enough dupacks */
|
2008-09-04 07:30:19 +02:00
|
|
|
if (hctx->rpdupack >= NUMDUPACK) {
|
|
|
|
hctx->rpdupack = -1; /* XXX lame */
|
|
|
|
hctx->rpseq = 0;
|
2006-03-21 02:41:47 +01:00
|
|
|
|
2007-11-25 00:32:53 +01:00
|
|
|
ccid2_change_l_ack_ratio(sk, 2 * dp->dccps_l_ack_ratio);
|
2006-03-21 02:41:47 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* check forward path congestion */
|
2008-09-04 07:30:19 +02:00
|
|
|
if (dccp_packet_without_ack(skb))
|
2006-03-21 02:41:47 +01:00
|
|
|
return;
|
|
|
|
|
2008-09-04 07:30:19 +02:00
|
|
|
/* still didn't send out new data packets */
|
|
|
|
if (hctx->seqh == hctx->seqt)
|
|
|
|
goto done;
|
2006-03-21 02:41:47 +01:00
|
|
|
|
|
|
|
ackno = DCCP_SKB_CB(skb)->dccpd_ack_seq;
|
2008-09-04 07:30:19 +02:00
|
|
|
if (after48(ackno, hctx->high_ack))
|
|
|
|
hctx->high_ack = ackno;
|
2006-11-16 17:28:40 +01:00
|
|
|
|
2008-09-04 07:30:19 +02:00
|
|
|
seqp = hctx->seqt;
|
2006-11-16 17:28:40 +01:00
|
|
|
while (before48(seqp->ccid2s_seq, ackno)) {
|
|
|
|
seqp = seqp->ccid2s_next;
|
2008-09-04 07:30:19 +02:00
|
|
|
if (seqp == hctx->seqh) {
|
|
|
|
seqp = hctx->seqh->ccid2s_prev;
|
2006-11-16 17:28:40 +01:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2006-03-21 02:41:47 +01:00
|
|
|
|
2007-11-25 01:10:29 +01:00
|
|
|
/*
|
|
|
|
* In slow-start, cwnd can increase up to a maximum of Ack Ratio/2
|
|
|
|
* packets per acknowledgement. Rounding up avoids that cwnd is not
|
|
|
|
* advanced when Ack Ratio is 1 and gives a slight edge otherwise.
|
2006-03-21 02:41:47 +01:00
|
|
|
*/
|
2008-09-04 07:30:19 +02:00
|
|
|
if (hctx->cwnd < hctx->ssthresh)
|
2007-11-25 01:10:29 +01:00
|
|
|
maxincr = DIV_ROUND_UP(dp->dccps_l_ack_ratio, 2);
|
2006-03-21 02:41:47 +01:00
|
|
|
|
|
|
|
/* go through all ack vectors */
|
2008-09-04 07:30:19 +02:00
|
|
|
list_for_each_entry(avp, &hctx->av_chunks, node) {
|
2006-03-21 02:41:47 +01:00
|
|
|
/* go through this ack vector */
|
2008-09-04 07:30:19 +02:00
|
|
|
for (; avp->len--; avp->vec++) {
|
|
|
|
u64 ackno_end_rl = SUB48(ackno,
|
|
|
|
dccp_ackvec_runlen(avp->vec));
|
2006-03-21 02:41:47 +01:00
|
|
|
|
2008-09-04 07:30:19 +02:00
|
|
|
ccid2_pr_debug("ackvec %llu |%u,%u|\n",
|
2006-10-30 01:03:30 +01:00
|
|
|
(unsigned long long)ackno,
|
2008-09-04 07:30:19 +02:00
|
|
|
dccp_ackvec_state(avp->vec) >> 6,
|
|
|
|
dccp_ackvec_runlen(avp->vec));
|
2006-03-21 02:41:47 +01:00
|
|
|
/* if the seqno we are analyzing is larger than the
|
|
|
|
* current ackno, then move towards the tail of our
|
|
|
|
* seqnos.
|
|
|
|
*/
|
|
|
|
while (after48(seqp->ccid2s_seq, ackno)) {
|
2008-09-04 07:30:19 +02:00
|
|
|
if (seqp == hctx->seqt) {
|
2006-03-21 02:41:47 +01:00
|
|
|
done = 1;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
seqp = seqp->ccid2s_prev;
|
|
|
|
}
|
|
|
|
if (done)
|
|
|
|
break;
|
|
|
|
|
|
|
|
/* check all seqnos in the range of the vector
|
|
|
|
* run length
|
|
|
|
*/
|
|
|
|
while (between48(seqp->ccid2s_seq,ackno_end_rl,ackno)) {
|
2008-09-04 07:30:19 +02:00
|
|
|
const u8 state = dccp_ackvec_state(avp->vec);
|
2006-03-21 02:41:47 +01:00
|
|
|
|
|
|
|
/* new packet received or marked */
|
dccp ccid-2: Ack Vector interface clean-up
This patch brings the Ack Vector interface up to date. Its main purpose is
to lay the basis for the subsequent patches of this set, which will use the
new data structure fields and routines.
There are no real algorithmic changes, rather an adaptation:
(1) Replaced the static Ack Vector size (2) with a #define so that it can
be adapted (with low loss / Ack Ratio, a value of 1 works, so 2 seems
to be sufficient for the moment) and added a solution so that computing
the ECN nonce will continue to work - even with larger Ack Vectors.
(2) Replaced the #defines for Ack Vector states with a complete enum.
(3) Replaced #defines to compute Ack Vector length and state with general
purpose routines (inlines), and updated code to use these.
(4) Added a `tail' field (conversion to circular buffer in subsequent patch).
(5) Updated the (outdated) documentation for Ack Vector struct.
(6) All sequence number containers now trimmed to 48 bits.
(7) Removal of unused bits:
* removed dccpav_ack_nonce from struct dccp_ackvec, since this is already
redundantly stored in the `dccpavr_ack_nonce' (of Ack Vector record);
* removed Elapsed Time for Ack Vectors (it was nowhere used);
* replaced semantics of dccpavr_sent_len with dccpavr_ack_runlen, since
the code needs to be able to remember the old run length;
* reduced the de-/allocation routines (redundant / duplicate tests).
Justification for removing Elapsed Time information [can be removed]:
---------------------------------------------------------------------
1. The Elapsed Time information for Ack Vectors was nowhere used in the code.
2. DCCP does not implement rate-based pacing of acknowledgments. The only
recommendation for always including Elapsed Time is in section 11.3 of
RFC 4340: "Receivers that rate-pace acknowledgements SHOULD [...]
include Elapsed Time options". But such is not the case here.
3. It does not really improve estimation accuracy. The Elapsed Time field only
records the time between the arrival of the last acknowledgeable packet and
the time the Ack Vector is sent out. Since Linux does not (yet) implement
delayed Acks, the time difference will typically be small, since often the
arrival of a data packet triggers sending feedback at the HC-receiver.
Justification for changes in de-/allocation routines [can be removed]:
----------------------------------------------------------------------
* INIT_LIST_HEAD in dccp_ackvec_record_new was redundant, since the list
pointers were later overwritten when the node was added via list_add();
* dccp_ackvec_record_new() was called in a single place only;
* calls to list_del_init() before calling dccp_ackvec_record_delete() were
redundant, since subsequently the entire element was k-freed;
* since all calls to dccp_ackvec_record_delete() were preceded to a call to
list_del_init(), the WARN_ON test would never evaluate to true;
* since all calls to dccp_ackvec_record_delete() were made from within
list_for_each_entry_safe(), the test for avr == NULL was redundant;
* list_empty() in ackvec_free was redundant, since the same condition is
embedded in the loop condition of the subsequent list_for_each_entry_safe().
Signed-off-by: Gerrit Renker <gerrit@erg.abdn.ac.uk>
2008-09-04 07:30:19 +02:00
|
|
|
if (state != DCCPAV_NOT_RECEIVED &&
|
2006-03-21 02:41:47 +01:00
|
|
|
!seqp->ccid2s_acked) {
|
dccp ccid-2: Ack Vector interface clean-up
This patch brings the Ack Vector interface up to date. Its main purpose is
to lay the basis for the subsequent patches of this set, which will use the
new data structure fields and routines.
There are no real algorithmic changes, rather an adaptation:
(1) Replaced the static Ack Vector size (2) with a #define so that it can
be adapted (with low loss / Ack Ratio, a value of 1 works, so 2 seems
to be sufficient for the moment) and added a solution so that computing
the ECN nonce will continue to work - even with larger Ack Vectors.
(2) Replaced the #defines for Ack Vector states with a complete enum.
(3) Replaced #defines to compute Ack Vector length and state with general
purpose routines (inlines), and updated code to use these.
(4) Added a `tail' field (conversion to circular buffer in subsequent patch).
(5) Updated the (outdated) documentation for Ack Vector struct.
(6) All sequence number containers now trimmed to 48 bits.
(7) Removal of unused bits:
* removed dccpav_ack_nonce from struct dccp_ackvec, since this is already
redundantly stored in the `dccpavr_ack_nonce' (of Ack Vector record);
* removed Elapsed Time for Ack Vectors (it was nowhere used);
* replaced semantics of dccpavr_sent_len with dccpavr_ack_runlen, since
the code needs to be able to remember the old run length;
* reduced the de-/allocation routines (redundant / duplicate tests).
Justification for removing Elapsed Time information [can be removed]:
---------------------------------------------------------------------
1. The Elapsed Time information for Ack Vectors was nowhere used in the code.
2. DCCP does not implement rate-based pacing of acknowledgments. The only
recommendation for always including Elapsed Time is in section 11.3 of
RFC 4340: "Receivers that rate-pace acknowledgements SHOULD [...]
include Elapsed Time options". But such is not the case here.
3. It does not really improve estimation accuracy. The Elapsed Time field only
records the time between the arrival of the last acknowledgeable packet and
the time the Ack Vector is sent out. Since Linux does not (yet) implement
delayed Acks, the time difference will typically be small, since often the
arrival of a data packet triggers sending feedback at the HC-receiver.
Justification for changes in de-/allocation routines [can be removed]:
----------------------------------------------------------------------
* INIT_LIST_HEAD in dccp_ackvec_record_new was redundant, since the list
pointers were later overwritten when the node was added via list_add();
* dccp_ackvec_record_new() was called in a single place only;
* calls to list_del_init() before calling dccp_ackvec_record_delete() were
redundant, since subsequently the entire element was k-freed;
* since all calls to dccp_ackvec_record_delete() were preceded to a call to
list_del_init(), the WARN_ON test would never evaluate to true;
* since all calls to dccp_ackvec_record_delete() were made from within
list_for_each_entry_safe(), the test for avr == NULL was redundant;
* list_empty() in ackvec_free was redundant, since the same condition is
embedded in the loop condition of the subsequent list_for_each_entry_safe().
Signed-off-by: Gerrit Renker <gerrit@erg.abdn.ac.uk>
2008-09-04 07:30:19 +02:00
|
|
|
if (state == DCCPAV_ECN_MARKED)
|
2007-11-25 00:40:24 +01:00
|
|
|
ccid2_congestion_event(sk,
|
2006-09-19 22:14:43 +02:00
|
|
|
seqp);
|
dccp ccid-2: Ack Vector interface clean-up
This patch brings the Ack Vector interface up to date. Its main purpose is
to lay the basis for the subsequent patches of this set, which will use the
new data structure fields and routines.
There are no real algorithmic changes, rather an adaptation:
(1) Replaced the static Ack Vector size (2) with a #define so that it can
be adapted (with low loss / Ack Ratio, a value of 1 works, so 2 seems
to be sufficient for the moment) and added a solution so that computing
the ECN nonce will continue to work - even with larger Ack Vectors.
(2) Replaced the #defines for Ack Vector states with a complete enum.
(3) Replaced #defines to compute Ack Vector length and state with general
purpose routines (inlines), and updated code to use these.
(4) Added a `tail' field (conversion to circular buffer in subsequent patch).
(5) Updated the (outdated) documentation for Ack Vector struct.
(6) All sequence number containers now trimmed to 48 bits.
(7) Removal of unused bits:
* removed dccpav_ack_nonce from struct dccp_ackvec, since this is already
redundantly stored in the `dccpavr_ack_nonce' (of Ack Vector record);
* removed Elapsed Time for Ack Vectors (it was nowhere used);
* replaced semantics of dccpavr_sent_len with dccpavr_ack_runlen, since
the code needs to be able to remember the old run length;
* reduced the de-/allocation routines (redundant / duplicate tests).
Justification for removing Elapsed Time information [can be removed]:
---------------------------------------------------------------------
1. The Elapsed Time information for Ack Vectors was nowhere used in the code.
2. DCCP does not implement rate-based pacing of acknowledgments. The only
recommendation for always including Elapsed Time is in section 11.3 of
RFC 4340: "Receivers that rate-pace acknowledgements SHOULD [...]
include Elapsed Time options". But such is not the case here.
3. It does not really improve estimation accuracy. The Elapsed Time field only
records the time between the arrival of the last acknowledgeable packet and
the time the Ack Vector is sent out. Since Linux does not (yet) implement
delayed Acks, the time difference will typically be small, since often the
arrival of a data packet triggers sending feedback at the HC-receiver.
Justification for changes in de-/allocation routines [can be removed]:
----------------------------------------------------------------------
* INIT_LIST_HEAD in dccp_ackvec_record_new was redundant, since the list
pointers were later overwritten when the node was added via list_add();
* dccp_ackvec_record_new() was called in a single place only;
* calls to list_del_init() before calling dccp_ackvec_record_delete() were
redundant, since subsequently the entire element was k-freed;
* since all calls to dccp_ackvec_record_delete() were preceded to a call to
list_del_init(), the WARN_ON test would never evaluate to true;
* since all calls to dccp_ackvec_record_delete() were made from within
list_for_each_entry_safe(), the test for avr == NULL was redundant;
* list_empty() in ackvec_free was redundant, since the same condition is
embedded in the loop condition of the subsequent list_for_each_entry_safe().
Signed-off-by: Gerrit Renker <gerrit@erg.abdn.ac.uk>
2008-09-04 07:30:19 +02:00
|
|
|
else
|
2006-03-21 02:41:47 +01:00
|
|
|
ccid2_new_ack(sk, seqp,
|
|
|
|
&maxincr);
|
|
|
|
|
|
|
|
seqp->ccid2s_acked = 1;
|
|
|
|
ccid2_pr_debug("Got ack for %llu\n",
|
2006-10-30 01:03:30 +01:00
|
|
|
(unsigned long long)seqp->ccid2s_seq);
|
2008-09-04 07:30:19 +02:00
|
|
|
hctx->pipe--;
|
2006-03-21 02:41:47 +01:00
|
|
|
}
|
2008-09-04 07:30:19 +02:00
|
|
|
if (seqp == hctx->seqt) {
|
2006-03-21 02:41:47 +01:00
|
|
|
done = 1;
|
|
|
|
break;
|
|
|
|
}
|
2007-11-24 23:37:48 +01:00
|
|
|
seqp = seqp->ccid2s_prev;
|
2006-03-21 02:41:47 +01:00
|
|
|
}
|
|
|
|
if (done)
|
|
|
|
break;
|
|
|
|
|
2007-11-24 23:43:59 +01:00
|
|
|
ackno = SUB48(ackno_end_rl, 1);
|
2006-03-21 02:41:47 +01:00
|
|
|
}
|
|
|
|
if (done)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* The state about what is acked should be correct now
|
|
|
|
* Check for NUMDUPACK
|
|
|
|
*/
|
2008-09-04 07:30:19 +02:00
|
|
|
seqp = hctx->seqt;
|
|
|
|
while (before48(seqp->ccid2s_seq, hctx->high_ack)) {
|
2006-11-16 17:28:40 +01:00
|
|
|
seqp = seqp->ccid2s_next;
|
2008-09-04 07:30:19 +02:00
|
|
|
if (seqp == hctx->seqh) {
|
|
|
|
seqp = hctx->seqh->ccid2s_prev;
|
2006-11-16 17:28:40 +01:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2006-03-21 02:41:47 +01:00
|
|
|
done = 0;
|
|
|
|
while (1) {
|
|
|
|
if (seqp->ccid2s_acked) {
|
|
|
|
done++;
|
2007-11-25 01:04:35 +01:00
|
|
|
if (done == NUMDUPACK)
|
2006-03-21 02:41:47 +01:00
|
|
|
break;
|
|
|
|
}
|
2008-09-04 07:30:19 +02:00
|
|
|
if (seqp == hctx->seqt)
|
2006-03-21 02:41:47 +01:00
|
|
|
break;
|
|
|
|
seqp = seqp->ccid2s_prev;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* If there are at least 3 acknowledgements, anything unacknowledged
|
|
|
|
* below the last sequence number is considered lost
|
|
|
|
*/
|
2007-11-25 01:04:35 +01:00
|
|
|
if (done == NUMDUPACK) {
|
2006-03-21 02:41:47 +01:00
|
|
|
struct ccid2_seq *last_acked = seqp;
|
|
|
|
|
|
|
|
/* check for lost packets */
|
|
|
|
while (1) {
|
|
|
|
if (!seqp->ccid2s_acked) {
|
2006-09-19 22:14:43 +02:00
|
|
|
ccid2_pr_debug("Packet lost: %llu\n",
|
2006-10-30 01:03:30 +01:00
|
|
|
(unsigned long long)seqp->ccid2s_seq);
|
2006-09-19 22:14:43 +02:00
|
|
|
/* XXX need to traverse from tail -> head in
|
|
|
|
* order to detect multiple congestion events in
|
|
|
|
* one ack vector.
|
|
|
|
*/
|
2007-11-25 00:40:24 +01:00
|
|
|
ccid2_congestion_event(sk, seqp);
|
2008-09-04 07:30:19 +02:00
|
|
|
hctx->pipe--;
|
2006-03-21 02:41:47 +01:00
|
|
|
}
|
2008-09-04 07:30:19 +02:00
|
|
|
if (seqp == hctx->seqt)
|
2006-03-21 02:41:47 +01:00
|
|
|
break;
|
|
|
|
seqp = seqp->ccid2s_prev;
|
|
|
|
}
|
|
|
|
|
2008-09-04 07:30:19 +02:00
|
|
|
hctx->seqt = last_acked;
|
2006-03-21 02:41:47 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/* trim acked packets in tail */
|
2008-09-04 07:30:19 +02:00
|
|
|
while (hctx->seqt != hctx->seqh) {
|
|
|
|
if (!hctx->seqt->ccid2s_acked)
|
2006-03-21 02:41:47 +01:00
|
|
|
break;
|
|
|
|
|
2008-09-04 07:30:19 +02:00
|
|
|
hctx->seqt = hctx->seqt->ccid2s_next;
|
2006-03-21 02:41:47 +01:00
|
|
|
}
|
|
|
|
|
2008-09-04 07:30:19 +02:00
|
|
|
/* restart RTO timer if not all outstanding data has been acked */
|
|
|
|
if (hctx->pipe == 0)
|
|
|
|
sk_stop_timer(sk, &hctx->rtotimer);
|
|
|
|
else
|
dccp ccid-2: Replace broken RTT estimator with better algorithm
The current CCID-2 RTT estimator code is in parts broken and lags behind the
suggestions in RFC2988 of using scaled variants for SRTT/RTTVAR.
That code is replaced by the present patch, which reuses the Linux TCP RTT
estimator code - reasons for this code duplication are given below.
Further details:
----------------
1. The minimum RTO of previously one second has been replaced with TCP's, since
RFC4341, sec. 5 says that the minimum of 1 sec. (suggested in RFC2988, 2.4)
is not necessary. Instead, the TCP_RTO_MIN is used, which agrees with DCCP's
concept of a default RTT (RFC 4340, 3.4).
2. The maximum RTO has been set to DCCP_RTO_MAX (64 sec), which agrees with
RFC2988, (2.5).
3. De-inlined the function ccid2_new_ack().
4. Added a FIXME: the RTT is sampled several times per Ack Vector, which will
give the wrong estimate. It should be replaced with one sample per Ack.
However, at the moment this can not be resolved easily, since
- it depends on TX history code (which also needs some work),
- the cleanest solution is not to use the `sent' time at all (saves 4 bytes
per entry) and use DCCP timestamps / elapsed time to estimated the RTT,
which however is non-trivial to get right (but needs to be done).
Reasons for reusing the Linux TCP estimator algorithm:
------------------------------------------------------
Some time was spent to find a better alternative, using basic RFC2988 as a first
step. Further analysis and experimentation showed that the Linux TCP RTO
estimator is superior to a basic RFC2988 implementation. A summary is on
http://www.erg.abdn.ac.uk/users/gerrit/dccp/notes/ccid2/rto_estimator/
In addition, this estimator fared well in a recent empirical evaluation:
Rewaskar, Sushant, Jasleen Kaur and F. Donelson Smith.
A Performance Study of Loss Detection/Recovery in Real-world TCP
Implementations. Proceedings of 15th IEEE International
Conference on Network Protocols (ICNP-07). 2007.
Thus there is significant benefit in reusing the existing TCP code.
Signed-off-by: Gerrit Renker <gerrit@erg.abdn.ac.uk>
2008-09-04 07:30:19 +02:00
|
|
|
sk_reset_timer(sk, &hctx->rtotimer, jiffies + hctx->rto);
|
2008-09-04 07:30:19 +02:00
|
|
|
done:
|
2008-09-04 07:30:19 +02:00
|
|
|
/* check if incoming Acks allow pending packets to be sent */
|
|
|
|
if (sender_was_blocked && !ccid2_cwnd_network_limited(hctx))
|
|
|
|
tasklet_schedule(&dccp_sk(sk)->dccps_xmitlet);
|
2008-09-04 07:30:19 +02:00
|
|
|
dccp_ackvec_parsed_cleanup(&hctx->av_chunks);
|
2006-03-21 02:41:47 +01:00
|
|
|
}
|
|
|
|
|
2006-03-21 04:21:44 +01:00
|
|
|
static int ccid2_hc_tx_init(struct ccid *ccid, struct sock *sk)
|
2006-03-21 02:41:47 +01:00
|
|
|
{
|
2007-02-09 15:24:38 +01:00
|
|
|
struct ccid2_hc_tx_sock *hctx = ccid_priv(ccid);
|
2007-11-25 00:44:30 +01:00
|
|
|
struct dccp_sock *dp = dccp_sk(sk);
|
|
|
|
u32 max_ratio;
|
2006-03-21 02:41:47 +01:00
|
|
|
|
2007-11-25 00:44:30 +01:00
|
|
|
/* RFC 4341, 5: initialise ssthresh to arbitrarily high (max) value */
|
2008-09-04 07:30:19 +02:00
|
|
|
hctx->ssthresh = ~0U;
|
2006-03-21 02:41:47 +01:00
|
|
|
|
2008-09-04 07:30:19 +02:00
|
|
|
/* Use larger initial windows (RFC 3390, rfc2581bis) */
|
|
|
|
hctx->cwnd = rfc3390_bytes_to_packets(dp->dccps_mss_cache);
|
2007-11-25 00:44:30 +01:00
|
|
|
|
|
|
|
/* Make sure that Ack Ratio is enabled and within bounds. */
|
2008-09-04 07:30:19 +02:00
|
|
|
max_ratio = DIV_ROUND_UP(hctx->cwnd, 2);
|
2007-11-25 00:44:30 +01:00
|
|
|
if (dp->dccps_l_ack_ratio == 0 || dp->dccps_l_ack_ratio > max_ratio)
|
|
|
|
dp->dccps_l_ack_ratio = max_ratio;
|
|
|
|
|
2006-03-21 02:41:47 +01:00
|
|
|
/* XXX init ~ to window size... */
|
2007-10-04 23:41:00 +02:00
|
|
|
if (ccid2_hc_tx_alloc_seq(hctx))
|
2006-03-21 02:41:47 +01:00
|
|
|
return -ENOMEM;
|
2006-03-21 04:21:44 +01:00
|
|
|
|
dccp ccid-2: Replace broken RTT estimator with better algorithm
The current CCID-2 RTT estimator code is in parts broken and lags behind the
suggestions in RFC2988 of using scaled variants for SRTT/RTTVAR.
That code is replaced by the present patch, which reuses the Linux TCP RTT
estimator code - reasons for this code duplication are given below.
Further details:
----------------
1. The minimum RTO of previously one second has been replaced with TCP's, since
RFC4341, sec. 5 says that the minimum of 1 sec. (suggested in RFC2988, 2.4)
is not necessary. Instead, the TCP_RTO_MIN is used, which agrees with DCCP's
concept of a default RTT (RFC 4340, 3.4).
2. The maximum RTO has been set to DCCP_RTO_MAX (64 sec), which agrees with
RFC2988, (2.5).
3. De-inlined the function ccid2_new_ack().
4. Added a FIXME: the RTT is sampled several times per Ack Vector, which will
give the wrong estimate. It should be replaced with one sample per Ack.
However, at the moment this can not be resolved easily, since
- it depends on TX history code (which also needs some work),
- the cleanest solution is not to use the `sent' time at all (saves 4 bytes
per entry) and use DCCP timestamps / elapsed time to estimated the RTT,
which however is non-trivial to get right (but needs to be done).
Reasons for reusing the Linux TCP estimator algorithm:
------------------------------------------------------
Some time was spent to find a better alternative, using basic RFC2988 as a first
step. Further analysis and experimentation showed that the Linux TCP RTO
estimator is superior to a basic RFC2988 implementation. A summary is on
http://www.erg.abdn.ac.uk/users/gerrit/dccp/notes/ccid2/rto_estimator/
In addition, this estimator fared well in a recent empirical evaluation:
Rewaskar, Sushant, Jasleen Kaur and F. Donelson Smith.
A Performance Study of Loss Detection/Recovery in Real-world TCP
Implementations. Proceedings of 15th IEEE International
Conference on Network Protocols (ICNP-07). 2007.
Thus there is significant benefit in reusing the existing TCP code.
Signed-off-by: Gerrit Renker <gerrit@erg.abdn.ac.uk>
2008-09-04 07:30:19 +02:00
|
|
|
hctx->rto = DCCP_TIMEOUT_INIT;
|
2008-09-04 07:30:19 +02:00
|
|
|
hctx->rpdupack = -1;
|
|
|
|
hctx->last_cong = jiffies;
|
|
|
|
setup_timer(&hctx->rtotimer, ccid2_hc_tx_rto_expire, (unsigned long)sk);
|
2008-09-04 07:30:19 +02:00
|
|
|
INIT_LIST_HEAD(&hctx->av_chunks);
|
2006-03-21 02:41:47 +01:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void ccid2_hc_tx_exit(struct sock *sk)
|
|
|
|
{
|
2007-02-09 15:24:38 +01:00
|
|
|
struct ccid2_hc_tx_sock *hctx = ccid2_hc_tx_sk(sk);
|
2006-09-19 22:13:37 +02:00
|
|
|
int i;
|
2006-03-21 02:41:47 +01:00
|
|
|
|
2008-09-04 07:30:19 +02:00
|
|
|
sk_stop_timer(sk, &hctx->rtotimer);
|
2006-09-19 22:13:37 +02:00
|
|
|
|
2008-09-04 07:30:19 +02:00
|
|
|
for (i = 0; i < hctx->seqbufc; i++)
|
|
|
|
kfree(hctx->seqbuf[i]);
|
|
|
|
hctx->seqbufc = 0;
|
2006-03-21 02:41:47 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
static void ccid2_hc_rx_packet_recv(struct sock *sk, struct sk_buff *skb)
|
|
|
|
{
|
|
|
|
const struct dccp_sock *dp = dccp_sk(sk);
|
|
|
|
struct ccid2_hc_rx_sock *hcrx = ccid2_hc_rx_sk(sk);
|
|
|
|
|
|
|
|
switch (DCCP_SKB_CB(skb)->dccpd_type) {
|
|
|
|
case DCCP_PKT_DATA:
|
|
|
|
case DCCP_PKT_DATAACK:
|
2008-09-04 07:30:19 +02:00
|
|
|
hcrx->data++;
|
|
|
|
if (hcrx->data >= dp->dccps_r_ack_ratio) {
|
2006-03-21 02:41:47 +01:00
|
|
|
dccp_send_ack(sk);
|
2008-09-04 07:30:19 +02:00
|
|
|
hcrx->data = 0;
|
2006-03-21 02:41:47 +01:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-03-21 04:21:44 +01:00
|
|
|
static struct ccid_operations ccid2 = {
|
2008-09-04 07:30:19 +02:00
|
|
|
.ccid_id = DCCPC_CCID2,
|
|
|
|
.ccid_name = "TCP-like",
|
|
|
|
.ccid_owner = THIS_MODULE,
|
|
|
|
.ccid_hc_tx_obj_size = sizeof(struct ccid2_hc_tx_sock),
|
|
|
|
.ccid_hc_tx_init = ccid2_hc_tx_init,
|
|
|
|
.ccid_hc_tx_exit = ccid2_hc_tx_exit,
|
|
|
|
.ccid_hc_tx_send_packet = ccid2_hc_tx_send_packet,
|
|
|
|
.ccid_hc_tx_packet_sent = ccid2_hc_tx_packet_sent,
|
|
|
|
.ccid_hc_tx_parse_options = ccid2_hc_tx_parse_options,
|
|
|
|
.ccid_hc_tx_packet_recv = ccid2_hc_tx_packet_recv,
|
|
|
|
.ccid_hc_rx_obj_size = sizeof(struct ccid2_hc_rx_sock),
|
|
|
|
.ccid_hc_rx_packet_recv = ccid2_hc_rx_packet_recv,
|
2006-03-21 02:41:47 +01:00
|
|
|
};
|
|
|
|
|
2006-11-20 21:26:03 +01:00
|
|
|
#ifdef CONFIG_IP_DCCP_CCID2_DEBUG
|
2008-08-23 13:28:27 +02:00
|
|
|
module_param(ccid2_debug, bool, 0644);
|
2006-03-21 02:41:47 +01:00
|
|
|
MODULE_PARM_DESC(ccid2_debug, "Enable debug messages");
|
2006-11-20 21:26:03 +01:00
|
|
|
#endif
|
2006-03-21 02:41:47 +01:00
|
|
|
|
|
|
|
static __init int ccid2_module_init(void)
|
|
|
|
{
|
|
|
|
return ccid_register(&ccid2);
|
|
|
|
}
|
|
|
|
module_init(ccid2_module_init);
|
|
|
|
|
|
|
|
static __exit void ccid2_module_exit(void)
|
|
|
|
{
|
|
|
|
ccid_unregister(&ccid2);
|
|
|
|
}
|
|
|
|
module_exit(ccid2_module_exit);
|
|
|
|
|
|
|
|
MODULE_AUTHOR("Andrea Bittau <a.bittau@cs.ucl.ac.uk>");
|
2006-03-21 07:05:37 +01:00
|
|
|
MODULE_DESCRIPTION("DCCP TCP-Like (CCID2) CCID");
|
2006-03-21 02:41:47 +01:00
|
|
|
MODULE_LICENSE("GPL");
|
|
|
|
MODULE_ALIAS("net-dccp-ccid-2");
|