[NET]: Introduce inet_connection_sock

This creates struct inet_connection_sock, moving members out of struct
tcp_sock that are shareable with other INET connection oriented
protocols, such as DCCP, that in my private tree already uses most of
these members.

The functions that operate on these members were renamed, using a
inet_csk_ prefix while not being moved yet to a new file, so as to
ease the review of these changes.

Signed-off-by: Arnaldo Carvalho de Melo <acme@ghostprotocols.net>
Signed-off-by: David S. Miller <davem@davemloft.net>

9 files changed, 215 insertions, 159 deletions

diff --git a/include/linux/ip.h b/include/linux/ip.h
index 2c54bbd3da76..33e8a19a1a0f 100644
--- a/include/linux/ip.h
+++ b/include/linux/ip.h
@@ -128,7 +128,6 @@ static inline struct inet_request_sock *inet_rsk(const struct request_sock *sk)
         return (struct inet_request_sock *)sk;
 }
 
-struct inet_bind_bucket;
 struct ipv6_pinfo;
 
 struct inet_sock {
@@ -158,7 +157,6 @@ struct inet_sock {
         int                     mc_index;       /* Multicast device index */
         __u32                   mc_addr;
         struct ip_mc_socklist   *mc_list;       /* Group array */
-        struct inet_bind_bucket *bind_hash;
         /*
          * Following members are used to retain the infomation to build
          * an ip header on each ip fragmentation while the socket is corked.
diff --git a/include/linux/ipv6.h b/include/linux/ipv6.h
index 98fa32316e40..88591913c94f 100644
--- a/include/linux/ipv6.h
+++ b/include/linux/ipv6.h
@@ -333,15 +333,15 @@ static inline struct in6_addr *tcp_v6_rcv_saddr(const struct sock *sk)
         return sk->sk_family == AF_INET6 ? __tcp_v6_rcv_saddr(sk) : NULL;
 }
 
-static inline int tcp_twsk_ipv6only(const struct sock *sk)
+static inline int inet_twsk_ipv6only(const struct sock *sk)
 {
         return inet_twsk(sk)->tw_ipv6only;
 }
 
-static inline int tcp_v6_ipv6only(const struct sock *sk)
+static inline int inet_v6_ipv6only(const struct sock *sk)
 {
         return likely(sk->sk_state != TCP_TIME_WAIT) ?
-                ipv6_only_sock(sk) : tcp_twsk_ipv6only(sk);
+                ipv6_only_sock(sk) : inet_twsk_ipv6only(sk);
 }
 #else
 #define __ipv6_only_sock(sk)    0
@@ -360,7 +360,7 @@ static inline struct raw6_sock *raw6_sk(const struct sock *sk)
 #define __tcp_v6_rcv_saddr(__sk)        NULL
 #define tcp_v6_rcv_saddr(__sk)          NULL
 #define tcp_twsk_ipv6only(__sk)         0
-#define tcp_v6_ipv6only(__sk)           0
+#define inet_v6_ipv6only(__sk)          0
 #endif /* defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE) */
 
 #define INET6_MATCH(__sk, __saddr, __daddr, __ports, __dif)        \
diff --git a/include/linux/tcp.h b/include/linux/tcp.h
index 5d295b1b3de7..800930fac388 100644
--- a/include/linux/tcp.h
+++ b/include/linux/tcp.h
@@ -177,8 +177,8 @@ struct tcp_info
 
 #include <linux/config.h>
 #include <linux/skbuff.h>
-#include <linux/ip.h>
 #include <net/sock.h>
+#include <net/inet_connection_sock.h>
 #include <net/inet_timewait_sock.h>
 
 /* This defines a selective acknowledgement block. */
@@ -219,8 +219,8 @@ static inline struct tcp_request_sock *tcp_rsk(const struct request_sock *req)
 }
 
 struct tcp_sock {
-        /* inet_sock has to be the first member of tcp_sock */
-        struct inet_sock        inet;
+        /* inet_connection_sock has to be the first member of tcp_sock */
+        struct inet_connection_sock     inet_conn;
         int     tcp_header_len; /* Bytes of tcp header to send          */
 
 /*
@@ -241,18 +241,6 @@ struct tcp_sock {
         __u32   snd_sml;        /* Last byte of the most recently transmitted small packet */
         __u32   rcv_tstamp;     /* timestamp of last received ACK (for keepalives) */
         __u32   lsndtime;       /* timestamp of last sent data packet (for restart window) */
-        /* Delayed ACK control data */
-        struct {
-                __u8    pending;        /* ACK is pending */
-                __u8    quick;          /* Scheduled number of quick acks       */
-                __u8    pingpong;       /* The session is interactive           */
-                __u8    blocked;        /* Delayed ACK was blocked by socket lock*/
-                __u32   ato;            /* Predicted tick of soft clock         */
-                unsigned long timeout;  /* Currently scheduled timeout          */
-                __u32   lrcvtime;       /* timestamp of last received data packet*/
-                __u16   last_seg_size;  /* Size of last incoming segment        */
-                __u16   rcv_mss;        /* MSS used for delayed ACK decisions   */ 
-        } ack;
 
         /* Data for direct copy to user */
         struct {
@@ -271,8 +259,8 @@ struct tcp_sock {
         __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    retransmits;    /* Number of unrecovered RTO timeouts.  */
 
+        __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                 */
@@ -281,7 +269,7 @@ struct tcp_sock {
         __u8    reordering;     /* Packet reordering metric.            */
         __u8    frto_counter;   /* Number of new acks after RTO */
 
-        __u8    unused;
+        __u8    nonagle;        /* Disable Nagle algorithm?             */
         __u8    defer_accept;   /* User waits for some data after accept() */
 
 /* RTT measurement */
@@ -290,19 +278,13 @@ struct tcp_sock {
         __u32   mdev_max;       /* maximal mdev for the last rtt period */
         __u32   rttvar;         /* smoothed mdev_max                    */
         __u32   rtt_seq;        /* sequence number to update rttvar     */
-        __u32   rto;            /* retransmit timeout                   */
 
         __u32   packets_out;    /* Packets which are "in flight"        */
         __u32   left_out;       /* Packets which leaved network */
         __u32   retrans_out;    /* Retransmitted packets out            */
-        __u8    backoff;        /* backoff                              */
 /*
  *      Options received (usually on last packet, some only on SYN packets).
  */
-        __u8    nonagle;        /* Disable Nagle algorithm?             */
-        __u8    keepalive_probes; /* num of allowed keep alive probes   */
-
-        __u8    probes_out;     /* unanswered 0 window probes           */
         struct tcp_options_received rx_opt;
 
 /*
@@ -315,11 +297,6 @@ struct tcp_sock {
         __u32   snd_cwnd_used;
         __u32   snd_cwnd_stamp;
 
-        /* Two commonly used timers in both sender and receiver paths. */
-        unsigned long           timeout;
-        struct timer_list       retransmit_timer;       /* Resend (no ack)      */
-        struct timer_list       delack_timer;           /* Ack delay            */
-
         struct sk_buff_head     out_of_order_queue; /* Out of order segments go here */
 
         struct tcp_func         *af_specific;   /* Operations which are AF_INET{4,6} specific   */
@@ -334,7 +311,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    syn_retries;    /* num of allowed syn retries */
+        __u8    probes_out;     /* unanswered 0 window probes           */
         __u8    ecn_flags;      /* ECN status bits.                     */
         __u16   prior_ssthresh; /* ssthresh saved at recovery start     */
         __u32   lost_out;       /* Lost packets                 */
@@ -349,14 +326,12 @@ struct tcp_sock {
         int     undo_retrans;   /* number of undoable retransmissions. */
         __u32   urg_seq;        /* Seq of received urgent pointer */
         __u16   urg_data;       /* Saved octet of OOB data and control flags */
-        __u8    pending;        /* Scheduled timer event        */
         __u8    urg_mode;       /* In urgent mode               */
+        /* ONE BYTE HOLE, TRY TO PACK! */
         __u32   snd_up;         /* Urgent pointer               */
 
         __u32   total_retrans;  /* Total retransmits for entire connection */
 
-        struct request_sock_queue accept_queue; /* FIFO of established children */
-
         unsigned int            keepalive_time;   /* time before keep alive takes place */
         unsigned int            keepalive_intvl;  /* time interval between keep alive probes */
         int                     linger2;
diff --git a/include/net/inet_connection_sock.h b/include/net/inet_connection_sock.h
new file mode 100644
index 000000000000..ef609396e41b
--- /dev/null
+++ b/include/net/inet_connection_sock.h
@@ -0,0 +1,86 @@
+/*
+ * NET          Generic infrastructure for INET connection oriented protocols.
+ *
+ *              Definitions for inet_connection_sock 
+ *
+ * Authors:     Many people, see the TCP sources
+ *
+ *              From code originally in TCP
+ *
+ *              This program is free software; you can redistribute it and/or
+ *              modify it under the terms of the GNU General Public License
+ *              as published by the Free Software Foundation; either version
+ *              2 of the License, or (at your option) any later version.
+ */
+#ifndef _INET_CONNECTION_SOCK_H
+#define _INET_CONNECTION_SOCK_H
+
+#include <linux/ip.h>
+#include <linux/timer.h>
+#include <net/request_sock.h>
+
+struct inet_bind_bucket;
+struct inet_hashinfo;
+
+/** inet_connection_sock - INET connection oriented sock
+ *
+ * @icsk_accept_queue:     FIFO of established children 
+ * @icsk_bind_hash:        Bind node
+ * @icsk_timeout:          Timeout
+ * @icsk_retransmit_timer: Resend (no ack)
+ * @icsk_rto:              Retransmit timeout
+ * @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_ack:              Delayed ACK control data
+ */
+struct inet_connection_sock {
+        /* inet_sock has to be the first member! */
+        struct inet_sock          icsk_inet;
+        struct request_sock_queue icsk_accept_queue;
+        struct inet_bind_bucket   *icsk_bind_hash;
+        unsigned long             icsk_timeout;
+        struct timer_list         icsk_retransmit_timer;
+        struct timer_list         icsk_delack_timer;
+        __u32                     icsk_rto;
+        __u8                      icsk_retransmits;
+        __u8                      icsk_pending;
+        __u8                      icsk_backoff;
+        __u8                      icsk_syn_retries;
+        struct {
+                __u8              pending;       /* ACK is pending                         */
+                __u8              quick;         /* Scheduled number of quick acks         */
+                __u8              pingpong;      /* The session is interactive             */
+                __u8              blocked;       /* Delayed ACK was blocked by socket lock */
+                __u32             ato;           /* Predicted tick of soft clock           */
+                unsigned long     timeout;       /* Currently scheduled timeout            */
+                __u32             lrcvtime;      /* timestamp of last received data packet */
+                __u16             last_seg_size; /* Size of last incoming segment          */
+                __u16             rcv_mss;       /* MSS used for delayed ACK decisions     */ 
+        } icsk_ack;
+};
+
+static inline struct inet_connection_sock *inet_csk(const struct sock *sk)
+{
+        return (struct inet_connection_sock *)sk;
+}
+
+extern void inet_csk_init_xmit_timers(struct sock *sk,
+                                      void (*retransmit_handler)(unsigned long),
+                                      void (*delack_handler)(unsigned long),
+                                      void (*keepalive_handler)(unsigned long));
+extern void inet_csk_clear_xmit_timers(struct sock *sk);
+
+extern struct request_sock *inet_csk_search_req(const struct sock *sk,
+                                                struct request_sock ***prevp,
+                                                const __u16 rport,
+                                                const __u32 raddr,
+                                                const __u32 laddr);
+extern int inet_csk_get_port(struct inet_hashinfo *hashinfo,
+                             struct sock *sk, unsigned short snum);
+
+extern struct dst_entry* inet_csk_route_req(struct sock *sk,
+                                            const struct request_sock *req);
+
+#endif /* _INET_CONNECTION_SOCK_H */
diff --git a/include/net/inet_hashtables.h b/include/net/inet_hashtables.h
index b5c0d64ea741..f0c21c07f894 100644
--- a/include/net/inet_hashtables.h
+++ b/include/net/inet_hashtables.h
@@ -17,7 +17,6 @@
 #include <linux/config.h>
 
 #include <linux/interrupt.h>
-#include <linux/ip.h>
 #include <linux/ipv6.h>
 #include <linux/list.h>
 #include <linux/slab.h>
@@ -26,6 +25,7 @@
 #include <linux/types.h>
 #include <linux/wait.h>
 
+#include <net/inet_connection_sock.h>
 #include <net/sock.h>
 #include <net/tcp_states.h>
 
@@ -185,9 +185,9 @@ static inline void __inet_inherit_port(struct inet_hashinfo *table,
         struct inet_bind_bucket *tb;
 
         spin_lock(&head->lock);
-        tb = inet_sk(sk)->bind_hash;
+        tb = inet_csk(sk)->icsk_bind_hash;
         sk_add_bind_node(child, &tb->owners);
-        inet_sk(child)->bind_hash = tb;
+        inet_csk(child)->icsk_bind_hash = tb;
         spin_unlock(&head->lock);
 }
 
diff --git a/include/net/request_sock.h b/include/net/request_sock.h
index 334717bf9ef6..b7c7eecbe64d 100644
--- a/include/net/request_sock.h
+++ b/include/net/request_sock.h
@@ -224,17 +224,17 @@ static inline int reqsk_queue_added(struct request_sock_queue *queue)
         return prev_qlen;
 }
 
-static inline int reqsk_queue_len(struct request_sock_queue *queue)
+static inline int reqsk_queue_len(const struct request_sock_queue *queue)
 {
         return queue->listen_opt != NULL ? queue->listen_opt->qlen : 0;
 }
 
-static inline int reqsk_queue_len_young(struct request_sock_queue *queue)
+static inline int reqsk_queue_len_young(const struct request_sock_queue *queue)
 {
         return queue->listen_opt->qlen_young;
 }
 
-static inline int reqsk_queue_is_full(struct request_sock_queue *queue)
+static inline int reqsk_queue_is_full(const struct request_sock_queue *queue)
 {
         return queue->listen_opt->qlen >> queue->listen_opt->max_qlen_log;
 }
diff --git a/include/net/sock.h b/include/net/sock.h
index 828dc082fcb7..48cc337a6566 100644
--- a/include/net/sock.h
+++ b/include/net/sock.h
@@ -493,9 +493,6 @@ extern int sk_wait_data(struct sock *sk, long *timeo);
 
 struct request_sock_ops;
 
-/* Here is the right place to enable sock refcounting debugging */
-//#define SOCK_REFCNT_DEBUG
-
 /* Networking protocol blocks we attach to sockets.
  * socket layer -> transport layer interface
  * transport -> network interface is defined by struct inet_proto
diff --git a/include/net/tcp.h b/include/net/tcp.h
index cf8e664176ad..a943c79c88b0 100644
--- a/include/net/tcp.h
+++ b/include/net/tcp.h
@@ -19,10 +19,11 @@
 #define _TCP_H
 
 #define TCP_DEBUG 1
+#define INET_CSK_DEBUG 1
 #define FASTRETRANS_DEBUG 1
 
 /* Cancel timers, when they are not required. */
-#undef TCP_CLEAR_TIMERS
+#undef INET_CSK_CLEAR_TIMERS
 
 #include <linux/config.h>
 #include <linux/list.h>
@@ -205,10 +206,10 @@ extern void tcp_tw_deschedule(struct inet_timewait_sock *tw);
 #define TCPOLEN_SACK_BASE_ALIGNED       4
 #define TCPOLEN_SACK_PERBLOCK           8
 
-#define TCP_TIME_RETRANS        1       /* Retransmit timer */
-#define TCP_TIME_DACK           2       /* Delayed ack timer */
-#define TCP_TIME_PROBE0         3       /* Zero window probe timer */
-#define TCP_TIME_KEEPOPEN       4       /* Keepalive timer */
+#define ICSK_TIME_RETRANS       1       /* Retransmit timer */
+#define ICSK_TIME_DACK          2       /* Delayed ack timer */
+#define ICSK_TIME_PROBE0        3       /* Zero window probe timer */
+#define ICSK_TIME_KEEPOPEN      4       /* Keepalive timer */
 
 /* Flags in tp->nonagle */
 #define TCP_NAGLE_OFF           1       /* Nagle's algo is disabled */
@@ -257,9 +258,9 @@ extern atomic_t tcp_sockets_allocated;
 extern int tcp_memory_pressure;
 
 #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
-#define TCP_INET_FAMILY(fam) ((fam) == AF_INET)
+#define AF_INET_FAMILY(fam) ((fam) == AF_INET)
 #else
-#define TCP_INET_FAMILY(fam) 1
+#define AF_INET_FAMILY(fam) 1
 #endif
 
 /*
@@ -372,41 +373,42 @@ extern int			tcp_rcv_established(struct sock *sk,
 
 extern void                     tcp_rcv_space_adjust(struct sock *sk);
 
-enum tcp_ack_state_t
-{
-        TCP_ACK_SCHED = 1,
-        TCP_ACK_TIMER = 2,
-        TCP_ACK_PUSHED= 4
+enum inet_csk_ack_state_t {
+        ICSK_ACK_SCHED  = 1,
+        ICSK_ACK_TIMER  = 2,
+        ICSK_ACK_PUSHED = 4
 };
 
-static inline void tcp_schedule_ack(struct tcp_sock *tp)
+static inline void inet_csk_schedule_ack(struct sock *sk)
 {
-        tp->ack.pending |= TCP_ACK_SCHED;
+        inet_csk(sk)->icsk_ack.pending |= ICSK_ACK_SCHED;
 }
 
-static inline int tcp_ack_scheduled(struct tcp_sock *tp)
+static inline int inet_csk_ack_scheduled(const struct sock *sk)
 {
-        return tp->ack.pending&TCP_ACK_SCHED;
+        return inet_csk(sk)->icsk_ack.pending & ICSK_ACK_SCHED;
 }
 
-static __inline__ void tcp_dec_quickack_mode(struct tcp_sock *tp, unsigned int pkts)
+static inline void tcp_dec_quickack_mode(struct sock *sk,
+                                         const unsigned int pkts)
 {
-        if (tp->ack.quick) {
-                if (pkts >= tp->ack.quick) {
-                        tp->ack.quick = 0;
+        struct inet_connection_sock *icsk = inet_csk(sk);
 
+        if (icsk->icsk_ack.quick) {
+                if (pkts >= icsk->icsk_ack.quick) {
+                        icsk->icsk_ack.quick = 0;
                         /* Leaving quickack mode we deflate ATO. */
-                        tp->ack.ato = TCP_ATO_MIN;
+                        icsk->icsk_ack.ato   = TCP_ATO_MIN;
                 } else
-                        tp->ack.quick -= pkts;
+                        icsk->icsk_ack.quick -= pkts;
         }
 }
 
-extern void tcp_enter_quickack_mode(struct tcp_sock *tp);
+extern void tcp_enter_quickack_mode(struct sock *sk);
 
-static __inline__ void tcp_delack_init(struct tcp_sock *tp)
+static inline void inet_csk_delack_init(struct sock *sk)
 {
-        memset(&tp->ack, 0, sizeof(tp->ack));
+        memset(&inet_csk(sk)->icsk_ack, 0, sizeof(inet_csk(sk)->icsk_ack));
 }
 
 static inline void tcp_clear_options(struct tcp_options_received *rx_opt)
@@ -440,7 +442,7 @@ extern void			tcp_update_metrics(struct sock *sk);
 
 extern void                     tcp_close(struct sock *sk, 
                                           long timeout);
-extern struct sock *            tcp_accept(struct sock *sk, int flags, int *err);
+extern struct sock *            inet_csk_accept(struct sock *sk, int flags, int *err);
 extern unsigned int             tcp_poll(struct file * file, struct socket *sock, struct poll_table_struct *wait);
 
 extern int                      tcp_getsockopt(struct sock *sk, int level, 
@@ -534,15 +536,18 @@ extern void tcp_cwnd_application_limited(struct sock *sk);
 
 /* tcp_timer.c */
 extern void tcp_init_xmit_timers(struct sock *);
-extern void tcp_clear_xmit_timers(struct sock *);
+static inline void tcp_clear_xmit_timers(struct sock *sk)
+{
+        inet_csk_clear_xmit_timers(sk);
+}
 
-extern void tcp_delete_keepalive_timer(struct sock *);
-extern void tcp_reset_keepalive_timer(struct sock *, unsigned long);
+extern void inet_csk_delete_keepalive_timer(struct sock *sk);
+extern void inet_csk_reset_keepalive_timer(struct sock *sk, unsigned long timeout);
 extern unsigned int tcp_sync_mss(struct sock *sk, u32 pmtu);
 extern unsigned int tcp_current_mss(struct sock *sk, int large);
 
-#ifdef TCP_DEBUG
-extern const char tcp_timer_bug_msg[];
+#ifdef INET_CSK_DEBUG
+extern const char inet_csk_timer_bug_msg[];
 #endif
 
 /* tcp_diag.c */
@@ -554,70 +559,58 @@ typedef int (*sk_read_actor_t)(read_descriptor_t *, struct sk_buff *,
 extern int tcp_read_sock(struct sock *sk, read_descriptor_t *desc,
                          sk_read_actor_t recv_actor);
 
-static inline void tcp_clear_xmit_timer(struct sock *sk, int what)
+static inline void inet_csk_clear_xmit_timer(struct sock *sk, const int what)
 {
-        struct tcp_sock *tp = tcp_sk(sk);
+        struct inet_connection_sock *icsk = inet_csk(sk);
         
-        switch (what) {
-        case TCP_TIME_RETRANS:
-        case TCP_TIME_PROBE0:
-                tp->pending = 0;
-
-#ifdef TCP_CLEAR_TIMERS
-                sk_stop_timer(sk, &tp->retransmit_timer);
+        if (what == ICSK_TIME_RETRANS || what == ICSK_TIME_PROBE0) {
+                icsk->icsk_pending = 0;
+#ifdef INET_CSK_CLEAR_TIMERS
+                sk_stop_timer(sk, &icsk->icsk_retransmit_timer);
 #endif
-                break;
-        case TCP_TIME_DACK:
-                tp->ack.blocked = 0;
-                tp->ack.pending = 0;
-
-#ifdef TCP_CLEAR_TIMERS
-                sk_stop_timer(sk, &tp->delack_timer);
+        } else if (what == ICSK_TIME_DACK) {
+                icsk->icsk_ack.blocked = icsk->icsk_ack.pending = 0;
+#ifdef INET_CSK_CLEAR_TIMERS
+                sk_stop_timer(sk, &icsk->icsk_delack_timer);
 #endif
-                break;
-        default:
-#ifdef TCP_DEBUG
-                printk(tcp_timer_bug_msg);
+        }
+#ifdef INET_CSK_DEBUG
+        else {
+                pr_debug(inet_csk_timer_bug_msg);
+        }
 #endif
-                return;
-        };
-
 }
 
 /*
  *      Reset the retransmission timer
  */
-static inline void tcp_reset_xmit_timer(struct sock *sk, int what, unsigned long when)
+static inline void inet_csk_reset_xmit_timer(struct sock *sk, const int what,
+                                             unsigned long when)
 {
-        struct tcp_sock *tp = tcp_sk(sk);
+        struct inet_connection_sock *icsk = inet_csk(sk);
 
         if (when > TCP_RTO_MAX) {
-#ifdef TCP_DEBUG
-                printk(KERN_DEBUG "reset_xmit_timer sk=%p %d when=0x%lx, caller=%p\n", sk, what, when, current_text_addr());
+#ifdef INET_CSK_DEBUG
+                pr_debug("reset_xmit_timer: sk=%p %d when=0x%lx, caller=%p\n",
+                         sk, what, when, current_text_addr());
 #endif
                 when = TCP_RTO_MAX;
         }
 
-        switch (what) {
-        case TCP_TIME_RETRANS:
-        case TCP_TIME_PROBE0:
-                tp->pending = what;
-                tp->timeout = jiffies+when;
-                sk_reset_timer(sk, &tp->retransmit_timer, tp->timeout);
-                break;
-
-        case TCP_TIME_DACK:
-                tp->ack.pending |= TCP_ACK_TIMER;
-                tp->ack.timeout = jiffies+when;
-                sk_reset_timer(sk, &tp->delack_timer, tp->ack.timeout);
-                break;
-
-        default:
-#ifdef TCP_DEBUG
-                printk(tcp_timer_bug_msg);
+        if (what == ICSK_TIME_RETRANS || what == ICSK_TIME_PROBE0) {
+                icsk->icsk_pending = what;
+                icsk->icsk_timeout = jiffies + when;
+                sk_reset_timer(sk, &icsk->icsk_retransmit_timer, icsk->icsk_timeout);
+        } else if (what == ICSK_TIME_DACK) {
+                icsk->icsk_ack.pending |= ICSK_ACK_TIMER;
+                icsk->icsk_ack.timeout = jiffies + when;
+                sk_reset_timer(sk, &icsk->icsk_delack_timer, icsk->icsk_ack.timeout);
+        }
+#ifdef INET_CSK_DEBUG
+        else {
+                pr_debug(inet_csk_timer_bug_msg);
+        }
 #endif
-                return;
-        };
 }
 
 /* Initialize RCV_MSS value.
@@ -637,7 +630,7 @@ static inline void tcp_initialize_rcv_mss(struct sock *sk)
         hint = min(hint, TCP_MIN_RCVMSS);
         hint = max(hint, TCP_MIN_MSS);
 
-        tp->ack.rcv_mss = hint;
+        inet_csk(sk)->icsk_ack.rcv_mss = hint;
 }
 
 static __inline__ void __tcp_fast_path_on(struct tcp_sock *tp, u32 snd_wnd)
@@ -772,7 +765,7 @@ static inline void tcp_packets_out_inc(struct sock *sk,
 
         tp->packets_out += tcp_skb_pcount(skb);
         if (!orig)
-                tcp_reset_xmit_timer(sk, TCP_TIME_RETRANS, tp->rto);
+                inet_csk_reset_xmit_timer(sk, ICSK_TIME_RETRANS, inet_csk(sk)->icsk_rto);
 }
 
 static inline void tcp_packets_out_dec(struct tcp_sock *tp, 
@@ -939,8 +932,9 @@ static __inline__ void tcp_minshall_update(struct tcp_sock *tp, int mss,
 
 static __inline__ void tcp_check_probe_timer(struct sock *sk, struct tcp_sock *tp)
 {
-        if (!tp->packets_out && !tp->pending)
-                tcp_reset_xmit_timer(sk, TCP_TIME_PROBE0, tp->rto);
+        const struct inet_connection_sock *icsk = inet_csk(sk);
+        if (!tp->packets_out && !icsk->icsk_pending)
+                inet_csk_reset_xmit_timer(sk, ICSK_TIME_PROBE0, icsk->icsk_rto);
 }
 
 static __inline__ void tcp_push_pending_frames(struct sock *sk,
@@ -1021,8 +1015,9 @@ static __inline__ int tcp_prequeue(struct sock *sk, struct sk_buff *skb)
                         tp->ucopy.memory = 0;
                 } else if (skb_queue_len(&tp->ucopy.prequeue) == 1) {
                         wake_up_interruptible(sk->sk_sleep);
-                        if (!tcp_ack_scheduled(tp))
-                                tcp_reset_xmit_timer(sk, TCP_TIME_DACK, (3*TCP_RTO_MIN)/4);
+                        if (!inet_csk_ack_scheduled(sk))
+                                inet_csk_reset_xmit_timer(sk, ICSK_TIME_DACK,
+                                                          (3 * TCP_RTO_MIN) / 4);
                 }
                 return 1;
         }
@@ -1055,7 +1050,7 @@ static __inline__ void tcp_set_state(struct sock *sk, int state)
                         TCP_INC_STATS(TCP_MIB_ESTABRESETS);
 
                 sk->sk_prot->unhash(sk);
-                if (inet_sk(sk)->bind_hash &&
+                if (inet_csk(sk)->icsk_bind_hash &&
                     !(sk->sk_userlocks & SOCK_BINDPORT_LOCK))
                         inet_put_port(&tcp_hashinfo, sk);
                 /* fall through */
@@ -1186,51 +1181,55 @@ static inline int tcp_full_space(const struct sock *sk)
         return tcp_win_from_space(sk->sk_rcvbuf); 
 }
 
-static inline void tcp_acceptq_queue(struct sock *sk, struct request_sock *req,
-                                         struct sock *child)
+static inline void inet_csk_reqsk_queue_add(struct sock *sk,
+                                            struct request_sock *req,
+                                            struct sock *child)
 {
-        reqsk_queue_add(&tcp_sk(sk)->accept_queue, req, sk, child);
+        reqsk_queue_add(&inet_csk(sk)->icsk_accept_queue, req, sk, child);
 }
 
-static inline void
-tcp_synq_removed(struct sock *sk, struct request_sock *req)
+static inline void inet_csk_reqsk_queue_removed(struct sock *sk,
+                                                struct request_sock *req)
 {
-        if (reqsk_queue_removed(&tcp_sk(sk)->accept_queue, req) == 0)
-                tcp_delete_keepalive_timer(sk);
+        if (reqsk_queue_removed(&inet_csk(sk)->icsk_accept_queue, req) == 0)
+                inet_csk_delete_keepalive_timer(sk);
 }
 
-static inline void tcp_synq_added(struct sock *sk)
+static inline void inet_csk_reqsk_queue_added(struct sock *sk,
+                                              const unsigned long timeout)
 {
-        if (reqsk_queue_added(&tcp_sk(sk)->accept_queue) == 0)
-                tcp_reset_keepalive_timer(sk, TCP_TIMEOUT_INIT);
+        if (reqsk_queue_added(&inet_csk(sk)->icsk_accept_queue) == 0)
+                inet_csk_reset_keepalive_timer(sk, timeout);
 }
 
-static inline int tcp_synq_len(struct sock *sk)
+static inline int inet_csk_reqsk_queue_len(const struct sock *sk)
 {
-        return reqsk_queue_len(&tcp_sk(sk)->accept_queue);
+        return reqsk_queue_len(&inet_csk(sk)->icsk_accept_queue);
 }
 
-static inline int tcp_synq_young(struct sock *sk)
+static inline int inet_csk_reqsk_queue_young(const struct sock *sk)
 {
-        return reqsk_queue_len_young(&tcp_sk(sk)->accept_queue);
+        return reqsk_queue_len_young(&inet_csk(sk)->icsk_accept_queue);
 }
 
-static inline int tcp_synq_is_full(struct sock *sk)
+static inline int inet_csk_reqsk_queue_is_full(const struct sock *sk)
 {
-        return reqsk_queue_is_full(&tcp_sk(sk)->accept_queue);
+        return reqsk_queue_is_full(&inet_csk(sk)->icsk_accept_queue);
 }
 
-static inline void tcp_synq_unlink(struct tcp_sock *tp, struct request_sock *req,
-                                   struct request_sock **prev)
+static inline void inet_csk_reqsk_queue_unlink(struct sock *sk,
+                                               struct request_sock *req,
+                                               struct request_sock **prev)
 {
-        reqsk_queue_unlink(&tp->accept_queue, req, prev);
+        reqsk_queue_unlink(&inet_csk(sk)->icsk_accept_queue, req, prev);
 }
 
-static inline void tcp_synq_drop(struct sock *sk, struct request_sock *req,
-                                     struct request_sock **prev)
+static inline void inet_csk_reqsk_queue_drop(struct sock *sk,
+                                             struct request_sock *req,
+                                             struct request_sock **prev)
 {
-        tcp_synq_unlink(tcp_sk(sk), req, prev);
-        tcp_synq_removed(sk, req);
+        inet_csk_reqsk_queue_unlink(sk, req, prev);
+        inet_csk_reqsk_queue_removed(sk, req);
         reqsk_free(req);
 }
 
@@ -1265,12 +1264,13 @@ static inline int keepalive_time_when(const struct tcp_sock *tp)
         return tp->keepalive_time ? : sysctl_tcp_keepalive_time;
 }
 
-static inline int tcp_fin_time(const struct tcp_sock *tp)
+static inline int tcp_fin_time(const struct sock *sk)
 {
-        int fin_timeout = tp->linger2 ? : sysctl_tcp_fin_timeout;
+        int fin_timeout = tcp_sk(sk)->linger2 ? : sysctl_tcp_fin_timeout;
+        const int rto = inet_csk(sk)->icsk_rto;
 
-        if (fin_timeout < (tp->rto<<2) - (tp->rto>>1))
-                fin_timeout = (tp->rto<<2) - (tp->rto>>1);
+        if (fin_timeout < (rto << 2) - (rto >> 1))
+                fin_timeout = (rto << 2) - (rto >> 1);
 
         return fin_timeout;
 }
diff --git a/include/net/tcp_ecn.h b/include/net/tcp_ecn.h
index 64980ee8c92a..c6b84397448d 100644
--- a/include/net/tcp_ecn.h
+++ b/include/net/tcp_ecn.h
@@ -88,7 +88,7 @@ static inline void TCP_ECN_check_ce(struct tcp_sock *tp, struct sk_buff *skb)
                  * it is surely retransmit. It is not in ECN RFC,
                  * but Linux follows this rule. */
                 else if (INET_ECN_is_not_ect((TCP_SKB_CB(skb)->flags)))
-                        tcp_enter_quickack_mode(tp);
+                        tcp_enter_quickack_mode((struct sock *)tp);
         }
 }