[TCP]: Add pluggable congestion control algorithm infrastructure.

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>

3 files changed, 86 insertions, 209 deletions

diff --git a/include/linux/sysctl.h b/include/linux/sysctl.h
index 614e939c78a4..72965bfe6cfb 100644
--- a/include/linux/sysctl.h
+++ b/include/linux/sysctl.h
@@ -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 {
diff --git a/include/linux/tcp.h b/include/linux/tcp.h
index 97a7c9e03df5..3ea75dd6640a 100644
--- a/include/linux/tcp.h
+++ b/include/linux/tcp.h
@@ -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 */
diff --git a/include/net/tcp.h b/include/net/tcp.h
index f730935b824a..e427cf35915c 100644
--- a/include/net/tcp.h
+++ b/include/net/tcp.h
@@ -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 */