Commit 6687e988 authored by Arnaldo Carvalho de Melo's avatar Arnaldo Carvalho de Melo Committed by David S. Miller
Browse files

[ICSK]: Move TCP congestion avoidance members to icsk 



This changeset basically moves tcp_sk()->{ca_ops,ca_state,etc} to inet_csk(),
minimal renaming/moving done in this changeset to ease review.

Most of it is just changes of struct tcp_sock * to struct sock * parameters.

With this we move to a state closer to two interesting goals:

1. Generalisation of net/ipv4/tcp_diag.c, becoming inet_diag.c, being used
   for any INET transport protocol that has struct inet_hashinfo and are
   derived from struct inet_connection_sock. Keeps the userspace API, that will
   just not display DCCP sockets, while newer versions of tools can support
   DCCP.

2. INET generic transport pluggable Congestion Avoidance infrastructure, using
   the current TCP CA infrastructure with DCCP.

Signed-off-by: default avatarArnaldo Carvalho de Melo <acme@mandriva.com>
Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parent 64ce2073

include/linux/tcp.h

+3 −18
Original line number Diff line number Diff line
@@ -258,19 +258,15 @@ struct tcp_sock { 
	__u32	mss_cache;	/* Cached effective mss, not including SACKS */

	__u16	xmit_size_goal;	/* Goal for segmenting output packets	*/

	__u16	ext_header_len;	/* Network protocol overhead (IP/IPv6 options) */

	__u8	ca_state;	/* State of fast-retransmit machine 	*/



	__u8	keepalive_probes; /* num of allowed keep alive probes	*/

	__u16	advmss;		/* Advertised MSS			*/

	__u32	window_clamp;	/* Maximal window to advertise		*/

	__u32	rcv_ssthresh;	/* Current window clamp			*/



	__u32	frto_highmark;	/* snd_nxt when RTO occurred */

	__u8	reordering;	/* Packet reordering metric.		*/

	__u8	frto_counter;	/* Number of new acks after RTO */



	__u8	nonagle;	/* Disable Nagle algorithm?             */

	/* ONE BYTE HOLE, TRY TO PACK */

	__u8	keepalive_probes; /* num of allowed keep alive probes	*/



/* RTT measurement */

	__u32	srtt;		/* smoothed round trip time << 3	*/
@@ -311,8 +307,7 @@ struct tcp_sock { 
	struct tcp_sack_block duplicate_sack[1]; /* D-SACK block */

	struct tcp_sack_block selective_acks[4]; /* The SACKS themselves*/



	__u8	probes_out;	/* unanswered 0 window probes		*/

	__u8	ecn_flags;	/* ECN status bits.			*/

	__u16	advmss;		/* Advertised MSS			*/

	__u16	prior_ssthresh; /* ssthresh saved at recovery start	*/

	__u32	lost_out;	/* Lost packets			*/

	__u32	sacked_out;	/* SACK'd packets			*/
@@ -327,7 +322,7 @@ struct tcp_sock { 
	__u32	urg_seq;	/* Seq of received urgent pointer */

	__u16	urg_data;	/* Saved octet of OOB data and control flags */

	__u8	urg_mode;	/* In urgent mode		*/

	/* ONE BYTE HOLE, TRY TO PACK! */

	__u8	ecn_flags;	/* ECN status bits.			*/

	__u32	snd_up;		/* Urgent pointer		*/



	__u32	total_retrans;	/* Total retransmits for entire connection */
@@ -351,11 +346,6 @@ struct tcp_sock { 
		__u32	seq;

		__u32	time;

	} rcvq_space;



	/* 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)
@@ -377,11 +367,6 @@ static inline struct tcp_timewait_sock *tcp_twsk(const struct sock *sk) 
	return (struct tcp_timewait_sock *)sk;

}



static inline void *tcp_ca(const struct tcp_sock *tp)

{

	return (void *) tp->ca_priv;

}



#endif



#endif	/* _LINUX_TCP_H */

include/net/inet_connection_sock.h

+15 −0
Original line number Diff line number Diff line
@@ -27,6 +27,7 @@ 


struct inet_bind_bucket;

struct inet_hashinfo;

struct tcp_congestion_ops;



/** inet_connection_sock - INET connection oriented sock

 *
@@ -35,10 +36,13 @@ struct inet_hashinfo; 
 * @icsk_timeout:	   Timeout

 * @icsk_retransmit_timer: Resend (no ack)

 * @icsk_rto:		   Retransmit timeout

 * @icsk_ca_ops		   Pluggable congestion control hook

 * @icsk_ca_state:	   Congestion control state

 * @icsk_retransmits:	   Number of unrecovered [RTO] timeouts

 * @icsk_pending:	   Scheduled timer event

 * @icsk_backoff:	   Backoff

 * @icsk_syn_retries:      Number of allowed SYN (or equivalent) retries

 * @icsk_probes_out:	   unanswered 0 window probes

 * @icsk_ack:		   Delayed ACK control data

 */

struct inet_connection_sock {
@@ -50,10 +54,14 @@ struct inet_connection_sock { 
 	struct timer_list	  icsk_retransmit_timer;

 	struct timer_list	  icsk_delack_timer;

	__u32			  icsk_rto;

	struct tcp_congestion_ops *icsk_ca_ops;

	__u8			  icsk_ca_state;

	__u8			  icsk_retransmits;

	__u8			  icsk_pending;

	__u8			  icsk_backoff;

	__u8			  icsk_syn_retries;

	__u8			  icsk_probes_out;

	/* 2 BYTES HOLE, TRY TO PACK! */

	struct {

		__u8		  pending;	 /* ACK is pending			   */

		__u8		  quick;	 /* Scheduled number of quick acks	   */
@@ -65,6 +73,8 @@ struct inet_connection_sock { 
		__u16		  last_seg_size; /* Size of last incoming segment	   */

		__u16		  rcv_mss;	 /* MSS used for delayed ACK decisions	   */ 

	} icsk_ack;

	u32			  icsk_ca_priv[16];

#define ICSK_CA_PRIV_SIZE	(16 * sizeof(u32))

};



#define ICSK_TIME_RETRANS	1	/* Retransmit timer */
@@ -77,6 +87,11 @@ static inline struct inet_connection_sock *inet_csk(const struct sock *sk) 
	return (struct inet_connection_sock *)sk;

}



static inline void *inet_csk_ca(const struct sock *sk)

{

	return (void *)inet_csk(sk)->icsk_ca_priv;

}



extern struct sock *inet_csk_clone(struct sock *sk,

				   const struct request_sock *req,

				   const unsigned int __nocast priority);

include/net/tcp.h

+42 −32
Original line number Diff line number Diff line
@@ -669,29 +669,29 @@ struct tcp_congestion_ops { 
	struct list_head	list;



	/* initialize private data (optional) */

	void (*init)(struct tcp_sock *tp);

	void (*init)(struct sock *sk);

	/* cleanup private data  (optional) */

	void (*release)(struct tcp_sock *tp);

	void (*release)(struct sock *sk);



	/* return slow start threshold (required) */

	u32 (*ssthresh)(struct tcp_sock *tp);

	u32 (*ssthresh)(struct sock *sk);

	/* lower bound for congestion window (optional) */

	u32 (*min_cwnd)(struct tcp_sock *tp);

	u32 (*min_cwnd)(struct sock *sk);

	/* do new cwnd calculation (required) */

	void (*cong_avoid)(struct tcp_sock *tp, u32 ack,

	void (*cong_avoid)(struct sock *sk, 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);

	void (*rtt_sample)(struct sock *sk, u32 usrtt);

	/* call before changing ca_state (optional) */

	void (*set_state)(struct tcp_sock *tp, u8 new_state);

	void (*set_state)(struct sock *sk, u8 new_state);

	/* call when cwnd event occurs (optional) */

	void (*cwnd_event)(struct tcp_sock *tp, enum tcp_ca_event ev);

	void (*cwnd_event)(struct sock *sk, enum tcp_ca_event ev);

	/* new value of cwnd after loss (optional) */

	u32  (*undo_cwnd)(struct tcp_sock *tp);

	u32  (*undo_cwnd)(struct sock *sk);

	/* hook for packet ack accounting (optional) */

	void (*pkts_acked)(struct tcp_sock *tp, u32 num_acked);

	void (*pkts_acked)(struct sock *sk, u32 num_acked);

	/* get info for tcp_diag (optional) */

	void (*get_info)(struct tcp_sock *tp, u32 ext, struct sk_buff *skb);

	void (*get_info)(struct sock *sk, u32 ext, struct sk_buff *skb);



	char 		name[TCP_CA_NAME_MAX];

	struct module 	*owner;
@@ -700,30 +700,34 @@ struct tcp_congestion_ops { 
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 void tcp_init_congestion_control(struct sock *sk);

extern void tcp_cleanup_congestion_control(struct sock *sk);

extern int tcp_set_default_congestion_control(const char *name);

extern void tcp_get_default_congestion_control(char *name);

extern int tcp_set_congestion_control(struct tcp_sock *tp, const char *name);

extern int tcp_set_congestion_control(struct sock *sk, const char *name);



extern struct tcp_congestion_ops tcp_init_congestion_ops;

extern u32 tcp_reno_ssthresh(struct tcp_sock *tp);

extern void tcp_reno_cong_avoid(struct tcp_sock *tp, u32 ack,

extern u32 tcp_reno_ssthresh(struct sock *sk);

extern void tcp_reno_cong_avoid(struct sock *sk, u32 ack,

				u32 rtt, u32 in_flight, int flag);

extern u32 tcp_reno_min_cwnd(struct tcp_sock *tp);

extern u32 tcp_reno_min_cwnd(struct sock *sk);

extern struct tcp_congestion_ops tcp_reno;



static inline void tcp_set_ca_state(struct tcp_sock *tp, u8 ca_state)

static inline void tcp_set_ca_state(struct sock *sk, const u8 ca_state)

{

	if (tp->ca_ops->set_state)

		tp->ca_ops->set_state(tp, ca_state);

	tp->ca_state = ca_state;

	struct inet_connection_sock *icsk = inet_csk(sk);



	if (icsk->icsk_ca_ops->set_state)

		icsk->icsk_ca_ops->set_state(sk, ca_state);

	icsk->icsk_ca_state = ca_state;

}



static inline void tcp_ca_event(struct tcp_sock *tp, enum tcp_ca_event event)

static inline void tcp_ca_event(struct sock *sk, const enum tcp_ca_event event)

{

	if (tp->ca_ops->cwnd_event)

		tp->ca_ops->cwnd_event(tp, event);

	const struct inet_connection_sock *icsk = inet_csk(sk);



	if (icsk->icsk_ca_ops->cwnd_event)

		icsk->icsk_ca_ops->cwnd_event(sk, event);

}



/* This determines how many packets are "in the network" to the best
@@ -749,9 +753,10 @@ static __inline__ unsigned int tcp_packets_in_flight(const struct tcp_sock *tp) 
 * The exception is rate halving phase, when cwnd is decreasing towards

 * ssthresh.

 */

static inline __u32 tcp_current_ssthresh(struct tcp_sock *tp)

static inline __u32 tcp_current_ssthresh(const struct sock *sk)

{

	if ((1<<tp->ca_state)&(TCPF_CA_CWR|TCPF_CA_Recovery))

	const struct tcp_sock *tp = tcp_sk(sk);

	if ((1 << inet_csk(sk)->icsk_ca_state) & (TCPF_CA_CWR | TCPF_CA_Recovery))

		return tp->snd_ssthresh;

	else

		return max(tp->snd_ssthresh,
@@ -768,10 +773,13 @@ static inline void tcp_sync_left_out(struct tcp_sock *tp) 
}



/* Set slow start threshold and cwnd not falling to slow start */

static inline void __tcp_enter_cwr(struct tcp_sock *tp)

static inline void __tcp_enter_cwr(struct sock *sk)

{

	const struct inet_connection_sock *icsk = inet_csk(sk);

	struct tcp_sock *tp = tcp_sk(sk);



	tp->undo_marker = 0;

	tp->snd_ssthresh = tp->ca_ops->ssthresh(tp);

	tp->snd_ssthresh = icsk->icsk_ca_ops->ssthresh(sk);

	tp->snd_cwnd = min(tp->snd_cwnd,

			   tcp_packets_in_flight(tp) + 1U);

	tp->snd_cwnd_cnt = 0;
@@ -780,12 +788,14 @@ static inline void __tcp_enter_cwr(struct tcp_sock *tp) 
	TCP_ECN_queue_cwr(tp);

}



static inline void tcp_enter_cwr(struct tcp_sock *tp)

static inline void tcp_enter_cwr(struct sock *sk)

{

	struct tcp_sock *tp = tcp_sk(sk);



	tp->prior_ssthresh = 0;

	if (tp->ca_state < TCP_CA_CWR) {

		__tcp_enter_cwr(tp);

		tcp_set_ca_state(tp, TCP_CA_CWR);

	if (inet_csk(sk)->icsk_ca_state < TCP_CA_CWR) {

		__tcp_enter_cwr(sk);

		tcp_set_ca_state(sk, TCP_CA_CWR);

	}

}

net/ipv4/inet_connection_sock.c

+2 −1
Original line number Diff line number Diff line
@@ -509,6 +509,7 @@ struct sock *inet_csk_clone(struct sock *sk, const struct request_sock *req, 


		newicsk->icsk_retransmits = 0;

		newicsk->icsk_backoff	  = 0;

		newicsk->icsk_probes_out  = 0;



		/* Deinitialize accept_queue to trap illegal accesses. */

		memset(&newicsk->icsk_accept_queue, 0, sizeof(newicsk->icsk_accept_queue));

net/ipv4/tcp.c

+6 −6
Original line number Diff line number Diff line
@@ -1671,11 +1671,11 @@ int tcp_disconnect(struct sock *sk, int flags) 
		tp->write_seq = 1;

	icsk->icsk_backoff = 0;

	tp->snd_cwnd = 2;

	tp->probes_out = 0;

	icsk->icsk_probes_out = 0;

	tp->packets_out = 0;

	tp->snd_ssthresh = 0x7fffffff;

	tp->snd_cwnd_cnt = 0;

	tcp_set_ca_state(tp, TCP_CA_Open);

	tcp_set_ca_state(sk, TCP_CA_Open);

	tcp_clear_retrans(tp);

	inet_csk_delack_init(sk);

	sk->sk_send_head = NULL;
@@ -1718,7 +1718,7 @@ int tcp_setsockopt(struct sock *sk, int level, int optname, char __user *optval, 
		name[val] = 0;



		lock_sock(sk);

		err = tcp_set_congestion_control(tp, name);

		err = tcp_set_congestion_control(sk, name);

		release_sock(sk);

		return err;

	}
@@ -1886,9 +1886,9 @@ void tcp_get_info(struct sock *sk, struct tcp_info *info) 
	memset(info, 0, sizeof(*info));



	info->tcpi_state = sk->sk_state;

	info->tcpi_ca_state = tp->ca_state;

	info->tcpi_ca_state = icsk->icsk_ca_state;

	info->tcpi_retransmits = icsk->icsk_retransmits;

	info->tcpi_probes = tp->probes_out;

	info->tcpi_probes = icsk->icsk_probes_out;

	info->tcpi_backoff = icsk->icsk_backoff;



	if (tp->rx_opt.tstamp_ok)
@@ -2016,7 +2016,7 @@ int tcp_getsockopt(struct sock *sk, int level, int optname, char __user *optval, 
		len = min_t(unsigned int, len, TCP_CA_NAME_MAX);

		if (put_user(len, optlen))

			return -EFAULT;

		if (copy_to_user(optval, tp->ca_ops->name, len))

		if (copy_to_user(optval, icsk->icsk_ca_ops->name, len))

			return -EFAULT;

		return 0;

	default:

CRA Git | Maintained and supported by SUSTech CRA and CCSE