[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: Arnaldo Carvalho de Melo <acme@mandriva.com>
Signed-off-by: David S. Miller <davem@davemloft.net>

2 files changed, 57 insertions, 32 deletions

diff --git a/include/net/inet_connection_sock.h b/include/net/inet_connection_sock.h
index bec19d5cff26..4d7e708c07d1 100644
--- a/include/net/inet_connection_sock.h
+++ b/include/net/inet_connection_sock.h
@@ -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);
diff --git a/include/net/tcp.h b/include/net/tcp.h
index d489ac548e4b..0b3f7294c5c7 100644
--- a/include/net/tcp.h
+++ b/include/net/tcp.h
@@ -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);
         }
 }