[TCP]: Add pluggable congestion control algorithm infrastructure.
Stephen Hemminger [Thu, 23 Jun 2005 19:19:55 +0000 (12:19 -0700)]
Allow TCP to have multiple pluggable congestion control algorithms.
Algorithms are defined by a set of operations and can be built in
or modules.  The legacy "new RENO" algorithm is used as a starting
point and fallback.

Signed-off-by: Stephen Hemminger <shemminger@osdl.org>
Signed-off-by: David S. Miller <davem@davemloft.net>

13 files changed:
include/linux/sysctl.h
include/linux/tcp.h
include/net/tcp.h
net/ipv4/Makefile
net/ipv4/sysctl_net_ipv4.c
net/ipv4/tcp.c
net/ipv4/tcp_cong.c [new file with mode: 0644]
net/ipv4/tcp_diag.c
net/ipv4/tcp_input.c
net/ipv4/tcp_ipv4.c
net/ipv4/tcp_minisocks.c
net/ipv4/tcp_output.c
net/ipv6/tcp_ipv6.c

index 614e939..72965bf 100644 (file)
@@ -333,21 +333,14 @@ enum
        NET_TCP_FRTO=92,
        NET_TCP_LOW_LATENCY=93,
        NET_IPV4_IPFRAG_SECRET_INTERVAL=94,
-       NET_TCP_WESTWOOD=95,
        NET_IPV4_IGMP_MAX_MSF=96,
        NET_TCP_NO_METRICS_SAVE=97,
-       NET_TCP_VEGAS=98,
-       NET_TCP_VEGAS_ALPHA=99,
-       NET_TCP_VEGAS_BETA=100,
-       NET_TCP_VEGAS_GAMMA=101,
-       NET_TCP_BIC=102,
-       NET_TCP_BIC_FAST_CONVERGENCE=103,
-       NET_TCP_BIC_LOW_WINDOW=104,
        NET_TCP_DEFAULT_WIN_SCALE=105,
        NET_TCP_MODERATE_RCVBUF=106,
        NET_TCP_TSO_WIN_DIVISOR=107,
        NET_TCP_BIC_BETA=108,
        NET_IPV4_ICMP_ERRORS_USE_INBOUND_IFADDR=109,
+       NET_TCP_CONG_CONTROL=110,
 };
 
 enum {
index 97a7c9e..3ea75dd 100644 (file)
@@ -203,13 +203,6 @@ struct tcp_sack_block {
        __u32   end_seq;
 };
 
-enum tcp_congestion_algo {
-       TCP_RENO=0,
-       TCP_VEGAS,
-       TCP_WESTWOOD,
-       TCP_BIC,
-};
-
 struct tcp_options_received {
 /*     PAWS/RTTM data  */
        long    ts_recent_stamp;/* Time we stored ts_recent (for aging) */
@@ -305,7 +298,7 @@ struct tcp_sock {
        __u8    reordering;     /* Packet reordering metric.            */
        __u8    frto_counter;   /* Number of new acks after RTO */
 
-       __u8    adv_cong;       /* Using Vegas, Westwood, or BIC */
+       __u8    unused;
        __u8    defer_accept;   /* User waits for some data after accept() */
 
 /* RTT measurement */
@@ -401,37 +394,10 @@ struct tcp_sock {
                __u32   time;
        } rcvq_space;
 
-/* TCP Westwood structure */
-        struct {
-                __u32    bw_ns_est;        /* first bandwidth estimation..not too smoothed 8) */
-                __u32    bw_est;           /* bandwidth estimate */
-                __u32    rtt_win_sx;       /* here starts a new evaluation... */
-                __u32    bk;
-                __u32    snd_una;          /* used for evaluating the number of acked bytes */
-                __u32    cumul_ack;
-                __u32    accounted;
-                __u32    rtt;
-                __u32    rtt_min;          /* minimum observed RTT */
-        } westwood;
-
-/* Vegas variables */
-       struct {
-               __u32   beg_snd_nxt;    /* right edge during last RTT */
-               __u32   beg_snd_una;    /* left edge  during last RTT */
-               __u32   beg_snd_cwnd;   /* saves the size of the cwnd */
-               __u8    doing_vegas_now;/* if true, do vegas for this RTT */
-               __u16   cntRTT;         /* # of RTTs measured within last RTT */
-               __u32   minRTT;         /* min of RTTs measured within last RTT (in usec) */
-               __u32   baseRTT;        /* the min of all Vegas RTT measurements seen (in usec) */
-       } vegas;
-
-       /* BI TCP Parameters */
-       struct {
-               __u32   cnt;            /* increase cwnd by 1 after this number of ACKs */
-               __u32   last_max_cwnd;  /* last maximium snd_cwnd */
-               __u32   last_cwnd;      /* the last snd_cwnd */
-               __u32   last_stamp;     /* time when updated last_cwnd */
-       } bictcp;
+       /* Pluggable TCP congestion control hook */
+       struct tcp_congestion_ops *ca_ops;
+       u32     ca_priv[16];
+#define TCP_CA_PRIV_SIZE       (16*sizeof(u32))
 };
 
 static inline struct tcp_sock *tcp_sk(const struct sock *sk)
@@ -439,6 +405,11 @@ static inline struct tcp_sock *tcp_sk(const struct sock *sk)
        return (struct tcp_sock *)sk;
 }
 
+static inline void *tcp_ca(const struct tcp_sock *tp)
+{
+       return (void *) tp->ca_priv;
+}
+
 #endif
 
 #endif /* _LINUX_TCP_H */
index f730935..e427cf3 100644 (file)
@@ -505,25 +505,6 @@ static __inline__ int tcp_sk_listen_hashfn(struct sock *sk)
 #else
 # define TCP_TW_RECYCLE_TICK (12+2-TCP_TW_RECYCLE_SLOTS_LOG)
 #endif
-
-#define BICTCP_BETA_SCALE    1024      /* Scale factor beta calculation
-                                        * max_cwnd = snd_cwnd * beta
-                                        */
-#define BICTCP_MAX_INCREMENT 32                /*
-                                        * Limit on the amount of
-                                        * increment allowed during
-                                        * binary search.
-                                        */
-#define BICTCP_FUNC_OF_MIN_INCR 11     /*
-                                        * log(B/Smin)/log(B/(B-1))+1,
-                                        * Smin:min increment
-                                        * B:log factor
-                                        */
-#define BICTCP_B               4        /*
-                                         * In binary search,
-                                         * go to point (max+min)/N
-                                         */
-
 /*
  *     TCP option
  */
@@ -596,16 +577,7 @@ extern int sysctl_tcp_adv_win_scale;
 extern int sysctl_tcp_tw_reuse;
 extern int sysctl_tcp_frto;
 extern int sysctl_tcp_low_latency;
-extern int sysctl_tcp_westwood;
-extern int sysctl_tcp_vegas_cong_avoid;
-extern int sysctl_tcp_vegas_alpha;
-extern int sysctl_tcp_vegas_beta;
-extern int sysctl_tcp_vegas_gamma;
 extern int sysctl_tcp_nometrics_save;
-extern int sysctl_tcp_bic;
-extern int sysctl_tcp_bic_fast_convergence;
-extern int sysctl_tcp_bic_low_window;
-extern int sysctl_tcp_bic_beta;
 extern int sysctl_tcp_moderate_rcvbuf;
 extern int sysctl_tcp_tso_win_divisor;
 
@@ -1136,6 +1108,80 @@ static inline void tcp_packets_out_dec(struct tcp_sock *tp,
        tp->packets_out -= tcp_skb_pcount(skb);
 }
 
+/* Events passed to congestion control interface */
+enum tcp_ca_event {
+       CA_EVENT_TX_START,      /* first transmit when no packets in flight */
+       CA_EVENT_CWND_RESTART,  /* congestion window restart */
+       CA_EVENT_COMPLETE_CWR,  /* end of congestion recovery */
+       CA_EVENT_FRTO,          /* fast recovery timeout */
+       CA_EVENT_LOSS,          /* loss timeout */
+       CA_EVENT_FAST_ACK,      /* in sequence ack */
+       CA_EVENT_SLOW_ACK,      /* other ack */
+};
+
+/*
+ * Interface for adding new TCP congestion control handlers
+ */
+#define TCP_CA_NAME_MAX        16
+struct tcp_congestion_ops {
+       struct list_head        list;
+
+       /* initialize private data (optional) */
+       void (*init)(struct tcp_sock *tp);
+       /* cleanup private data  (optional) */
+       void (*release)(struct tcp_sock *tp);
+
+       /* return slow start threshold (required) */
+       u32 (*ssthresh)(struct tcp_sock *tp);
+       /* lower bound for congestion window (optional) */
+       u32 (*min_cwnd)(struct tcp_sock *tp);
+       /* do new cwnd calculation (required) */
+       void (*cong_avoid)(struct tcp_sock *tp, u32 ack,
+                          u32 rtt, u32 in_flight, int good_ack);
+       /* round trip time sample per acked packet (optional) */
+       void (*rtt_sample)(struct tcp_sock *tp, u32 usrtt);
+       /* call before changing ca_state (optional) */
+       void (*set_state)(struct tcp_sock *tp, u8 new_state);
+       /* call when cwnd event occurs (optional) */
+       void (*cwnd_event)(struct tcp_sock *tp, enum tcp_ca_event ev);
+       /* new value of cwnd after loss (optional) */
+       u32  (*undo_cwnd)(struct tcp_sock *tp);
+       /* hook for packet ack accounting (optional) */
+       void (*pkts_acked)(struct tcp_sock *tp, u32 num_acked);
+       /* get info for tcp_diag (optional) */
+       void (*get_info)(struct tcp_sock *tp, u32 ext, struct sk_buff *skb);
+
+       char            name[TCP_CA_NAME_MAX];
+       struct module   *owner;
+};
+
+extern int tcp_register_congestion_control(struct tcp_congestion_ops *type);
+extern void tcp_unregister_congestion_control(struct tcp_congestion_ops *type);
+
+extern void tcp_init_congestion_control(struct tcp_sock *tp);
+extern void tcp_cleanup_congestion_control(struct tcp_sock *tp);
+extern int tcp_set_default_congestion_control(const char *name);
+extern void tcp_get_default_congestion_control(char *name);
+
+extern struct tcp_congestion_ops tcp_reno;
+extern u32 tcp_reno_ssthresh(struct tcp_sock *tp);
+extern void tcp_reno_cong_avoid(struct tcp_sock *tp, u32 ack,
+                               u32 rtt, u32 in_flight, int flag);
+extern u32 tcp_reno_min_cwnd(struct tcp_sock *tp);
+
+static inline void tcp_set_ca_state(struct tcp_sock *tp, u8 ca_state)
+{
+       if (tp->ca_ops->set_state)
+               tp->ca_ops->set_state(tp, ca_state);
+       tp->ca_state = ca_state;
+}
+
+static inline void tcp_ca_event(struct tcp_sock *tp, enum tcp_ca_event event)
+{
+       if (tp->ca_ops->cwnd_event)
+               tp->ca_ops->cwnd_event(tp, event);
+}
+
 /* This determines how many packets are "in the network" to the best
  * of our knowledge.  In many cases it is conservative, but where
  * detailed information is available from the receiver (via SACK
@@ -1155,91 +1201,6 @@ static __inline__ unsigned int tcp_packets_in_flight(const struct tcp_sock *tp)
        return (tp->packets_out - tp->left_out + tp->retrans_out);
 }
 
-/*
- * Which congestion algorithim is in use on the connection.
- */
-#define tcp_is_vegas(__tp)     ((__tp)->adv_cong == TCP_VEGAS)
-#define tcp_is_westwood(__tp)  ((__tp)->adv_cong == TCP_WESTWOOD)
-#define tcp_is_bic(__tp)       ((__tp)->adv_cong == TCP_BIC)
-
-/* Recalculate snd_ssthresh, we want to set it to:
- *
- * Reno:
- *     one half the current congestion window, but no
- *     less than two segments
- *
- * BIC:
- *     behave like Reno until low_window is reached,
- *     then increase congestion window slowly
- */
-static inline __u32 tcp_recalc_ssthresh(struct tcp_sock *tp)
-{
-       if (tcp_is_bic(tp)) {
-               if (sysctl_tcp_bic_fast_convergence &&
-                   tp->snd_cwnd < tp->bictcp.last_max_cwnd)
-                       tp->bictcp.last_max_cwnd = (tp->snd_cwnd * 
-                                                   (BICTCP_BETA_SCALE
-                                                    + sysctl_tcp_bic_beta))
-                               / (2 * BICTCP_BETA_SCALE);
-               else
-                       tp->bictcp.last_max_cwnd = tp->snd_cwnd;
-
-               if (tp->snd_cwnd > sysctl_tcp_bic_low_window)
-                       return max((tp->snd_cwnd * sysctl_tcp_bic_beta)
-                                  / BICTCP_BETA_SCALE, 2U);
-       }
-
-       return max(tp->snd_cwnd >> 1U, 2U);
-}
-
-/* Stop taking Vegas samples for now. */
-#define tcp_vegas_disable(__tp)        ((__tp)->vegas.doing_vegas_now = 0)
-    
-static inline void tcp_vegas_enable(struct tcp_sock *tp)
-{
-       /* There are several situations when we must "re-start" Vegas:
-        *
-        *  o when a connection is established
-        *  o after an RTO
-        *  o after fast recovery
-        *  o when we send a packet and there is no outstanding
-        *    unacknowledged data (restarting an idle connection)
-        *
-        * In these circumstances we cannot do a Vegas calculation at the
-        * end of the first RTT, because any calculation we do is using
-        * stale info -- both the saved cwnd and congestion feedback are
-        * stale.
-        *
-        * Instead we must wait until the completion of an RTT during
-        * which we actually receive ACKs.
-        */
-    
-       /* Begin taking Vegas samples next time we send something. */
-       tp->vegas.doing_vegas_now = 1;
-     
-       /* Set the beginning of the next send window. */
-       tp->vegas.beg_snd_nxt = tp->snd_nxt;
-
-       tp->vegas.cntRTT = 0;
-       tp->vegas.minRTT = 0x7fffffff;
-}
-
-/* Should we be taking Vegas samples right now? */
-#define tcp_vegas_enabled(__tp)        ((__tp)->vegas.doing_vegas_now)
-
-extern void tcp_ca_init(struct tcp_sock *tp);
-
-static inline void tcp_set_ca_state(struct tcp_sock *tp, u8 ca_state)
-{
-       if (tcp_is_vegas(tp)) {
-               if (ca_state == TCP_CA_Open) 
-                       tcp_vegas_enable(tp);
-               else
-                       tcp_vegas_disable(tp);
-       }
-       tp->ca_state = ca_state;
-}
-
 /* If cwnd > ssthresh, we may raise ssthresh to be half-way to cwnd.
  * The exception is rate halving phase, when cwnd is decreasing towards
  * ssthresh.
@@ -1288,7 +1249,7 @@ static inline void tcp_cwnd_validate(struct sock *sk, struct tcp_sock *tp)
 static inline void __tcp_enter_cwr(struct tcp_sock *tp)
 {
        tp->undo_marker = 0;
-       tp->snd_ssthresh = tcp_recalc_ssthresh(tp);
+       tp->snd_ssthresh = tp->ca_ops->ssthresh(tp);
        tp->snd_cwnd = min(tp->snd_cwnd,
                           tcp_packets_in_flight(tp) + 1U);
        tp->snd_cwnd_cnt = 0;
@@ -1876,52 +1837,4 @@ struct tcp_iter_state {
 extern int tcp_proc_register(struct tcp_seq_afinfo *afinfo);
 extern void tcp_proc_unregister(struct tcp_seq_afinfo *afinfo);
 
-/* TCP Westwood functions and constants */
-
-#define TCP_WESTWOOD_INIT_RTT  (20*HZ)           /* maybe too conservative?! */
-#define TCP_WESTWOOD_RTT_MIN   (HZ/20)           /* 50ms */
-
-static inline void tcp_westwood_update_rtt(struct tcp_sock *tp, __u32 rtt_seq)
-{
-        if (tcp_is_westwood(tp))
-                tp->westwood.rtt = rtt_seq;
-}
-
-static inline __u32 __tcp_westwood_bw_rttmin(const struct tcp_sock *tp)
-{
-        return max((tp->westwood.bw_est) * (tp->westwood.rtt_min) /
-                  (__u32) (tp->mss_cache_std),
-                  2U);
-}
-
-static inline __u32 tcp_westwood_bw_rttmin(const struct tcp_sock *tp)
-{
-       return tcp_is_westwood(tp) ? __tcp_westwood_bw_rttmin(tp) : 0;
-}
-
-static inline int tcp_westwood_ssthresh(struct tcp_sock *tp)
-{
-       __u32 ssthresh = 0;
-
-       if (tcp_is_westwood(tp)) {
-               ssthresh = __tcp_westwood_bw_rttmin(tp);
-               if (ssthresh)
-                       tp->snd_ssthresh = ssthresh;  
-       }
-
-       return (ssthresh != 0);
-}
-
-static inline int tcp_westwood_cwnd(struct tcp_sock *tp)
-{
-       __u32 cwnd = 0;
-
-       if (tcp_is_westwood(tp)) {
-               cwnd = __tcp_westwood_bw_rttmin(tp);
-               if (cwnd)
-                       tp->snd_cwnd = cwnd;
-       }
-
-       return (cwnd != 0);
-}
 #endif /* _TCP_H */
index 65d57d8..89c0b4c 100644 (file)
@@ -5,7 +5,8 @@
 obj-y     := utils.o route.o inetpeer.o protocol.o \
             ip_input.o ip_fragment.o ip_forward.o ip_options.o \
             ip_output.o ip_sockglue.o \
-            tcp.o tcp_input.o tcp_output.o tcp_timer.o tcp_ipv4.o tcp_minisocks.o \
+            tcp.o tcp_input.o tcp_output.o tcp_timer.o tcp_ipv4.o \
+            tcp_minisocks.o tcp_cong.o \
             datagram.o raw.o udp.o arp.o icmp.o devinet.o af_inet.o igmp.o \
             sysctl_net_ipv4.o fib_frontend.o fib_semantics.o
 
index 23068bd..e328945 100644 (file)
@@ -118,6 +118,45 @@ static int ipv4_sysctl_forward_strategy(ctl_table *table,
        return 1;
 }
 
+static int proc_tcp_congestion_control(ctl_table *ctl, int write, struct file * filp,
+                                      void __user *buffer, size_t *lenp, loff_t *ppos)
+{
+       char val[TCP_CA_NAME_MAX];
+       ctl_table tbl = {
+               .data = val,
+               .maxlen = TCP_CA_NAME_MAX,
+       };
+       int ret;
+
+       tcp_get_default_congestion_control(val);
+
+       ret = proc_dostring(&tbl, write, filp, buffer, lenp, ppos);
+       if (write && ret == 0)
+               ret = tcp_set_default_congestion_control(val);
+       return ret;
+}
+
+int sysctl_tcp_congestion_control(ctl_table *table, int __user *name, int nlen,
+                                 void __user *oldval, size_t __user *oldlenp,
+                                 void __user *newval, size_t newlen,
+                                 void **context)
+{
+       char val[TCP_CA_NAME_MAX];
+       ctl_table tbl = {
+               .data = val,
+               .maxlen = TCP_CA_NAME_MAX,
+       };
+       int ret;
+
+       tcp_get_default_congestion_control(val);
+       ret = sysctl_string(&tbl, name, nlen, oldval, oldlenp, newval, newlen,
+                           context);
+       if (ret == 0 && newval && newlen)
+               ret = tcp_set_default_congestion_control(val);
+       return ret;
+}
+
+
 ctl_table ipv4_table[] = {
         {
                .ctl_name       = NET_IPV4_TCP_TIMESTAMPS,
@@ -612,70 +651,6 @@ ctl_table ipv4_table[] = {
                .proc_handler   = &proc_dointvec,
        },
        {
-               .ctl_name       = NET_TCP_WESTWOOD, 
-               .procname       = "tcp_westwood",
-               .data           = &sysctl_tcp_westwood,
-               .maxlen         = sizeof(int),
-               .mode           = 0644,
-               .proc_handler   = &proc_dointvec,
-       },
-       {
-               .ctl_name       = NET_TCP_VEGAS,
-               .procname       = "tcp_vegas_cong_avoid",
-               .data           = &sysctl_tcp_vegas_cong_avoid,
-               .maxlen         = sizeof(int),
-               .mode           = 0644,
-               .proc_handler   = &proc_dointvec,
-       },
-       {
-               .ctl_name       = NET_TCP_VEGAS_ALPHA,
-               .procname       = "tcp_vegas_alpha",
-               .data           = &sysctl_tcp_vegas_alpha,
-               .maxlen         = sizeof(int),
-               .mode           = 0644,
-               .proc_handler   = &proc_dointvec,
-       },
-       {
-               .ctl_name       = NET_TCP_VEGAS_BETA,
-               .procname       = "tcp_vegas_beta",
-               .data           = &sysctl_tcp_vegas_beta,
-               .maxlen         = sizeof(int),
-               .mode           = 0644,
-               .proc_handler   = &proc_dointvec,
-       },
-       {
-               .ctl_name       = NET_TCP_VEGAS_GAMMA,
-               .procname       = "tcp_vegas_gamma",
-               .data           = &sysctl_tcp_vegas_gamma,
-               .maxlen         = sizeof(int),
-               .mode           = 0644,
-               .proc_handler   = &proc_dointvec,
-       },
-       {
-               .ctl_name       = NET_TCP_BIC,
-               .procname       = "tcp_bic",
-               .data           = &sysctl_tcp_bic,
-               .maxlen         = sizeof(int),
-               .mode           = 0644,
-               .proc_handler   = &proc_dointvec,
-       },
-       {
-               .ctl_name       = NET_TCP_BIC_FAST_CONVERGENCE,
-               .procname       = "tcp_bic_fast_convergence",
-               .data           = &sysctl_tcp_bic_fast_convergence,
-               .maxlen         = sizeof(int),
-               .mode           = 0644,
-               .proc_handler   = &proc_dointvec,
-       },
-       {
-               .ctl_name       = NET_TCP_BIC_LOW_WINDOW,
-               .procname       = "tcp_bic_low_window",
-               .data           = &sysctl_tcp_bic_low_window,
-               .maxlen         = sizeof(int),
-               .mode           = 0644,
-               .proc_handler   = &proc_dointvec,
-       },
-       {
                .ctl_name       = NET_TCP_MODERATE_RCVBUF,
                .procname       = "tcp_moderate_rcvbuf",
                .data           = &sysctl_tcp_moderate_rcvbuf,
@@ -692,13 +667,14 @@ ctl_table ipv4_table[] = {
                .proc_handler   = &proc_dointvec,
        },
        {
-               .ctl_name       = NET_TCP_BIC_BETA,
-               .procname       = "tcp_bic_beta",
-               .data           = &sysctl_tcp_bic_beta,
-               .maxlen         = sizeof(int),
+               .ctl_name       = NET_TCP_CONG_CONTROL,
+               .procname       = "tcp_congestion_control",
                .mode           = 0644,
-               .proc_handler   = &proc_dointvec,
+               .maxlen         = TCP_CA_NAME_MAX,
+               .proc_handler   = &proc_tcp_congestion_control,
+               .strategy       = &sysctl_tcp_congestion_control,
        },
+
        { .ctl_name = 0 }
 };
 
index 674bbd8..f3dbc8d 100644 (file)
@@ -2333,6 +2333,8 @@ void __init tcp_init(void)
        printk(KERN_INFO "TCP: Hash tables configured "
               "(established %d bind %d)\n",
               tcp_ehash_size << 1, tcp_bhash_size);
+
+       tcp_register_congestion_control(&tcp_reno);
 }
 
 EXPORT_SYMBOL(tcp_accept);
diff --git a/net/ipv4/tcp_cong.c b/net/ipv4/tcp_cong.c
new file mode 100644 (file)
index 0000000..665394a
--- /dev/null
@@ -0,0 +1,195 @@
+/*
+ * Plugable TCP congestion control support and newReno
+ * congestion control.
+ * Based on ideas from I/O scheduler suport and Web100.
+ *
+ * Copyright (C) 2005 Stephen Hemminger <shemminger@osdl.org>
+ */
+
+#include <linux/config.h>
+#include <linux/module.h>
+#include <linux/mm.h>
+#include <linux/types.h>
+#include <linux/list.h>
+#include <net/tcp.h>
+
+static DEFINE_SPINLOCK(tcp_cong_list_lock);
+static LIST_HEAD(tcp_cong_list);
+
+/* Simple linear search, don't expect many entries! */
+static struct tcp_congestion_ops *tcp_ca_find(const char *name)
+{
+       struct tcp_congestion_ops *e;
+
+       list_for_each_entry(e, &tcp_cong_list, list) {
+               if (strcmp(e->name, name) == 0)
+                       return e;
+       }
+
+       return NULL;
+}
+
+/*
+ * Attach new congestion control algorthim to the list
+ * of available options.
+ */
+int tcp_register_congestion_control(struct tcp_congestion_ops *ca)
+{
+       int ret = 0;
+
+       /* all algorithms must implement ssthresh and cong_avoid ops */
+       if (!ca->ssthresh || !ca->cong_avoid || !ca->min_cwnd) {
+               printk(KERN_ERR "TCP %s does not implement required ops\n",
+                      ca->name);
+               return -EINVAL;
+       }
+
+       spin_lock(&tcp_cong_list_lock);
+       if (tcp_ca_find(ca->name)) {
+               printk(KERN_NOTICE "TCP %s already registered\n", ca->name);
+               ret = -EEXIST;
+       } else {
+               list_add_rcu(&ca->list, &tcp_cong_list);
+               printk(KERN_INFO "TCP %s registered\n", ca->name);
+       }
+       spin_unlock(&tcp_cong_list_lock);
+
+       return ret;
+}
+EXPORT_SYMBOL_GPL(tcp_register_congestion_control);
+
+/*
+ * Remove congestion control algorithm, called from
+ * the module's remove function.  Module ref counts are used
+ * to ensure that this can't be done till all sockets using
+ * that method are closed.
+ */
+void tcp_unregister_congestion_control(struct tcp_congestion_ops *ca)
+{
+       spin_lock(&tcp_cong_list_lock);
+       list_del_rcu(&ca->list);
+       spin_unlock(&tcp_cong_list_lock);
+}
+EXPORT_SYMBOL_GPL(tcp_unregister_congestion_control);
+
+/* Assign choice of congestion control. */
+void tcp_init_congestion_control(struct tcp_sock *tp)
+{
+       struct tcp_congestion_ops *ca;
+
+       rcu_read_lock();
+       list_for_each_entry_rcu(ca, &tcp_cong_list, list) {
+               if (try_module_get(ca->owner)) {
+                       tp->ca_ops = ca;
+                       break;
+               }
+
+       }
+       rcu_read_unlock();
+
+       if (tp->ca_ops->init)
+               tp->ca_ops->init(tp);
+}
+
+/* Manage refcounts on socket close. */
+void tcp_cleanup_congestion_control(struct tcp_sock *tp)
+{
+       if (tp->ca_ops->release)
+               tp->ca_ops->release(tp);
+       module_put(tp->ca_ops->owner);
+}
+
+/* Used by sysctl to change default congestion control */
+int tcp_set_default_congestion_control(const char *name)
+{
+       struct tcp_congestion_ops *ca;
+       int ret = -ENOENT;
+
+       spin_lock(&tcp_cong_list_lock);
+       ca = tcp_ca_find(name);
+#ifdef CONFIG_KMOD
+       if (!ca) {
+               spin_unlock(&tcp_cong_list_lock);
+
+               request_module("tcp_%s", name);
+               spin_lock(&tcp_cong_list_lock);
+               ca = tcp_ca_find(name);
+       }
+#endif
+
+       if (ca) {
+               list_move(&ca->list, &tcp_cong_list);
+               ret = 0;
+       }
+       spin_unlock(&tcp_cong_list_lock);
+
+       return ret;
+}
+
+/* Get current default congestion control */
+void tcp_get_default_congestion_control(char *name)
+{
+       struct tcp_congestion_ops *ca;
+       /* We will always have reno... */
+       BUG_ON(list_empty(&tcp_cong_list));
+
+       rcu_read_lock();
+       ca = list_entry(tcp_cong_list.next, struct tcp_congestion_ops, list);
+       strncpy(name, ca->name, TCP_CA_NAME_MAX);
+       rcu_read_unlock();
+}
+
+/*
+ * TCP Reno congestion control
+ * This is special case used for fallback as well.
+ */
+/* This is Jacobson's slow start and congestion avoidance.
+ * SIGCOMM '88, p. 328.
+ */
+void tcp_reno_cong_avoid(struct tcp_sock *tp, u32 ack, u32 rtt, u32 in_flight,
+                        int flag)
+{
+       if (in_flight < tp->snd_cwnd)
+               return;
+
+        if (tp->snd_cwnd <= tp->snd_ssthresh) {
+                /* In "safe" area, increase. */
+               if (tp->snd_cwnd < tp->snd_cwnd_clamp)
+                       tp->snd_cwnd++;
+       } else {
+                /* In dangerous area, increase slowly.
+                * In theory this is tp->snd_cwnd += 1 / tp->snd_cwnd
+                */
+               if (tp->snd_cwnd_cnt >= tp->snd_cwnd) {
+                       if (tp->snd_cwnd < tp->snd_cwnd_clamp)
+                               tp->snd_cwnd++;
+                       tp->snd_cwnd_cnt = 0;
+               } else
+                       tp->snd_cwnd_cnt++;
+       }
+}
+EXPORT_SYMBOL_GPL(tcp_reno_cong_avoid);
+
+/* Slow start threshold is half the congestion window (min 2) */
+u32 tcp_reno_ssthresh(struct tcp_sock *tp)
+{
+       return max(tp->snd_cwnd >> 1U, 2U);
+}
+EXPORT_SYMBOL_GPL(tcp_reno_ssthresh);
+
+/* Lower bound on congestion window. */
+u32 tcp_reno_min_cwnd(struct tcp_sock *tp)
+{
+       return tp->snd_ssthresh/2;
+}
+EXPORT_SYMBOL_GPL(tcp_reno_min_cwnd);
+
+struct tcp_congestion_ops tcp_reno = {
+       .name           = "reno",
+       .owner          = THIS_MODULE,
+       .ssthresh       = tcp_reno_ssthresh,
+       .cong_avoid     = tcp_reno_cong_avoid,
+       .min_cwnd       = tcp_reno_min_cwnd,
+};
+
+EXPORT_SYMBOL_GPL(tcp_reno);
index 634befc..867acc0 100644 (file)
@@ -42,7 +42,6 @@ struct tcpdiag_entry
 
 static struct sock *tcpnl;
 
-
 #define TCPDIAG_PUT(skb, attrtype, attrlen) \
 ({ int rtalen = RTA_LENGTH(attrlen);        \
    struct rtattr *rta;                      \
@@ -61,7 +60,6 @@ static int tcpdiag_fill(struct sk_buff *skb, struct sock *sk,
        struct nlmsghdr  *nlh;
        struct tcp_info  *info = NULL;
        struct tcpdiag_meminfo  *minfo = NULL;
-       struct tcpvegas_info *vinfo = NULL;
        unsigned char    *b = skb->tail;
 
        nlh = NLMSG_PUT(skb, pid, seq, TCPDIAG_GETSOCK, sizeof(*r));
@@ -73,9 +71,6 @@ static int tcpdiag_fill(struct sk_buff *skb, struct sock *sk,
                if (ext & (1<<(TCPDIAG_INFO-1)))
                        info = TCPDIAG_PUT(skb, TCPDIAG_INFO, sizeof(*info));
                
-               if ((tcp_is_westwood(tp) || tcp_is_vegas(tp))
-                   && (ext & (1<<(TCPDIAG_VEGASINFO-1))))
-                       vinfo = TCPDIAG_PUT(skb, TCPDIAG_VEGASINFO, sizeof(*vinfo));
        }
        r->tcpdiag_family = sk->sk_family;
        r->tcpdiag_state = sk->sk_state;
@@ -166,19 +161,8 @@ static int tcpdiag_fill(struct sk_buff *skb, struct sock *sk,
        if (info) 
                tcp_get_info(sk, info);
 
-       if (vinfo) {
-               if (tcp_is_vegas(tp)) {
-                       vinfo->tcpv_enabled = tp->vegas.doing_vegas_now;
-                       vinfo->tcpv_rttcnt = tp->vegas.cntRTT;
-                       vinfo->tcpv_rtt = jiffies_to_usecs(tp->vegas.baseRTT);
-                       vinfo->tcpv_minrtt = jiffies_to_usecs(tp->vegas.minRTT);
-               } else {
-                       vinfo->tcpv_enabled = 0;
-                       vinfo->tcpv_rttcnt = 0;
-                       vinfo->tcpv_rtt = jiffies_to_usecs(tp->westwood.rtt);
-                       vinfo->tcpv_minrtt = jiffies_to_usecs(tp->westwood.rtt_min);
-               }
-       }
+       if (sk->sk_state < TCP_TIME_WAIT && tp->ca_ops->get_info)
+               tp->ca_ops->get_info(tp, ext, skb);
 
        nlh->nlmsg_len = skb->tail - b;
        return skb->len;
index 5bad504..7bbbbc3 100644 (file)
@@ -61,7 +61,6 @@
  *             Panu Kuhlberg:          Experimental audit of TCP (re)transmission
  *                                     engine. Lots of bugs are found.
  *             Pasi Sarolahti:         F-RTO for dealing with spurious RTOs
- *             Angelo Dell'Aera:       TCP Westwood+ support
  */
 
 #include <linux/config.h>
@@ -88,23 +87,9 @@ int sysctl_tcp_rfc1337;
 int sysctl_tcp_max_orphans = NR_FILE;
 int sysctl_tcp_frto;
 int sysctl_tcp_nometrics_save;
-int sysctl_tcp_westwood;
-int sysctl_tcp_vegas_cong_avoid;
 
 int sysctl_tcp_moderate_rcvbuf = 1;
 
-/* Default values of the Vegas variables, in fixed-point representation
- * with V_PARAM_SHIFT bits to the right of the binary point.
- */
-#define V_PARAM_SHIFT 1
-int sysctl_tcp_vegas_alpha = 1<<V_PARAM_SHIFT;
-int sysctl_tcp_vegas_beta  = 3<<V_PARAM_SHIFT;
-int sysctl_tcp_vegas_gamma = 1<<V_PARAM_SHIFT;
-int sysctl_tcp_bic = 1;
-int sysctl_tcp_bic_fast_convergence = 1;
-int sysctl_tcp_bic_low_window = 14;
-int sysctl_tcp_bic_beta = 819;         /* = 819/1024 (BICTCP_BETA_SCALE) */
-
 #define FLAG_DATA              0x01 /* Incoming frame contained data.          */
 #define FLAG_WIN_UPDATE                0x02 /* Incoming ACK was a window update.       */
 #define FLAG_DATA_ACKED                0x04 /* This ACK acknowledged new data.         */
@@ -333,15 +318,6 @@ static void tcp_init_buffer_space(struct sock *sk)
        tp->snd_cwnd_stamp = tcp_time_stamp;
 }
 
-static void init_bictcp(struct tcp_sock *tp)
-{
-       tp->bictcp.cnt = 0;
-
-       tp->bictcp.last_max_cwnd = 0;
-       tp->bictcp.last_cwnd = 0;
-       tp->bictcp.last_stamp = 0;
-}
-
 /* 5. Recalculate window clamp after socket hit its memory bounds. */
 static void tcp_clamp_window(struct sock *sk, struct tcp_sock *tp)
 {
@@ -558,45 +534,6 @@ static void tcp_event_data_recv(struct sock *sk, struct tcp_sock *tp, struct sk_
                tcp_grow_window(sk, tp, skb);
 }
 
-/* When starting a new connection, pin down the current choice of 
- * congestion algorithm.
- */
-void tcp_ca_init(struct tcp_sock *tp)
-{
-       if (sysctl_tcp_westwood) 
-               tp->adv_cong = TCP_WESTWOOD;
-       else if (sysctl_tcp_bic)
-               tp->adv_cong = TCP_BIC;
-       else if (sysctl_tcp_vegas_cong_avoid) {
-               tp->adv_cong = TCP_VEGAS;
-               tp->vegas.baseRTT = 0x7fffffff;
-               tcp_vegas_enable(tp);
-       } 
-}
-
-/* Do RTT sampling needed for Vegas.
- * Basically we:
- *   o min-filter RTT samples from within an RTT to get the current
- *     propagation delay + queuing delay (we are min-filtering to try to
- *     avoid the effects of delayed ACKs)
- *   o min-filter RTT samples from a much longer window (forever for now)
- *     to find the propagation delay (baseRTT)
- */
-static inline void vegas_rtt_calc(struct tcp_sock *tp, __u32 rtt)
-{
-       __u32 vrtt = rtt + 1; /* Never allow zero rtt or baseRTT */
-
-       /* Filter to find propagation delay: */
-       if (vrtt < tp->vegas.baseRTT) 
-               tp->vegas.baseRTT = vrtt;
-
-       /* Find the min RTT during the last RTT to find
-        * the current prop. delay + queuing delay:
-        */
-       tp->vegas.minRTT = min(tp->vegas.minRTT, vrtt);
-       tp->vegas.cntRTT++;
-}
-
 /* Called to compute a smoothed rtt estimate. The data fed to this
  * routine either comes from timestamps, or from segments that were
  * known _not_ to have been retransmitted [see Karn/Partridge
@@ -606,13 +543,10 @@ static inline void vegas_rtt_calc(struct tcp_sock *tp, __u32 rtt)
  * To save cycles in the RFC 1323 implementation it was better to break
  * it up into three procedures. -- erics
  */
-static void tcp_rtt_estimator(struct tcp_sock *tp, __u32 mrtt)
+static void tcp_rtt_estimator(struct tcp_sock *tp, __u32 mrtt, u32 *usrtt)
 {
        long m = mrtt; /* RTT */
 
-       if (tcp_vegas_enabled(tp))
-               vegas_rtt_calc(tp, mrtt);
-
        /*      The following amusing code comes from Jacobson's
         *      article in SIGCOMM '88.  Note that rtt and mdev
         *      are scaled versions of rtt and mean deviation.
@@ -670,7 +604,8 @@ static void tcp_rtt_estimator(struct tcp_sock *tp, __u32 mrtt)
                tp->rtt_seq = tp->snd_nxt;
        }
 
-       tcp_westwood_update_rtt(tp, tp->srtt >> 3);
+       if (tp->ca_ops->rtt_sample)
+               tp->ca_ops->rtt_sample(tp, *usrtt);
 }
 
 /* Calculate rto without backoff.  This is the second half of Van Jacobson's
@@ -1185,8 +1120,8 @@ void tcp_enter_frto(struct sock *sk)
             tp->snd_una == tp->high_seq ||
             (tp->ca_state == TCP_CA_Loss && !tp->retransmits)) {
                tp->prior_ssthresh = tcp_current_ssthresh(tp);
-               if (!tcp_westwood_ssthresh(tp))
-                       tp->snd_ssthresh = tcp_recalc_ssthresh(tp);
+               tp->snd_ssthresh = tp->ca_ops->ssthresh(tp);
+               tcp_ca_event(tp, CA_EVENT_FRTO);
        }
 
        /* Have to clear retransmission markers here to keep the bookkeeping
@@ -1252,8 +1187,6 @@ static void tcp_enter_frto_loss(struct sock *sk)
        tcp_set_ca_state(tp, TCP_CA_Loss);
        tp->high_seq = tp->frto_highmark;
        TCP_ECN_queue_cwr(tp);
-
-       init_bictcp(tp);
 }
 
 void tcp_clear_retrans(struct tcp_sock *tp)
@@ -1283,7 +1216,8 @@ void tcp_enter_loss(struct sock *sk, int how)
        if (tp->ca_state <= TCP_CA_Disorder || tp->snd_una == tp->high_seq ||
            (tp->ca_state == TCP_CA_Loss && !tp->retransmits)) {
                tp->prior_ssthresh = tcp_current_ssthresh(tp);
-               tp->snd_ssthresh = tcp_recalc_ssthresh(tp);
+               tp->snd_ssthresh = tp->ca_ops->ssthresh(tp);
+               tcp_ca_event(tp, CA_EVENT_LOSS);
        }
        tp->snd_cwnd       = 1;
        tp->snd_cwnd_cnt   = 0;
@@ -1596,28 +1530,14 @@ static inline void tcp_moderate_cwnd(struct tcp_sock *tp)
 }
 
 /* Decrease cwnd each second ack. */
-
 static void tcp_cwnd_down(struct tcp_sock *tp)
 {
        int decr = tp->snd_cwnd_cnt + 1;
-       __u32 limit;
-
-       /*
-        * TCP Westwood
-        * Here limit is evaluated as BWestimation*RTTmin (for obtaining it
-        * in packets we use mss_cache). If sysctl_tcp_westwood is off
-        * tcp_westwood_bw_rttmin() returns 0. In such case snd_ssthresh is
-        * still used as usual. It prevents other strange cases in which
-        * BWE*RTTmin could assume value 0. It should not happen but...
-        */
-
-       if (!(limit = tcp_westwood_bw_rttmin(tp)))
-               limit = tp->snd_ssthresh/2;
 
        tp->snd_cwnd_cnt = decr&1;
        decr >>= 1;
 
-       if (decr && tp->snd_cwnd > limit)
+       if (decr && tp->snd_cwnd > tp->ca_ops->min_cwnd(tp))
                tp->snd_cwnd -= decr;
 
        tp->snd_cwnd = min(tp->snd_cwnd, tcp_packets_in_flight(tp)+1);
@@ -1654,8 +1574,8 @@ static void DBGUNDO(struct sock *sk, struct tcp_sock *tp, const char *msg)
 static void tcp_undo_cwr(struct tcp_sock *tp, int undo)
 {
        if (tp->prior_ssthresh) {
-               if (tcp_is_bic(tp))
-                       tp->snd_cwnd = max(tp->snd_cwnd, tp->bictcp.last_max_cwnd);
+               if (tp->ca_ops->undo_cwnd)
+                       tp->snd_cwnd = tp->ca_ops->undo_cwnd(tp);
                else
                        tp->snd_cwnd = max(tp->snd_cwnd, tp->snd_ssthresh<<1);
 
@@ -1767,11 +1687,9 @@ static int tcp_try_undo_loss(struct sock *sk, struct tcp_sock *tp)
 
 static inline void tcp_complete_cwr(struct tcp_sock *tp)
 {
-       if (tcp_westwood_cwnd(tp)) 
-               tp->snd_ssthresh = tp->snd_cwnd;
-       else
-               tp->snd_cwnd = min(tp->snd_cwnd, tp->snd_ssthresh);
+       tp->snd_cwnd = min(tp->snd_cwnd, tp->snd_ssthresh);
        tp->snd_cwnd_stamp = tcp_time_stamp;
+       tcp_ca_event(tp, CA_EVENT_COMPLETE_CWR);
 }
 
 static void tcp_try_to_open(struct sock *sk, struct tcp_sock *tp, int flag)
@@ -1946,7 +1864,7 @@ tcp_fastretrans_alert(struct sock *sk, u32 prior_snd_una,
                if (tp->ca_state < TCP_CA_CWR) {
                        if (!(flag&FLAG_ECE))
                                tp->prior_ssthresh = tcp_current_ssthresh(tp);
-                       tp->snd_ssthresh = tcp_recalc_ssthresh(tp);
+                       tp->snd_ssthresh = tp->ca_ops->ssthresh(tp);
                        TCP_ECN_queue_cwr(tp);
                }
 
@@ -1963,7 +1881,7 @@ tcp_fastretrans_alert(struct sock *sk, u32 prior_snd_una,
 /* Read draft-ietf-tcplw-high-performance before mucking
  * with this code. (Superceeds RFC1323)
  */
-static void tcp_ack_saw_tstamp(struct tcp_sock *tp, int flag)
+static void tcp_ack_saw_tstamp(struct tcp_sock *tp, u32 *usrtt, int flag)
 {
        __u32 seq_rtt;
 
@@ -1983,13 +1901,13 @@ static void tcp_ack_saw_tstamp(struct tcp_sock *tp, int flag)
         * in window is lost... Voila.                          --ANK (010210)
         */
        seq_rtt = tcp_time_stamp - tp->rx_opt.rcv_tsecr;
-       tcp_rtt_estimator(tp, seq_rtt);
+       tcp_rtt_estimator(tp, seq_rtt, usrtt);
        tcp_set_rto(tp);
        tp->backoff = 0;
        tcp_bound_rto(tp);
 }
 
-static void tcp_ack_no_tstamp(struct tcp_sock *tp, u32 seq_rtt, int flag)
+static void tcp_ack_no_tstamp(struct tcp_sock *tp, u32 seq_rtt, u32 *usrtt, int flag)
 {
        /* We don't have a timestamp. Can only use
         * packets that are not retransmitted to determine
@@ -2003,338 +1921,29 @@ static void tcp_ack_no_tstamp(struct tcp_sock *tp, u32 seq_rtt, int flag)
        if (flag & FLAG_RETRANS_DATA_ACKED)
                return;
 
-       tcp_rtt_estimator(tp, seq_rtt);
+       tcp_rtt_estimator(tp, seq_rtt, usrtt);
        tcp_set_rto(tp);
        tp->backoff = 0;
        tcp_bound_rto(tp);
 }
 
 static inline void tcp_ack_update_rtt(struct tcp_sock *tp,
-                                     int flag, s32 seq_rtt)
+                                     int flag, s32 seq_rtt, u32 *usrtt)
 {
        /* Note that peer MAY send zero echo. In this case it is ignored. (rfc1323) */
        if (tp->rx_opt.saw_tstamp && tp->rx_opt.rcv_tsecr)
-               tcp_ack_saw_tstamp(tp, flag);
+               tcp_ack_saw_tstamp(tp, usrtt, flag);
        else if (seq_rtt >= 0)
-               tcp_ack_no_tstamp(tp, seq_rtt, flag);
+               tcp_ack_no_tstamp(tp, seq_rtt, usrtt, flag);
 }
 
-/*
- * Compute congestion window to use.
- *
- * This is from the implementation of BICTCP in
- * Lison-Xu, Kahaled Harfoush, and Injog Rhee.
- *  "Binary Increase Congestion Control for Fast, Long Distance
- *  Networks" in InfoComm 2004
- * Available from:
- *  http://www.csc.ncsu.edu/faculty/rhee/export/bitcp.pdf
- *
- * Unless BIC is enabled and congestion window is large
- * this behaves the same as the original Reno.
- */
-static inline __u32 bictcp_cwnd(struct tcp_sock *tp)
-{
-       /* orignal Reno behaviour */
-       if (!tcp_is_bic(tp))
-               return tp->snd_cwnd;
-
-       if (tp->bictcp.last_cwnd == tp->snd_cwnd &&
-          (s32)(tcp_time_stamp - tp->bictcp.last_stamp) <= (HZ>>5))
-               return tp->bictcp.cnt;
-
-       tp->bictcp.last_cwnd = tp->snd_cwnd;
-       tp->bictcp.last_stamp = tcp_time_stamp;
-      
-       /* start off normal */
-       if (tp->snd_cwnd <= sysctl_tcp_bic_low_window)
-               tp->bictcp.cnt = tp->snd_cwnd;
-
-       /* binary increase */
-       else if (tp->snd_cwnd < tp->bictcp.last_max_cwnd) {
-               __u32   dist = (tp->bictcp.last_max_cwnd - tp->snd_cwnd)
-                       / BICTCP_B;
-
-               if (dist > BICTCP_MAX_INCREMENT)
-                       /* linear increase */
-                       tp->bictcp.cnt = tp->snd_cwnd / BICTCP_MAX_INCREMENT;
-               else if (dist <= 1U)
-                       /* binary search increase */
-                       tp->bictcp.cnt = tp->snd_cwnd * BICTCP_FUNC_OF_MIN_INCR
-                               / BICTCP_B;
-               else
-                       /* binary search increase */
-                       tp->bictcp.cnt = tp->snd_cwnd / dist;
-       } else {
-               /* slow start amd linear increase */
-               if (tp->snd_cwnd < tp->bictcp.last_max_cwnd + BICTCP_B)
-                       /* slow start */
-                       tp->bictcp.cnt = tp->snd_cwnd * BICTCP_FUNC_OF_MIN_INCR
-                               / BICTCP_B;
-               else if (tp->snd_cwnd < tp->bictcp.last_max_cwnd
-                                       + BICTCP_MAX_INCREMENT*(BICTCP_B-1))
-                       /* slow start */
-                       tp->bictcp.cnt = tp->snd_cwnd * (BICTCP_B-1)
-                               / (tp->snd_cwnd-tp->bictcp.last_max_cwnd);
-               else
-                       /* linear increase */
-                       tp->bictcp.cnt = tp->snd_cwnd / BICTCP_MAX_INCREMENT;
-       }
-       return tp->bictcp.cnt;
-}
-
-/* This is Jacobson's slow start and congestion avoidance. 
- * SIGCOMM '88, p. 328.
- */
-static inline void reno_cong_avoid(struct tcp_sock *tp)
+static inline void tcp_cong_avoid(struct tcp_sock *tp, u32 ack, u32 rtt,
+                                 u32 in_flight, int good)
 {
-        if (tp->snd_cwnd <= tp->snd_ssthresh) {
-                /* In "safe" area, increase. */
-               if (tp->snd_cwnd < tp->snd_cwnd_clamp)
-                       tp->snd_cwnd++;
-       } else {
-                /* In dangerous area, increase slowly.
-                * In theory this is tp->snd_cwnd += 1 / tp->snd_cwnd
-                */
-               if (tp->snd_cwnd_cnt >= bictcp_cwnd(tp)) {
-                       if (tp->snd_cwnd < tp->snd_cwnd_clamp)
-                               tp->snd_cwnd++;
-                       tp->snd_cwnd_cnt=0;
-               } else
-                       tp->snd_cwnd_cnt++;
-        }
+       tp->ca_ops->cong_avoid(tp, ack, rtt, in_flight, good);
        tp->snd_cwnd_stamp = tcp_time_stamp;
 }
 
-/* This is based on the congestion detection/avoidance scheme described in
- *    Lawrence S. Brakmo and Larry L. Peterson.
- *    "TCP Vegas: End to end congestion avoidance on a global internet."
- *    IEEE Journal on Selected Areas in Communication, 13(8):1465--1480,
- *    October 1995. Available from:
- *     ftp://ftp.cs.arizona.edu/xkernel/Papers/jsac.ps
- *
- * See http://www.cs.arizona.edu/xkernel/ for their implementation.
- * The main aspects that distinguish this implementation from the
- * Arizona Vegas implementation are:
- *   o We do not change the loss detection or recovery mechanisms of
- *     Linux in any way. Linux already recovers from losses quite well,
- *     using fine-grained timers, NewReno, and FACK.
- *   o To avoid the performance penalty imposed by increasing cwnd
- *     only every-other RTT during slow start, we increase during
- *     every RTT during slow start, just like Reno.
- *   o Largely to allow continuous cwnd growth during slow start,
- *     we use the rate at which ACKs come back as the "actual"
- *     rate, rather than the rate at which data is sent.
- *   o To speed convergence to the right rate, we set the cwnd
- *     to achieve the right ("actual") rate when we exit slow start.
- *   o To filter out the noise caused by delayed ACKs, we use the
- *     minimum RTT sample observed during the last RTT to calculate
- *     the actual rate.
- *   o When the sender re-starts from idle, it waits until it has
- *     received ACKs for an entire flight of new data before making
- *     a cwnd adjustment decision. The original Vegas implementation
- *     assumed senders never went idle.
- */
-static void vegas_cong_avoid(struct tcp_sock *tp, u32 ack, u32 seq_rtt)
-{
-       /* The key players are v_beg_snd_una and v_beg_snd_nxt.
-        *
-        * These are so named because they represent the approximate values
-        * of snd_una and snd_nxt at the beginning of the current RTT. More
-        * precisely, they represent the amount of data sent during the RTT.
-        * At the end of the RTT, when we receive an ACK for v_beg_snd_nxt,
-        * we will calculate that (v_beg_snd_nxt - v_beg_snd_una) outstanding
-        * bytes of data have been ACKed during the course of the RTT, giving
-        * an "actual" rate of:
-        *
-        *     (v_beg_snd_nxt - v_beg_snd_una) / (rtt duration)
-        *
-        * Unfortunately, v_beg_snd_una is not exactly equal to snd_una,
-        * because delayed ACKs can cover more than one segment, so they
-        * don't line up nicely with the boundaries of RTTs.
-        *
-        * Another unfortunate fact of life is that delayed ACKs delay the
-        * advance of the left edge of our send window, so that the number
-        * of bytes we send in an RTT is often less than our cwnd will allow.
-        * So we keep track of our cwnd separately, in v_beg_snd_cwnd.
-        */
-
-       if (after(ack, tp->vegas.beg_snd_nxt)) {
-               /* Do the Vegas once-per-RTT cwnd adjustment. */
-               u32 old_wnd, old_snd_cwnd;
-
-               
-               /* Here old_wnd is essentially the window of data that was
-                * sent during the previous RTT, and has all
-                * been acknowledged in the course of the RTT that ended
-                * with the ACK we just received. Likewise, old_snd_cwnd
-                * is the cwnd during the previous RTT.
-                */
-               old_wnd = (tp->vegas.beg_snd_nxt - tp->vegas.beg_snd_una) /
-                       tp->mss_cache_std;
-               old_snd_cwnd = tp->vegas.beg_snd_cwnd;
-
-               /* Save the extent of the current window so we can use this
-                * at the end of the next RTT.
-                */
-               tp->vegas.beg_snd_una  = tp->vegas.beg_snd_nxt;
-               tp->vegas.beg_snd_nxt  = tp->snd_nxt;
-               tp->vegas.beg_snd_cwnd = tp->snd_cwnd;
-
-               /* Take into account the current RTT sample too, to
-                * decrease the impact of delayed acks. This double counts
-                * this sample since we count it for the next window as well,
-                * but that's not too awful, since we're taking the min,
-                * rather than averaging.
-                */
-               vegas_rtt_calc(tp, seq_rtt);
-
-               /* We do the Vegas calculations only if we got enough RTT
-                * samples that we can be reasonably sure that we got
-                * at least one RTT sample that wasn't from a delayed ACK.
-                * If we only had 2 samples total,
-                * then that means we're getting only 1 ACK per RTT, which
-                * means they're almost certainly delayed ACKs.
-                * If  we have 3 samples, we should be OK.
-                */
-
-               if (tp->vegas.cntRTT <= 2) {
-                       /* We don't have enough RTT samples to do the Vegas
-                        * calculation, so we'll behave like Reno.
-                        */
-                       if (tp->snd_cwnd > tp->snd_ssthresh)
-                               tp->snd_cwnd++;
-               } else {
-                       u32 rtt, target_cwnd, diff;
-
-                       /* We have enough RTT samples, so, using the Vegas
-                        * algorithm, we determine if we should increase or
-                        * decrease cwnd, and by how much.
-                        */
-
-                       /* Pluck out the RTT we are using for the Vegas
-                        * calculations. This is the min RTT seen during the
-                        * last RTT. Taking the min filters out the effects
-                        * of delayed ACKs, at the cost of noticing congestion
-                        * a bit later.
-                        */
-                       rtt = tp->vegas.minRTT;
-
-                       /* Calculate the cwnd we should have, if we weren't
-                        * going too fast.
-                        *
-                        * This is:
-                        *     (actual rate in segments) * baseRTT
-                        * We keep it as a fixed point number with
-                        * V_PARAM_SHIFT bits to the right of the binary point.
-                        */
-                       target_cwnd = ((old_wnd * tp->vegas.baseRTT)
-                                      << V_PARAM_SHIFT) / rtt;
-
-                       /* Calculate the difference between the window we had,
-                        * and the window we would like to have. This quantity
-                        * is the "Diff" from the Arizona Vegas papers.
-                        *
-                        * Again, this is a fixed point number with
-                        * V_PARAM_SHIFT bits to the right of the binary
-                        * point.
-                        */
-                       diff = (old_wnd << V_PARAM_SHIFT) - target_cwnd;
-
-                       if (tp->snd_cwnd < tp->snd_ssthresh) {
-                               /* Slow start.  */
-                               if (diff > sysctl_tcp_vegas_gamma) {
-                                       /* Going too fast. Time to slow down
-                                        * and switch to congestion avoidance.
-                                        */
-                                       tp->snd_ssthresh = 2;
-
-                                       /* Set cwnd to match the actual rate
-                                        * exactly:
-                                        *   cwnd = (actual rate) * baseRTT
-                                        * Then we add 1 because the integer
-                                        * truncation robs us of full link
-                                        * utilization.
-                                        */
-                                       tp->snd_cwnd = min(tp->snd_cwnd,
-                                                          (target_cwnd >>
-                                                           V_PARAM_SHIFT)+1);
-
-                               }
-                       } else {
-                               /* Congestion avoidance. */
-                               u32 next_snd_cwnd;
-
-                               /* Figure out where we would like cwnd
-                                * to be.
-                                */
-                               if (diff > sysctl_tcp_vegas_beta) {
-                                       /* The old window was too fast, so
-                                        * we slow down.
-                                        */
-                                       next_snd_cwnd = old_snd_cwnd - 1;
-                               } else if (diff < sysctl_tcp_vegas_alpha) {
-                                       /* We don't have enough extra packets
-                                        * in the network, so speed up.
-                                        */
-                                       next_snd_cwnd = old_snd_cwnd + 1;
-                               } else {
-                                       /* Sending just as fast as we
-                                        * should be.
-                                        */
-                                       next_snd_cwnd = old_snd_cwnd;
-                               }
-
-                               /* Adjust cwnd upward or downward, toward the
-                                * desired value.
-                                */
-                               if (next_snd_cwnd > tp->snd_cwnd)
-                                       tp->snd_cwnd++;
-                               else if (next_snd_cwnd < tp->snd_cwnd)
-                                       tp->snd_cwnd--;
-                       }
-               }
-
-               /* Wipe the slate clean for the next RTT. */
-               tp->vegas.cntRTT = 0;
-               tp->vegas.minRTT = 0x7fffffff;
-       }
-
-       /* The following code is executed for every ack we receive,
-        * except for conditions checked in should_advance_cwnd()
-        * before the call to tcp_cong_avoid(). Mainly this means that
-        * we only execute this code if the ack actually acked some
-        * data.
-        */
-
-       /* If we are in slow start, increase our cwnd in response to this ACK.
-        * (If we are not in slow start then we are in congestion avoidance,
-        * and adjust our congestion window only once per RTT. See the code
-        * above.)
-        */
-       if (tp->snd_cwnd <= tp->snd_ssthresh) 
-               tp->snd_cwnd++;
-
-       /* to keep cwnd from growing without bound */
-       tp->snd_cwnd = min_t(u32, tp->snd_cwnd, tp->snd_cwnd_clamp);
-
-       /* Make sure that we are never so timid as to reduce our cwnd below
-        * 2 MSS.
-        *
-        * Going below 2 MSS would risk huge delayed ACKs from our receiver.
-        */
-       tp->snd_cwnd = max(tp->snd_cwnd, 2U);
-
-       tp->snd_cwnd_stamp = tcp_time_stamp;
-}
-
-static inline void tcp_cong_avoid(struct tcp_sock *tp, u32 ack, u32 seq_rtt)
-{
-       if (tcp_vegas_enabled(tp))
-               vegas_cong_avoid(tp, ack, seq_rtt);
-       else
-               reno_cong_avoid(tp);
-}
-
 /* Restart timer after forward progress on connection.
  * RFC2988 recommends to restart timer to now+rto.
  */
@@ -2415,13 +2024,18 @@ static int tcp_tso_acked(struct sock *sk, struct sk_buff *skb,
 
 
 /* Remove acknowledged frames from the retransmission queue. */
-static int tcp_clean_rtx_queue(struct sock *sk, __s32 *seq_rtt_p)
+static int tcp_clean_rtx_queue(struct sock *sk, __s32 *seq_rtt_p, s32 *seq_usrtt)
 {
        struct tcp_sock *tp = tcp_sk(sk);
        struct sk_buff *skb;
        __u32 now = tcp_time_stamp;
        int acked = 0;
        __s32 seq_rtt = -1;
+       struct timeval usnow;
+       u32 pkts_acked = 0;
+
+       if (seq_usrtt)
+               do_gettimeofday(&usnow);
 
        while ((skb = skb_peek(&sk->sk_write_queue)) &&
               skb != sk->sk_send_head) {
@@ -2448,6 +2062,7 @@ static int tcp_clean_rtx_queue(struct sock *sk, __s32 *seq_rtt_p)
                 */
                if (!(scb->flags & TCPCB_FLAG_SYN)) {
                        acked |= FLAG_DATA_ACKED;
+                       ++pkts_acked;
                } else {
                        acked |= FLAG_SYN_ACKED;
                        tp->retrans_stamp = 0;
@@ -2461,6 +2076,10 @@ static int tcp_clean_rtx_queue(struct sock *sk, __s32 *seq_rtt_p)
                                seq_rtt = -1;
                        } else if (seq_rtt < 0)
                                seq_rtt = now - scb->when;
+                       if (seq_usrtt)
+                               *seq_usrtt = (usnow.tv_sec - skb->stamp.tv_sec) * 1000000
+                                       + (usnow.tv_usec - skb->stamp.tv_usec);
+
                        if (sacked & TCPCB_SACKED_ACKED)
                                tp->sacked_out -= tcp_skb_pcount(skb);
                        if (sacked & TCPCB_LOST)
@@ -2479,8 +2098,11 @@ static int tcp_clean_rtx_queue(struct sock *sk, __s32 *seq_rtt_p)
        }
 
        if (acked&FLAG_ACKED) {
-               tcp_ack_update_rtt(tp, acked, seq_rtt);
+               tcp_ack_update_rtt(tp, acked, seq_rtt, seq_usrtt);
                tcp_ack_packets_out(sk, tp);
+
+               if (tp->ca_ops->pkts_acked)
+                       tp->ca_ops->pkts_acked(tp, pkts_acked);
        }
 
 #if FASTRETRANS_DEBUG > 0
@@ -2624,257 +2246,6 @@ static void tcp_process_frto(struct sock *sk, u32 prior_snd_una)
        tp->frto_counter = (tp->frto_counter + 1) % 3;
 }
 
-/*
- * TCP Westwood+
- */
-
-/*
- * @init_westwood
- * This function initializes fields used in TCP Westwood+. We can't
- * get no information about RTTmin at this time so we simply set it to
- * TCP_WESTWOOD_INIT_RTT. This value was chosen to be too conservative
- * since in this way we're sure it will be updated in a consistent
- * way as soon as possible. It will reasonably happen within the first
- * RTT period of the connection lifetime.
- */
-
-static void init_westwood(struct sock *sk)
-{
-        struct tcp_sock *tp = tcp_sk(sk);
-
-        tp->westwood.bw_ns_est = 0;
-        tp->westwood.bw_est = 0;
-        tp->westwood.accounted = 0;
-        tp->westwood.cumul_ack = 0;
-        tp->westwood.rtt_win_sx = tcp_time_stamp;
-        tp->westwood.rtt = TCP_WESTWOOD_INIT_RTT;
-        tp->westwood.rtt_min = TCP_WESTWOOD_INIT_RTT;
-        tp->westwood.snd_una = tp->snd_una;
-}
-
-/*
- * @westwood_do_filter
- * Low-pass filter. Implemented using constant coeffients.
- */
-
-static inline __u32 westwood_do_filter(__u32 a, __u32 b)
-{
-       return (((7 * a) + b) >> 3);
-}
-
-static void westwood_filter(struct sock *sk, __u32 delta)
-{
-       struct tcp_sock *tp = tcp_sk(sk);
-
-       tp->westwood.bw_ns_est =
-               westwood_do_filter(tp->westwood.bw_ns_est, 
-                                  tp->westwood.bk / delta);
-       tp->westwood.bw_est =
-               westwood_do_filter(tp->westwood.bw_est,
-                                  tp->westwood.bw_ns_est);
-}
-
-/* 
- * @westwood_update_rttmin
- * It is used to update RTTmin. In this case we MUST NOT use
- * WESTWOOD_RTT_MIN minimum bound since we could be on a LAN!
- */
-
-static inline __u32 westwood_update_rttmin(const struct sock *sk)
-{
-       const struct tcp_sock *tp = tcp_sk(sk);
-       __u32 rttmin = tp->westwood.rtt_min;
-
-       if (tp->westwood.rtt != 0 &&
-           (tp->westwood.rtt < tp->westwood.rtt_min || !rttmin))
-               rttmin = tp->westwood.rtt;
-
-       return rttmin;
-}
-
-/*
- * @westwood_acked
- * Evaluate increases for dk. 
- */
-
-static inline __u32 westwood_acked(const struct sock *sk)
-{
-       const struct tcp_sock *tp = tcp_sk(sk);
-
-       return tp->snd_una - tp->westwood.snd_una;
-}
-
-/*
- * @westwood_new_window
- * It evaluates if we are receiving data inside the same RTT window as
- * when we started.
- * Return value:
- * It returns 0 if we are still evaluating samples in the same RTT
- * window, 1 if the sample has to be considered in the next window.
- */
-
-static int westwood_new_window(const struct sock *sk)
-{
-       const struct tcp_sock *tp = tcp_sk(sk);
-       __u32 left_bound;
-       __u32 rtt;
-       int ret = 0;
-
-       left_bound = tp->westwood.rtt_win_sx;
-       rtt = max(tp->westwood.rtt, (u32) TCP_WESTWOOD_RTT_MIN);
-
-       /*
-        * A RTT-window has passed. Be careful since if RTT is less than
-        * 50ms we don't filter but we continue 'building the sample'.
-        * This minimum limit was choosen since an estimation on small
-        * time intervals is better to avoid...
-        * Obvioulsy on a LAN we reasonably will always have
-        * right_bound = left_bound + WESTWOOD_RTT_MIN
-         */
-
-       if ((left_bound + rtt) < tcp_time_stamp)
-               ret = 1;
-
-       return ret;
-}
-
-/*
- * @westwood_update_window
- * It updates RTT evaluation window if it is the right moment to do
- * it. If so it calls filter for evaluating bandwidth. 
- */
-
-static void __westwood_update_window(struct sock *sk, __u32 now)
-{
-       struct tcp_sock *tp = tcp_sk(sk);
-       __u32 delta = now - tp->westwood.rtt_win_sx;
-
-        if (delta) {
-               if (tp->westwood.rtt)
-                       westwood_filter(sk, delta);
-
-               tp->westwood.bk = 0;
-               tp->westwood.rtt_win_sx = tcp_time_stamp;
-       }
-}
-
-
-static void westwood_update_window(struct sock *sk, __u32 now)
-{
-       if (westwood_new_window(sk)) 
-               __westwood_update_window(sk, now);
-}
-
-/*
- * @__tcp_westwood_fast_bw
- * It is called when we are in fast path. In particular it is called when
- * header prediction is successfull. In such case infact update is
- * straight forward and doesn't need any particular care.
- */
-
-static void __tcp_westwood_fast_bw(struct sock *sk, struct sk_buff *skb)
-{
-       struct tcp_sock *tp = tcp_sk(sk);
-
-       westwood_update_window(sk, tcp_time_stamp);
-
-       tp->westwood.bk += westwood_acked(sk);
-       tp->westwood.snd_una = tp->snd_una;
-       tp->westwood.rtt_min = westwood_update_rttmin(sk);
-}
-
-static inline void tcp_westwood_fast_bw(struct sock *sk, struct sk_buff *skb)
-{
-        if (tcp_is_westwood(tcp_sk(sk)))
-                __tcp_westwood_fast_bw(sk, skb);
-}
-
-
-/*
- * @westwood_dupack_update
- * It updates accounted and cumul_ack when receiving a dupack.
- */
-
-static void westwood_dupack_update(struct sock *sk)
-{
-       struct tcp_sock *tp = tcp_sk(sk);
-
-       tp->westwood.accounted += tp->mss_cache_std;
-       tp->westwood.cumul_ack = tp->mss_cache_std;
-}
-
-static inline int westwood_may_change_cumul(struct tcp_sock *tp)
-{
-       return (tp->westwood.cumul_ack > tp->mss_cache_std);
-}
-
-static inline void westwood_partial_update(struct tcp_sock *tp)
-{
-       tp->westwood.accounted -= tp->westwood.cumul_ack;
-       tp->westwood.cumul_ack = tp->mss_cache_std;
-}
-
-static inline void westwood_complete_update(struct tcp_sock *tp)
-{
-       tp->westwood.cumul_ack -= tp->westwood.accounted;
-       tp->westwood.accounted = 0;
-}
-
-/*
- * @westwood_acked_count
- * This function evaluates cumul_ack for evaluating dk in case of
- * delayed or partial acks.
- */
-
-static inline __u32 westwood_acked_count(struct sock *sk)
-{
-       struct tcp_sock *tp = tcp_sk(sk);
-
-       tp->westwood.cumul_ack = westwood_acked(sk);
-
-        /* If cumul_ack is 0 this is a dupack since it's not moving
-         * tp->snd_una.
-         */
-        if (!(tp->westwood.cumul_ack))
-                westwood_dupack_update(sk);
-
-        if (westwood_may_change_cumul(tp)) {
-               /* Partial or delayed ack */
-               if (tp->westwood.accounted >= tp->westwood.cumul_ack)
-                       westwood_partial_update(tp);
-               else
-                       westwood_complete_update(tp);
-       }
-
-       tp->westwood.snd_una = tp->snd_una;
-
-       return tp->westwood.cumul_ack;
-}
-
-
-/*
- * @__tcp_westwood_slow_bw
- * It is called when something is going wrong..even if there could
- * be no problems! Infact a simple delayed packet may trigger a
- * dupack. But we need to be careful in such case.
- */
-
-static void __tcp_westwood_slow_bw(struct sock *sk, struct sk_buff *skb)
-{
-       struct tcp_sock *tp = tcp_sk(sk);
-
-       westwood_update_window(sk, tcp_time_stamp);
-
-       tp->westwood.bk += westwood_acked_count(sk);
-       tp->westwood.rtt_min = westwood_update_rttmin(sk);
-}
-
-static inline void tcp_westwood_slow_bw(struct sock *sk, struct sk_buff *skb)
-{
-        if (tcp_is_westwood(tcp_sk(sk)))
-                __tcp_westwood_slow_bw(sk, skb);
-}
-
 /* This routine deals with incoming acks, but not outgoing ones. */
 static int tcp_ack(struct sock *sk, struct sk_buff *skb, int flag)
 {
@@ -2884,6 +2255,7 @@ static int tcp_ack(struct sock *sk, struct sk_buff *skb, int flag)
        u32 ack = TCP_SKB_CB(skb)->ack_seq;
        u32 prior_in_flight;
        s32 seq_rtt;
+       s32 seq_usrtt = 0;
        int prior_packets;
 
        /* If the ack is newer than sent or older than previous acks
@@ -2902,9 +2274,10 @@ static int tcp_ack(struct sock *sk, struct sk_buff *skb, int flag)
                 */
                tcp_update_wl(tp, ack, ack_seq);
                tp->snd_una = ack;
-               tcp_westwood_fast_bw(sk, skb);
                flag |= FLAG_WIN_UPDATE;
 
+               tcp_ca_event(tp, CA_EVENT_FAST_ACK);
+
                NET_INC_STATS_BH(LINUX_MIB_TCPHPACKS);
        } else {
                if (ack_seq != TCP_SKB_CB(skb)->end_seq)
@@ -2920,7 +2293,7 @@ static int tcp_ack(struct sock *sk, struct sk_buff *skb, int flag)
                if (TCP_ECN_rcv_ecn_echo(tp, skb->h.th))
                        flag |= FLAG_ECE;
 
-               tcp_westwood_slow_bw(sk,skb);
+               tcp_ca_event(tp, CA_EVENT_SLOW_ACK);
        }
 
        /* We passed data and got it acked, remove any soft error
@@ -2935,22 +2308,20 @@ static int tcp_ack(struct sock *sk, struct sk_buff *skb, int flag)
        prior_in_flight = tcp_packets_in_flight(tp);
 
        /* See if we can take anything off of the retransmit queue. */
-       flag |= tcp_clean_rtx_queue(sk, &seq_rtt);
+       flag |= tcp_clean_rtx_queue(sk, &seq_rtt,
+                                   tp->ca_ops->rtt_sample ? &seq_usrtt : NULL);
 
        if (tp->frto_counter)
                tcp_process_frto(sk, prior_snd_una);
 
        if (tcp_ack_is_dubious(tp, flag)) {
                /* Advanve CWND, if state allows this. */
-               if ((flag & FLAG_DATA_ACKED) &&
-                   (tcp_vegas_enabled(tp) || prior_in_flight >= tp->snd_cwnd) &&
-                   tcp_may_raise_cwnd(tp, flag))
-                       tcp_cong_avoid(tp, ack, seq_rtt);
+               if ((flag & FLAG_DATA_ACKED) && tcp_may_raise_cwnd(tp, flag))
+                       tcp_cong_avoid(tp, ack,  seq_rtt, prior_in_flight, 0);
                tcp_fastretrans_alert(sk, prior_snd_una, prior_packets, flag);
        } else {
-               if ((flag & FLAG_DATA_ACKED) && 
-                   (tcp_vegas_enabled(tp) || prior_in_flight >= tp->snd_cwnd))
-                       tcp_cong_avoid(tp, ack, seq_rtt);
+               if ((flag & FLAG_DATA_ACKED))
+                       tcp_cong_avoid(tp, ack, seq_rtt, prior_in_flight, 1);
        }
 
        if ((flag & FLAG_FORWARD_PROGRESS) || !(flag&FLAG_NOT_DUP))
@@ -4552,6 +3923,8 @@ static int tcp_rcv_synsent_state_process(struct sock *sk, struct sk_buff *skb,
 
                tcp_init_metrics(sk);
 
+               tcp_init_congestion_control(tp);
+
                /* Prevent spurious tcp_cwnd_restart() on first data
                 * packet.
                 */
@@ -4708,9 +4081,6 @@ int tcp_rcv_state_process(struct sock *sk, struct sk_buff *skb,
                        if(tp->af_specific->conn_request(sk, skb) < 0)
                                return 1;
 
-                       init_westwood(sk);
-                       init_bictcp(tp);
-
                        /* Now we have several options: In theory there is 
                         * nothing else in the frame. KA9Q has an option to 
                         * send data with the syn, BSD accepts data with the
@@ -4732,9 +4102,6 @@ int tcp_rcv_state_process(struct sock *sk, struct sk_buff *skb,
                goto discard;
 
        case TCP_SYN_SENT:
-               init_westwood(sk);
-               init_bictcp(tp);
-
                queued = tcp_rcv_synsent_state_process(sk, skb, th, len);
                if (queued >= 0)
                        return queued;
@@ -4816,7 +4183,7 @@ int tcp_rcv_state_process(struct sock *sk, struct sk_buff *skb,
                                 */
                                if (tp->rx_opt.saw_tstamp && tp->rx_opt.rcv_tsecr &&
                                    !tp->srtt)
-                                       tcp_ack_saw_tstamp(tp, 0);
+                                       tcp_ack_saw_tstamp(tp, 0, 0);
 
                                if (tp->rx_opt.tstamp_ok)
                                        tp->advmss -= TCPOLEN_TSTAMP_ALIGNED;
@@ -4828,6 +4195,8 @@ int tcp_rcv_state_process(struct sock *sk, struct sk_buff *skb,
 
                                tcp_init_metrics(sk);
 
+                               tcp_init_congestion_control(tp);
+
                                /* Prevent spurious tcp_cwnd_restart() on
                                 * first data packet.
                                 */
index 2d41d5d..9122814 100644 (file)
@@ -2048,6 +2048,7 @@ static int tcp_v4_init_sock(struct sock *sk)
        tp->mss_cache_std = tp->mss_cache = 536;
 
        tp->reordering = sysctl_tcp_reordering;
+       tp->ca_ops = &tcp_reno;
 
        sk->sk_state = TCP_CLOSE;
 
@@ -2070,6 +2071,8 @@ int tcp_v4_destroy_sock(struct sock *sk)
 
        tcp_clear_xmit_timers(sk);
 
+       tcp_cleanup_congestion_control(tp);
+
        /* Cleanup up the write buffer. */
        sk_stream_writequeue_purge(sk);
 
index b3943e7..f42a284 100644 (file)
@@ -774,6 +774,8 @@ struct sock *tcp_create_openreq_child(struct sock *sk, struct request_sock *req,
                newtp->frto_counter = 0;
                newtp->frto_highmark = 0;
 
+               newtp->ca_ops = &tcp_reno;
+
                tcp_set_ca_state(newtp, TCP_CA_Open);
                tcp_init_xmit_timers(newsk);
                skb_queue_head_init(&newtp->out_of_order_queue);
@@ -842,8 +844,6 @@ struct sock *tcp_create_openreq_child(struct sock *sk, struct request_sock *req,
                if (newtp->ecn_flags&TCP_ECN_OK)
                        sock_set_flag(newsk, SOCK_NO_LARGESEND);
 
-               tcp_ca_init(newtp);
-
                TCP_INC_STATS_BH(TCP_MIB_PASSIVEOPENS);
        }
        return newsk;
index f17c657..0e17c24 100644 (file)
@@ -111,8 +111,7 @@ static void tcp_cwnd_restart(struct tcp_sock *tp, struct dst_entry *dst)
        u32 restart_cwnd = tcp_init_cwnd(tp, dst);
        u32 cwnd = tp->snd_cwnd;
 
-       if (tcp_is_vegas(tp)) 
-               tcp_vegas_enable(tp);
+       tcp_ca_event(tp, CA_EVENT_CWND_RESTART);
 
        tp->snd_ssthresh = tcp_current_ssthresh(tp);
        restart_cwnd = min(restart_cwnd, cwnd);
@@ -280,6 +279,10 @@ static int tcp_transmit_skb(struct sock *sk, struct sk_buff *skb)
 #define SYSCTL_FLAG_WSCALE     0x2
 #define SYSCTL_FLAG_SACK       0x4
 
+               /* If congestion control is doing timestamping */
+               if (tp->ca_ops->rtt_sample)
+                       do_gettimeofday(&skb->stamp);
+
                sysctl_flags = 0;
                if (tcb->flags & TCPCB_FLAG_SYN) {
                        tcp_header_size = sizeof(struct tcphdr) + TCPOLEN_MSS;
@@ -304,17 +307,8 @@ static int tcp_transmit_skb(struct sock *sk, struct sk_buff *skb)
                                            (tp->rx_opt.eff_sacks * TCPOLEN_SACK_PERBLOCK));
                }
                
-               /*
-                * If the connection is idle and we are restarting,
-                * then we don't want to do any Vegas calculations
-                * until we get fresh RTT samples.  So when we
-                * restart, we reset our Vegas state to a clean
-                * slate. After we get acks for this flight of
-                * packets, _then_ we can make Vegas calculations
-                * again.
-                */
-               if (tcp_is_vegas(tp) && tcp_packets_in_flight(tp) == 0)
-                       tcp_vegas_enable(tp);
+               if (tcp_packets_in_flight(tp) == 0)
+                       tcp_ca_event(tp, CA_EVENT_TX_START);
 
                th = (struct tcphdr *) skb_push(skb, tcp_header_size);
                skb->h.th = th;
@@ -521,6 +515,7 @@ static int tcp_fragment(struct sock *sk, struct sk_buff *skb, u32 len)
         * skbs, which it never sent before. --ANK
         */
        TCP_SKB_CB(buff)->when = TCP_SKB_CB(skb)->when;
+       buff->stamp = skb->stamp;
 
        if (TCP_SKB_CB(skb)->sacked & TCPCB_LOST) {
                tp->lost_out -= tcp_skb_pcount(skb);
@@ -1449,7 +1444,6 @@ static inline void tcp_connect_init(struct sock *sk)
                tp->window_clamp = dst_metric(dst, RTAX_WINDOW);
        tp->advmss = dst_metric(dst, RTAX_ADVMSS);
        tcp_initialize_rcv_mss(sk);
-       tcp_ca_init(tp);
 
        tcp_select_initial_window(tcp_full_space(sk),
                                  tp->advmss - (tp->rx_opt.ts_recent_stamp ? tp->tcp_header_len - sizeof(struct tcphdr) : 0),
@@ -1503,7 +1497,6 @@ int tcp_connect(struct sock *sk)
        TCP_SKB_CB(buff)->end_seq = tp->write_seq;
        tp->snd_nxt = tp->write_seq;
        tp->pushed_seq = tp->write_seq;
-       tcp_ca_init(tp);
 
        /* Send it off. */
        TCP_SKB_CB(buff)->when = tcp_time_stamp;
index 2414937..fce5603 100644 (file)
@@ -2025,7 +2025,7 @@ static int tcp_v6_init_sock(struct sock *sk)
        sk->sk_state = TCP_CLOSE;
 
        tp->af_specific = &ipv6_specific;
-
+       tp->ca_ops = &tcp_reno;
        sk->sk_write_space = sk_stream_write_space;
        sock_set_flag(sk, SOCK_USE_WRITE_QUEUE);