[TCP]: Add pluggable congestion control algorithm infrastructure. (317a76f9) · Commits · 戴 / test

include/linux/sysctl.h

+1 −8

Original line number	Diff line number	Diff line
		@@ -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 {

include/linux/tcp.h

+10 −39

Original line number	Diff line number	Diff line
		@@ -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 */

include/net/tcp.h

+75 −162

Original line number	Diff line number	Diff line
		@@ -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 (20HZ) / 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 */

net/ipv4/Makefile

+2 −1

Original line number	Diff line number	Diff line
		@@ -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

net/ipv4/sysctl_net_ipv4.c

+45 −69

Original line number	Diff line number	Diff line
		@@ -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,
		@@ -611,70 +650,6 @@ ctl_table ipv4_table[] = {
		.mode = 0644,
		.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",
		@@ -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 }
		};

Admin message