aboutsummaryrefslogtreecommitdiffstats
path: root/net/ipv4
diff options
context:
space:
mode:
Diffstat (limited to 'net/ipv4')
-rw-r--r--net/ipv4/inet_hashtables.c15
-rw-r--r--net/ipv4/inet_timewait_sock.c5
-rw-r--r--net/ipv4/syncookies.c2
-rw-r--r--net/ipv4/tcp.c90
-rw-r--r--net/ipv4/tcp_diag.c21
-rw-r--r--net/ipv4/tcp_input.c266
-rw-r--r--net/ipv4/tcp_ipv4.c158
-rw-r--r--net/ipv4/tcp_minisocks.c28
-rw-r--r--net/ipv4/tcp_output.c86
-rw-r--r--net/ipv4/tcp_timer.c165
10 files changed, 440 insertions, 396 deletions
diff --git a/net/ipv4/inet_hashtables.c b/net/ipv4/inet_hashtables.c
index d94e962958a4..e8d29fe736d2 100644
--- a/net/ipv4/inet_hashtables.c
+++ b/net/ipv4/inet_hashtables.c
@@ -19,6 +19,7 @@
19#include <linux/slab.h> 19#include <linux/slab.h>
20#include <linux/wait.h> 20#include <linux/wait.h>
21 21
22#include <net/inet_connection_sock.h>
22#include <net/inet_hashtables.h> 23#include <net/inet_hashtables.h>
23 24
24/* 25/*
@@ -56,10 +57,9 @@ void inet_bind_bucket_destroy(kmem_cache_t *cachep, struct inet_bind_bucket *tb)
56void inet_bind_hash(struct sock *sk, struct inet_bind_bucket *tb, 57void inet_bind_hash(struct sock *sk, struct inet_bind_bucket *tb,
57 const unsigned short snum) 58 const unsigned short snum)
58{ 59{
59 struct inet_sock *inet = inet_sk(sk); 60 inet_sk(sk)->num = snum;
60 inet->num = snum;
61 sk_add_bind_node(sk, &tb->owners); 61 sk_add_bind_node(sk, &tb->owners);
62 inet->bind_hash = tb; 62 inet_csk(sk)->icsk_bind_hash = tb;
63} 63}
64 64
65EXPORT_SYMBOL(inet_bind_hash); 65EXPORT_SYMBOL(inet_bind_hash);
@@ -69,16 +69,15 @@ EXPORT_SYMBOL(inet_bind_hash);
69 */ 69 */
70static void __inet_put_port(struct inet_hashinfo *hashinfo, struct sock *sk) 70static void __inet_put_port(struct inet_hashinfo *hashinfo, struct sock *sk)
71{ 71{
72 struct inet_sock *inet = inet_sk(sk); 72 const int bhash = inet_bhashfn(inet_sk(sk)->num, hashinfo->bhash_size);
73 const int bhash = inet_bhashfn(inet->num, hashinfo->bhash_size);
74 struct inet_bind_hashbucket *head = &hashinfo->bhash[bhash]; 73 struct inet_bind_hashbucket *head = &hashinfo->bhash[bhash];
75 struct inet_bind_bucket *tb; 74 struct inet_bind_bucket *tb;
76 75
77 spin_lock(&head->lock); 76 spin_lock(&head->lock);
78 tb = inet->bind_hash; 77 tb = inet_csk(sk)->icsk_bind_hash;
79 __sk_del_bind_node(sk); 78 __sk_del_bind_node(sk);
80 inet->bind_hash = NULL; 79 inet_csk(sk)->icsk_bind_hash = NULL;
81 inet->num = 0; 80 inet_sk(sk)->num = 0;
82 inet_bind_bucket_destroy(hashinfo->bind_bucket_cachep, tb); 81 inet_bind_bucket_destroy(hashinfo->bind_bucket_cachep, tb);
83 spin_unlock(&head->lock); 82 spin_unlock(&head->lock);
84} 83}
diff --git a/net/ipv4/inet_timewait_sock.c b/net/ipv4/inet_timewait_sock.c
index ceb577c74237..5cba59b869fe 100644
--- a/net/ipv4/inet_timewait_sock.c
+++ b/net/ipv4/inet_timewait_sock.c
@@ -56,6 +56,7 @@ void __inet_twsk_hashdance(struct inet_timewait_sock *tw, struct sock *sk,
56 struct inet_hashinfo *hashinfo) 56 struct inet_hashinfo *hashinfo)
57{ 57{
58 const struct inet_sock *inet = inet_sk(sk); 58 const struct inet_sock *inet = inet_sk(sk);
59 const struct inet_connection_sock *icsk = inet_csk(sk);
59 struct inet_ehash_bucket *ehead = &hashinfo->ehash[sk->sk_hashent]; 60 struct inet_ehash_bucket *ehead = &hashinfo->ehash[sk->sk_hashent];
60 struct inet_bind_hashbucket *bhead; 61 struct inet_bind_hashbucket *bhead;
61 /* Step 1: Put TW into bind hash. Original socket stays there too. 62 /* Step 1: Put TW into bind hash. Original socket stays there too.
@@ -64,8 +65,8 @@ void __inet_twsk_hashdance(struct inet_timewait_sock *tw, struct sock *sk,
64 */ 65 */
65 bhead = &hashinfo->bhash[inet_bhashfn(inet->num, hashinfo->bhash_size)]; 66 bhead = &hashinfo->bhash[inet_bhashfn(inet->num, hashinfo->bhash_size)];
66 spin_lock(&bhead->lock); 67 spin_lock(&bhead->lock);
67 tw->tw_tb = inet->bind_hash; 68 tw->tw_tb = icsk->icsk_bind_hash;
68 BUG_TRAP(inet->bind_hash); 69 BUG_TRAP(icsk->icsk_bind_hash);
69 inet_twsk_add_bind_node(tw, &tw->tw_tb->owners); 70 inet_twsk_add_bind_node(tw, &tw->tw_tb->owners);
70 spin_unlock(&bhead->lock); 71 spin_unlock(&bhead->lock);
71 72
diff --git a/net/ipv4/syncookies.c b/net/ipv4/syncookies.c
index 72d014442185..8692cb9d4bdb 100644
--- a/net/ipv4/syncookies.c
+++ b/net/ipv4/syncookies.c
@@ -180,7 +180,7 @@ static inline struct sock *get_cookie_sock(struct sock *sk, struct sk_buff *skb,
180 180
181 child = tp->af_specific->syn_recv_sock(sk, skb, req, dst); 181 child = tp->af_specific->syn_recv_sock(sk, skb, req, dst);
182 if (child) 182 if (child)
183 tcp_acceptq_queue(sk, req, child); 183 inet_csk_reqsk_queue_add(sk, req, child);
184 else 184 else
185 reqsk_free(req); 185 reqsk_free(req);
186 186
diff --git a/net/ipv4/tcp.c b/net/ipv4/tcp.c
index f1a708bf7a97..8177b86570db 100644
--- a/net/ipv4/tcp.c
+++ b/net/ipv4/tcp.c
@@ -313,7 +313,7 @@ EXPORT_SYMBOL(tcp_enter_memory_pressure);
313static __inline__ unsigned int tcp_listen_poll(struct sock *sk, 313static __inline__ unsigned int tcp_listen_poll(struct sock *sk,
314 poll_table *wait) 314 poll_table *wait)
315{ 315{
316 return !reqsk_queue_empty(&tcp_sk(sk)->accept_queue) ? (POLLIN | POLLRDNORM) : 0; 316 return !reqsk_queue_empty(&inet_csk(sk)->icsk_accept_queue) ? (POLLIN | POLLRDNORM) : 0;
317} 317}
318 318
319/* 319/*
@@ -458,15 +458,15 @@ int tcp_ioctl(struct sock *sk, int cmd, unsigned long arg)
458int tcp_listen_start(struct sock *sk) 458int tcp_listen_start(struct sock *sk)
459{ 459{
460 struct inet_sock *inet = inet_sk(sk); 460 struct inet_sock *inet = inet_sk(sk);
461 struct tcp_sock *tp = tcp_sk(sk); 461 struct inet_connection_sock *icsk = inet_csk(sk);
462 int rc = reqsk_queue_alloc(&tp->accept_queue, TCP_SYNQ_HSIZE); 462 int rc = reqsk_queue_alloc(&icsk->icsk_accept_queue, TCP_SYNQ_HSIZE);
463 463
464 if (rc != 0) 464 if (rc != 0)
465 return rc; 465 return rc;
466 466
467 sk->sk_max_ack_backlog = 0; 467 sk->sk_max_ack_backlog = 0;
468 sk->sk_ack_backlog = 0; 468 sk->sk_ack_backlog = 0;
469 tcp_delack_init(tp); 469 inet_csk_delack_init(sk);
470 470
471 /* There is race window here: we announce ourselves listening, 471 /* There is race window here: we announce ourselves listening,
472 * but this transition is still not validated by get_port(). 472 * but this transition is still not validated by get_port().
@@ -484,7 +484,7 @@ int tcp_listen_start(struct sock *sk)
484 } 484 }
485 485
486 sk->sk_state = TCP_CLOSE; 486 sk->sk_state = TCP_CLOSE;
487 __reqsk_queue_destroy(&tp->accept_queue); 487 __reqsk_queue_destroy(&icsk->icsk_accept_queue);
488 return -EADDRINUSE; 488 return -EADDRINUSE;
489} 489}
490 490
@@ -495,14 +495,14 @@ int tcp_listen_start(struct sock *sk)
495 495
496static void tcp_listen_stop (struct sock *sk) 496static void tcp_listen_stop (struct sock *sk)
497{ 497{
498 struct tcp_sock *tp = tcp_sk(sk); 498 struct inet_connection_sock *icsk = inet_csk(sk);
499 struct request_sock *acc_req; 499 struct request_sock *acc_req;
500 struct request_sock *req; 500 struct request_sock *req;
501 501
502 tcp_delete_keepalive_timer(sk); 502 inet_csk_delete_keepalive_timer(sk);
503 503
504 /* make all the listen_opt local to us */ 504 /* make all the listen_opt local to us */
505 acc_req = reqsk_queue_yank_acceptq(&tp->accept_queue); 505 acc_req = reqsk_queue_yank_acceptq(&icsk->icsk_accept_queue);
506 506
507 /* Following specs, it would be better either to send FIN 507 /* Following specs, it would be better either to send FIN
508 * (and enter FIN-WAIT-1, it is normal close) 508 * (and enter FIN-WAIT-1, it is normal close)
@@ -512,7 +512,7 @@ static void tcp_listen_stop (struct sock *sk)
512 * To be honest, we are not able to make either 512 * To be honest, we are not able to make either
513 * of the variants now. --ANK 513 * of the variants now. --ANK
514 */ 514 */
515 reqsk_queue_destroy(&tp->accept_queue); 515 reqsk_queue_destroy(&icsk->icsk_accept_queue);
516 516
517 while ((req = acc_req) != NULL) { 517 while ((req = acc_req) != NULL) {
518 struct sock *child = req->sk; 518 struct sock *child = req->sk;
@@ -1039,20 +1039,21 @@ static void cleanup_rbuf(struct sock *sk, int copied)
1039 BUG_TRAP(!skb || before(tp->copied_seq, TCP_SKB_CB(skb)->end_seq)); 1039 BUG_TRAP(!skb || before(tp->copied_seq, TCP_SKB_CB(skb)->end_seq));
1040#endif 1040#endif
1041 1041
1042 if (tcp_ack_scheduled(tp)) { 1042 if (inet_csk_ack_scheduled(sk)) {
1043 const struct inet_connection_sock *icsk = inet_csk(sk);
1043 /* Delayed ACKs frequently hit locked sockets during bulk 1044 /* Delayed ACKs frequently hit locked sockets during bulk
1044 * receive. */ 1045 * receive. */
1045 if (tp->ack.blocked || 1046 if (icsk->icsk_ack.blocked ||
1046 /* Once-per-two-segments ACK was not sent by tcp_input.c */ 1047 /* Once-per-two-segments ACK was not sent by tcp_input.c */
1047 tp->rcv_nxt - tp->rcv_wup > tp->ack.rcv_mss || 1048 tp->rcv_nxt - tp->rcv_wup > icsk->icsk_ack.rcv_mss ||
1048 /* 1049 /*
1049 * If this read emptied read buffer, we send ACK, if 1050 * If this read emptied read buffer, we send ACK, if
1050 * connection is not bidirectional, user drained 1051 * connection is not bidirectional, user drained
1051 * receive buffer and there was a small segment 1052 * receive buffer and there was a small segment
1052 * in queue. 1053 * in queue.
1053 */ 1054 */
1054 (copied > 0 && (tp->ack.pending & TCP_ACK_PUSHED) && 1055 (copied > 0 && (icsk->icsk_ack.pending & ICSK_ACK_PUSHED) &&
1055 !tp->ack.pingpong && !atomic_read(&sk->sk_rmem_alloc))) 1056 !icsk->icsk_ack.pingpong && !atomic_read(&sk->sk_rmem_alloc)))
1056 time_to_ack = 1; 1057 time_to_ack = 1;
1057 } 1058 }
1058 1059
@@ -1569,7 +1570,7 @@ void tcp_destroy_sock(struct sock *sk)
1569 BUG_TRAP(sk_unhashed(sk)); 1570 BUG_TRAP(sk_unhashed(sk));
1570 1571
1571 /* If it has not 0 inet_sk(sk)->num, it must be bound */ 1572 /* If it has not 0 inet_sk(sk)->num, it must be bound */
1572 BUG_TRAP(!inet_sk(sk)->num || inet_sk(sk)->bind_hash); 1573 BUG_TRAP(!inet_sk(sk)->num || inet_csk(sk)->icsk_bind_hash);
1573 1574
1574 sk->sk_prot->destroy(sk); 1575 sk->sk_prot->destroy(sk);
1575 1576
@@ -1698,10 +1699,10 @@ adjudge_to_death:
1698 tcp_send_active_reset(sk, GFP_ATOMIC); 1699 tcp_send_active_reset(sk, GFP_ATOMIC);
1699 NET_INC_STATS_BH(LINUX_MIB_TCPABORTONLINGER); 1700 NET_INC_STATS_BH(LINUX_MIB_TCPABORTONLINGER);
1700 } else { 1701 } else {
1701 int tmo = tcp_fin_time(tp); 1702 const int tmo = tcp_fin_time(sk);
1702 1703
1703 if (tmo > TCP_TIMEWAIT_LEN) { 1704 if (tmo > TCP_TIMEWAIT_LEN) {
1704 tcp_reset_keepalive_timer(sk, tcp_fin_time(tp)); 1705 inet_csk_reset_keepalive_timer(sk, tcp_fin_time(sk));
1705 } else { 1706 } else {
1706 atomic_inc(&tcp_orphan_count); 1707 atomic_inc(&tcp_orphan_count);
1707 tcp_time_wait(sk, TCP_FIN_WAIT2, tmo); 1708 tcp_time_wait(sk, TCP_FIN_WAIT2, tmo);
@@ -1746,6 +1747,7 @@ static inline int tcp_need_reset(int state)
1746int tcp_disconnect(struct sock *sk, int flags) 1747int tcp_disconnect(struct sock *sk, int flags)
1747{ 1748{
1748 struct inet_sock *inet = inet_sk(sk); 1749 struct inet_sock *inet = inet_sk(sk);
1750 struct inet_connection_sock *icsk = inet_csk(sk);
1749 struct tcp_sock *tp = tcp_sk(sk); 1751 struct tcp_sock *tp = tcp_sk(sk);
1750 int err = 0; 1752 int err = 0;
1751 int old_state = sk->sk_state; 1753 int old_state = sk->sk_state;
@@ -1782,7 +1784,7 @@ int tcp_disconnect(struct sock *sk, int flags)
1782 tp->srtt = 0; 1784 tp->srtt = 0;
1783 if ((tp->write_seq += tp->max_window + 2) == 0) 1785 if ((tp->write_seq += tp->max_window + 2) == 0)
1784 tp->write_seq = 1; 1786 tp->write_seq = 1;
1785 tp->backoff = 0; 1787 icsk->icsk_backoff = 0;
1786 tp->snd_cwnd = 2; 1788 tp->snd_cwnd = 2;
1787 tp->probes_out = 0; 1789 tp->probes_out = 0;
1788 tp->packets_out = 0; 1790 tp->packets_out = 0;
@@ -1790,13 +1792,13 @@ int tcp_disconnect(struct sock *sk, int flags)
1790 tp->snd_cwnd_cnt = 0; 1792 tp->snd_cwnd_cnt = 0;
1791 tcp_set_ca_state(tp, TCP_CA_Open); 1793 tcp_set_ca_state(tp, TCP_CA_Open);
1792 tcp_clear_retrans(tp); 1794 tcp_clear_retrans(tp);
1793 tcp_delack_init(tp); 1795 inet_csk_delack_init(sk);
1794 sk->sk_send_head = NULL; 1796 sk->sk_send_head = NULL;
1795 tp->rx_opt.saw_tstamp = 0; 1797 tp->rx_opt.saw_tstamp = 0;
1796 tcp_sack_reset(&tp->rx_opt); 1798 tcp_sack_reset(&tp->rx_opt);
1797 __sk_dst_reset(sk); 1799 __sk_dst_reset(sk);
1798 1800
1799 BUG_TRAP(!inet->num || inet->bind_hash); 1801 BUG_TRAP(!inet->num || icsk->icsk_bind_hash);
1800 1802
1801 sk->sk_error_report(sk); 1803 sk->sk_error_report(sk);
1802 return err; 1804 return err;
@@ -1808,7 +1810,7 @@ int tcp_disconnect(struct sock *sk, int flags)
1808 */ 1810 */
1809static int wait_for_connect(struct sock *sk, long timeo) 1811static int wait_for_connect(struct sock *sk, long timeo)
1810{ 1812{
1811 struct tcp_sock *tp = tcp_sk(sk); 1813 struct inet_connection_sock *icsk = inet_csk(sk);
1812 DEFINE_WAIT(wait); 1814 DEFINE_WAIT(wait);
1813 int err; 1815 int err;
1814 1816
@@ -1830,11 +1832,11 @@ static int wait_for_connect(struct sock *sk, long timeo)
1830 prepare_to_wait_exclusive(sk->sk_sleep, &wait, 1832 prepare_to_wait_exclusive(sk->sk_sleep, &wait,
1831 TASK_INTERRUPTIBLE); 1833 TASK_INTERRUPTIBLE);
1832 release_sock(sk); 1834 release_sock(sk);
1833 if (reqsk_queue_empty(&tp->accept_queue)) 1835 if (reqsk_queue_empty(&icsk->icsk_accept_queue))
1834 timeo = schedule_timeout(timeo); 1836 timeo = schedule_timeout(timeo);
1835 lock_sock(sk); 1837 lock_sock(sk);
1836 err = 0; 1838 err = 0;
1837 if (!reqsk_queue_empty(&tp->accept_queue)) 1839 if (!reqsk_queue_empty(&icsk->icsk_accept_queue))
1838 break; 1840 break;
1839 err = -EINVAL; 1841 err = -EINVAL;
1840 if (sk->sk_state != TCP_LISTEN) 1842 if (sk->sk_state != TCP_LISTEN)
@@ -1854,9 +1856,9 @@ static int wait_for_connect(struct sock *sk, long timeo)
1854 * This will accept the next outstanding connection. 1856 * This will accept the next outstanding connection.
1855 */ 1857 */
1856 1858
1857struct sock *tcp_accept(struct sock *sk, int flags, int *err) 1859struct sock *inet_csk_accept(struct sock *sk, int flags, int *err)
1858{ 1860{
1859 struct tcp_sock *tp = tcp_sk(sk); 1861 struct inet_connection_sock *icsk = inet_csk(sk);
1860 struct sock *newsk; 1862 struct sock *newsk;
1861 int error; 1863 int error;
1862 1864
@@ -1870,7 +1872,7 @@ struct sock *tcp_accept(struct sock *sk, int flags, int *err)
1870 goto out_err; 1872 goto out_err;
1871 1873
1872 /* Find already established connection */ 1874 /* Find already established connection */
1873 if (reqsk_queue_empty(&tp->accept_queue)) { 1875 if (reqsk_queue_empty(&icsk->icsk_accept_queue)) {
1874 long timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK); 1876 long timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK);
1875 1877
1876 /* If this is a non blocking socket don't sleep */ 1878 /* If this is a non blocking socket don't sleep */
@@ -1883,7 +1885,7 @@ struct sock *tcp_accept(struct sock *sk, int flags, int *err)
1883 goto out_err; 1885 goto out_err;
1884 } 1886 }
1885 1887
1886 newsk = reqsk_queue_get_child(&tp->accept_queue, sk); 1888 newsk = reqsk_queue_get_child(&icsk->icsk_accept_queue, sk);
1887 BUG_TRAP(newsk->sk_state != TCP_SYN_RECV); 1889 BUG_TRAP(newsk->sk_state != TCP_SYN_RECV);
1888out: 1890out:
1889 release_sock(sk); 1891 release_sock(sk);
@@ -1901,6 +1903,7 @@ int tcp_setsockopt(struct sock *sk, int level, int optname, char __user *optval,
1901 int optlen) 1903 int optlen)
1902{ 1904{
1903 struct tcp_sock *tp = tcp_sk(sk); 1905 struct tcp_sock *tp = tcp_sk(sk);
1906 struct inet_connection_sock *icsk = inet_csk(sk);
1904 int val; 1907 int val;
1905 int err = 0; 1908 int err = 0;
1906 1909
@@ -1999,7 +2002,7 @@ int tcp_setsockopt(struct sock *sk, int level, int optname, char __user *optval,
1999 elapsed = tp->keepalive_time - elapsed; 2002 elapsed = tp->keepalive_time - elapsed;
2000 else 2003 else
2001 elapsed = 0; 2004 elapsed = 0;
2002 tcp_reset_keepalive_timer(sk, elapsed); 2005 inet_csk_reset_keepalive_timer(sk, elapsed);
2003 } 2006 }
2004 } 2007 }
2005 break; 2008 break;
@@ -2019,7 +2022,7 @@ int tcp_setsockopt(struct sock *sk, int level, int optname, char __user *optval,
2019 if (val < 1 || val > MAX_TCP_SYNCNT) 2022 if (val < 1 || val > MAX_TCP_SYNCNT)
2020 err = -EINVAL; 2023 err = -EINVAL;
2021 else 2024 else
2022 tp->syn_retries = val; 2025 icsk->icsk_syn_retries = val;
2023 break; 2026 break;
2024 2027
2025 case TCP_LINGER2: 2028 case TCP_LINGER2:
@@ -2058,16 +2061,16 @@ int tcp_setsockopt(struct sock *sk, int level, int optname, char __user *optval,
2058 2061
2059 case TCP_QUICKACK: 2062 case TCP_QUICKACK:
2060 if (!val) { 2063 if (!val) {
2061 tp->ack.pingpong = 1; 2064 icsk->icsk_ack.pingpong = 1;
2062 } else { 2065 } else {
2063 tp->ack.pingpong = 0; 2066 icsk->icsk_ack.pingpong = 0;
2064 if ((1 << sk->sk_state) & 2067 if ((1 << sk->sk_state) &
2065 (TCPF_ESTABLISHED | TCPF_CLOSE_WAIT) && 2068 (TCPF_ESTABLISHED | TCPF_CLOSE_WAIT) &&
2066 tcp_ack_scheduled(tp)) { 2069 inet_csk_ack_scheduled(sk)) {
2067 tp->ack.pending |= TCP_ACK_PUSHED; 2070 icsk->icsk_ack.pending |= ICSK_ACK_PUSHED;
2068 cleanup_rbuf(sk, 1); 2071 cleanup_rbuf(sk, 1);
2069 if (!(val & 1)) 2072 if (!(val & 1))
2070 tp->ack.pingpong = 1; 2073 icsk->icsk_ack.pingpong = 1;
2071 } 2074 }
2072 } 2075 }
2073 break; 2076 break;
@@ -2084,15 +2087,16 @@ int tcp_setsockopt(struct sock *sk, int level, int optname, char __user *optval,
2084void tcp_get_info(struct sock *sk, struct tcp_info *info) 2087void tcp_get_info(struct sock *sk, struct tcp_info *info)
2085{ 2088{
2086 struct tcp_sock *tp = tcp_sk(sk); 2089 struct tcp_sock *tp = tcp_sk(sk);
2090 const struct inet_connection_sock *icsk = inet_csk(sk);
2087 u32 now = tcp_time_stamp; 2091 u32 now = tcp_time_stamp;
2088 2092
2089 memset(info, 0, sizeof(*info)); 2093 memset(info, 0, sizeof(*info));
2090 2094
2091 info->tcpi_state = sk->sk_state; 2095 info->tcpi_state = sk->sk_state;
2092 info->tcpi_ca_state = tp->ca_state; 2096 info->tcpi_ca_state = tp->ca_state;
2093 info->tcpi_retransmits = tp->retransmits; 2097 info->tcpi_retransmits = icsk->icsk_retransmits;
2094 info->tcpi_probes = tp->probes_out; 2098 info->tcpi_probes = tp->probes_out;
2095 info->tcpi_backoff = tp->backoff; 2099 info->tcpi_backoff = icsk->icsk_backoff;
2096 2100
2097 if (tp->rx_opt.tstamp_ok) 2101 if (tp->rx_opt.tstamp_ok)
2098 info->tcpi_options |= TCPI_OPT_TIMESTAMPS; 2102 info->tcpi_options |= TCPI_OPT_TIMESTAMPS;
@@ -2107,10 +2111,10 @@ void tcp_get_info(struct sock *sk, struct tcp_info *info)
2107 if (tp->ecn_flags&TCP_ECN_OK) 2111 if (tp->ecn_flags&TCP_ECN_OK)
2108 info->tcpi_options |= TCPI_OPT_ECN; 2112 info->tcpi_options |= TCPI_OPT_ECN;
2109 2113
2110 info->tcpi_rto = jiffies_to_usecs(tp->rto); 2114 info->tcpi_rto = jiffies_to_usecs(icsk->icsk_rto);
2111 info->tcpi_ato = jiffies_to_usecs(tp->ack.ato); 2115 info->tcpi_ato = jiffies_to_usecs(icsk->icsk_ack.ato);
2112 info->tcpi_snd_mss = tp->mss_cache; 2116 info->tcpi_snd_mss = tp->mss_cache;
2113 info->tcpi_rcv_mss = tp->ack.rcv_mss; 2117 info->tcpi_rcv_mss = icsk->icsk_ack.rcv_mss;
2114 2118
2115 info->tcpi_unacked = tp->packets_out; 2119 info->tcpi_unacked = tp->packets_out;
2116 info->tcpi_sacked = tp->sacked_out; 2120 info->tcpi_sacked = tp->sacked_out;
@@ -2119,7 +2123,7 @@ void tcp_get_info(struct sock *sk, struct tcp_info *info)
2119 info->tcpi_fackets = tp->fackets_out; 2123 info->tcpi_fackets = tp->fackets_out;
2120 2124
2121 info->tcpi_last_data_sent = jiffies_to_msecs(now - tp->lsndtime); 2125 info->tcpi_last_data_sent = jiffies_to_msecs(now - tp->lsndtime);
2122 info->tcpi_last_data_recv = jiffies_to_msecs(now - tp->ack.lrcvtime); 2126 info->tcpi_last_data_recv = jiffies_to_msecs(now - icsk->icsk_ack.lrcvtime);
2123 info->tcpi_last_ack_recv = jiffies_to_msecs(now - tp->rcv_tstamp); 2127 info->tcpi_last_ack_recv = jiffies_to_msecs(now - tp->rcv_tstamp);
2124 2128
2125 info->tcpi_pmtu = tp->pmtu_cookie; 2129 info->tcpi_pmtu = tp->pmtu_cookie;
@@ -2179,7 +2183,7 @@ int tcp_getsockopt(struct sock *sk, int level, int optname, char __user *optval,
2179 val = tp->keepalive_probes ? : sysctl_tcp_keepalive_probes; 2183 val = tp->keepalive_probes ? : sysctl_tcp_keepalive_probes;
2180 break; 2184 break;
2181 case TCP_SYNCNT: 2185 case TCP_SYNCNT:
2182 val = tp->syn_retries ? : sysctl_tcp_syn_retries; 2186 val = inet_csk(sk)->icsk_syn_retries ? : sysctl_tcp_syn_retries;
2183 break; 2187 break;
2184 case TCP_LINGER2: 2188 case TCP_LINGER2:
2185 val = tp->linger2; 2189 val = tp->linger2;
@@ -2209,7 +2213,7 @@ int tcp_getsockopt(struct sock *sk, int level, int optname, char __user *optval,
2209 return 0; 2213 return 0;
2210 } 2214 }
2211 case TCP_QUICKACK: 2215 case TCP_QUICKACK:
2212 val = !tp->ack.pingpong; 2216 val = !inet_csk(sk)->icsk_ack.pingpong;
2213 break; 2217 break;
2214 2218
2215 case TCP_CONGESTION: 2219 case TCP_CONGESTION:
@@ -2340,7 +2344,7 @@ void __init tcp_init(void)
2340 tcp_register_congestion_control(&tcp_reno); 2344 tcp_register_congestion_control(&tcp_reno);
2341} 2345}
2342 2346
2343EXPORT_SYMBOL(tcp_accept); 2347EXPORT_SYMBOL(inet_csk_accept);
2344EXPORT_SYMBOL(tcp_close); 2348EXPORT_SYMBOL(tcp_close);
2345EXPORT_SYMBOL(tcp_destroy_sock); 2349EXPORT_SYMBOL(tcp_destroy_sock);
2346EXPORT_SYMBOL(tcp_disconnect); 2350EXPORT_SYMBOL(tcp_disconnect);
diff --git a/net/ipv4/tcp_diag.c b/net/ipv4/tcp_diag.c
index 60c6a797cc50..5f4c74f45e82 100644
--- a/net/ipv4/tcp_diag.c
+++ b/net/ipv4/tcp_diag.c
@@ -48,8 +48,9 @@ static struct sock *tcpnl;
48static int tcpdiag_fill(struct sk_buff *skb, struct sock *sk, 48static int tcpdiag_fill(struct sk_buff *skb, struct sock *sk,
49 int ext, u32 pid, u32 seq, u16 nlmsg_flags) 49 int ext, u32 pid, u32 seq, u16 nlmsg_flags)
50{ 50{
51 struct inet_sock *inet = inet_sk(sk); 51 const struct inet_sock *inet = inet_sk(sk);
52 struct tcp_sock *tp = tcp_sk(sk); 52 struct tcp_sock *tp = tcp_sk(sk);
53 const struct inet_connection_sock *icsk = inet_csk(sk);
53 struct tcpdiagmsg *r; 54 struct tcpdiagmsg *r;
54 struct nlmsghdr *nlh; 55 struct nlmsghdr *nlh;
55 struct tcp_info *info = NULL; 56 struct tcp_info *info = NULL;
@@ -129,14 +130,14 @@ static int tcpdiag_fill(struct sk_buff *skb, struct sock *sk,
129 130
130#define EXPIRES_IN_MS(tmo) ((tmo-jiffies)*1000+HZ-1)/HZ 131#define EXPIRES_IN_MS(tmo) ((tmo-jiffies)*1000+HZ-1)/HZ
131 132
132 if (tp->pending == TCP_TIME_RETRANS) { 133 if (icsk->icsk_pending == ICSK_TIME_RETRANS) {
133 r->tcpdiag_timer = 1; 134 r->tcpdiag_timer = 1;
134 r->tcpdiag_retrans = tp->retransmits; 135 r->tcpdiag_retrans = icsk->icsk_retransmits;
135 r->tcpdiag_expires = EXPIRES_IN_MS(tp->timeout); 136 r->tcpdiag_expires = EXPIRES_IN_MS(icsk->icsk_timeout);
136 } else if (tp->pending == TCP_TIME_PROBE0) { 137 } else if (icsk->icsk_pending == ICSK_TIME_PROBE0) {
137 r->tcpdiag_timer = 4; 138 r->tcpdiag_timer = 4;
138 r->tcpdiag_retrans = tp->probes_out; 139 r->tcpdiag_retrans = tp->probes_out;
139 r->tcpdiag_expires = EXPIRES_IN_MS(tp->timeout); 140 r->tcpdiag_expires = EXPIRES_IN_MS(icsk->icsk_timeout);
140 } else if (timer_pending(&sk->sk_timer)) { 141 } else if (timer_pending(&sk->sk_timer)) {
141 r->tcpdiag_timer = 2; 142 r->tcpdiag_timer = 2;
142 r->tcpdiag_retrans = tp->probes_out; 143 r->tcpdiag_retrans = tp->probes_out;
@@ -497,7 +498,7 @@ static int tcpdiag_dump_reqs(struct sk_buff *skb, struct sock *sk,
497{ 498{
498 struct tcpdiag_entry entry; 499 struct tcpdiag_entry entry;
499 struct tcpdiagreq *r = NLMSG_DATA(cb->nlh); 500 struct tcpdiagreq *r = NLMSG_DATA(cb->nlh);
500 struct tcp_sock *tp = tcp_sk(sk); 501 struct inet_connection_sock *icsk = inet_csk(sk);
501 struct listen_sock *lopt; 502 struct listen_sock *lopt;
502 struct rtattr *bc = NULL; 503 struct rtattr *bc = NULL;
503 struct inet_sock *inet = inet_sk(sk); 504 struct inet_sock *inet = inet_sk(sk);
@@ -513,9 +514,9 @@ static int tcpdiag_dump_reqs(struct sk_buff *skb, struct sock *sk,
513 514
514 entry.family = sk->sk_family; 515 entry.family = sk->sk_family;
515 516
516 read_lock_bh(&tp->accept_queue.syn_wait_lock); 517 read_lock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
517 518
518 lopt = tp->accept_queue.listen_opt; 519 lopt = icsk->icsk_accept_queue.listen_opt;
519 if (!lopt || !lopt->qlen) 520 if (!lopt || !lopt->qlen)
520 goto out; 521 goto out;
521 522
@@ -572,7 +573,7 @@ static int tcpdiag_dump_reqs(struct sk_buff *skb, struct sock *sk,
572 } 573 }
573 574
574out: 575out:
575 read_unlock_bh(&tp->accept_queue.syn_wait_lock); 576 read_unlock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
576 577
577 return err; 578 return err;
578} 579}
diff --git a/net/ipv4/tcp_input.c b/net/ipv4/tcp_input.c
index ffa24025cd02..8a8c5c2d90cb 100644
--- a/net/ipv4/tcp_input.c
+++ b/net/ipv4/tcp_input.c
@@ -114,20 +114,21 @@ int sysctl_tcp_moderate_rcvbuf = 1;
114/* Adapt the MSS value used to make delayed ack decision to the 114/* Adapt the MSS value used to make delayed ack decision to the
115 * real world. 115 * real world.
116 */ 116 */
117static inline void tcp_measure_rcv_mss(struct tcp_sock *tp, 117static inline void tcp_measure_rcv_mss(struct sock *sk,
118 struct sk_buff *skb) 118 const struct sk_buff *skb)
119{ 119{
120 unsigned int len, lss; 120 struct inet_connection_sock *icsk = inet_csk(sk);
121 const unsigned int lss = icsk->icsk_ack.last_seg_size;
122 unsigned int len;
121 123
122 lss = tp->ack.last_seg_size; 124 icsk->icsk_ack.last_seg_size = 0;
123 tp->ack.last_seg_size = 0;
124 125
125 /* skb->len may jitter because of SACKs, even if peer 126 /* skb->len may jitter because of SACKs, even if peer
126 * sends good full-sized frames. 127 * sends good full-sized frames.
127 */ 128 */
128 len = skb->len; 129 len = skb->len;
129 if (len >= tp->ack.rcv_mss) { 130 if (len >= icsk->icsk_ack.rcv_mss) {
130 tp->ack.rcv_mss = len; 131 icsk->icsk_ack.rcv_mss = len;
131 } else { 132 } else {
132 /* Otherwise, we make more careful check taking into account, 133 /* Otherwise, we make more careful check taking into account,
133 * that SACKs block is variable. 134 * that SACKs block is variable.
@@ -147,41 +148,44 @@ static inline void tcp_measure_rcv_mss(struct tcp_sock *tp,
147 * tcp header plus fixed timestamp option length. 148 * tcp header plus fixed timestamp option length.
148 * Resulting "len" is MSS free of SACK jitter. 149 * Resulting "len" is MSS free of SACK jitter.
149 */ 150 */
150 len -= tp->tcp_header_len; 151 len -= tcp_sk(sk)->tcp_header_len;
151 tp->ack.last_seg_size = len; 152 icsk->icsk_ack.last_seg_size = len;
152 if (len == lss) { 153 if (len == lss) {
153 tp->ack.rcv_mss = len; 154 icsk->icsk_ack.rcv_mss = len;
154 return; 155 return;
155 } 156 }
156 } 157 }
157 tp->ack.pending |= TCP_ACK_PUSHED; 158 icsk->icsk_ack.pending |= ICSK_ACK_PUSHED;
158 } 159 }
159} 160}
160 161
161static void tcp_incr_quickack(struct tcp_sock *tp) 162static void tcp_incr_quickack(struct sock *sk)
162{ 163{
163 unsigned quickacks = tp->rcv_wnd/(2*tp->ack.rcv_mss); 164 struct inet_connection_sock *icsk = inet_csk(sk);
165 unsigned quickacks = tcp_sk(sk)->rcv_wnd / (2 * icsk->icsk_ack.rcv_mss);
164 166
165 if (quickacks==0) 167 if (quickacks==0)
166 quickacks=2; 168 quickacks=2;
167 if (quickacks > tp->ack.quick) 169 if (quickacks > icsk->icsk_ack.quick)
168 tp->ack.quick = min(quickacks, TCP_MAX_QUICKACKS); 170 icsk->icsk_ack.quick = min(quickacks, TCP_MAX_QUICKACKS);
169} 171}
170 172
171void tcp_enter_quickack_mode(struct tcp_sock *tp) 173void tcp_enter_quickack_mode(struct sock *sk)
172{ 174{
173 tcp_incr_quickack(tp); 175 struct inet_connection_sock *icsk = inet_csk(sk);
174 tp->ack.pingpong = 0; 176 tcp_incr_quickack(sk);
175 tp->ack.ato = TCP_ATO_MIN; 177 icsk->icsk_ack.pingpong = 0;
178 icsk->icsk_ack.ato = TCP_ATO_MIN;
176} 179}
177 180
178/* Send ACKs quickly, if "quick" count is not exhausted 181/* Send ACKs quickly, if "quick" count is not exhausted
179 * and the session is not interactive. 182 * and the session is not interactive.
180 */ 183 */
181 184
182static __inline__ int tcp_in_quickack_mode(struct tcp_sock *tp) 185static inline int tcp_in_quickack_mode(const struct sock *sk)
183{ 186{
184 return (tp->ack.quick && !tp->ack.pingpong); 187 const struct inet_connection_sock *icsk = inet_csk(sk);
188 return icsk->icsk_ack.quick && !icsk->icsk_ack.pingpong;
185} 189}
186 190
187/* Buffer size and advertised window tuning. 191/* Buffer size and advertised window tuning.
@@ -224,8 +228,8 @@ static void tcp_fixup_sndbuf(struct sock *sk)
224 */ 228 */
225 229
226/* Slow part of check#2. */ 230/* Slow part of check#2. */
227static int __tcp_grow_window(struct sock *sk, struct tcp_sock *tp, 231static int __tcp_grow_window(const struct sock *sk, struct tcp_sock *tp,
228 struct sk_buff *skb) 232 const struct sk_buff *skb)
229{ 233{
230 /* Optimize this! */ 234 /* Optimize this! */
231 int truesize = tcp_win_from_space(skb->truesize)/2; 235 int truesize = tcp_win_from_space(skb->truesize)/2;
@@ -233,7 +237,7 @@ static int __tcp_grow_window(struct sock *sk, struct tcp_sock *tp,
233 237
234 while (tp->rcv_ssthresh <= window) { 238 while (tp->rcv_ssthresh <= window) {
235 if (truesize <= skb->len) 239 if (truesize <= skb->len)
236 return 2*tp->ack.rcv_mss; 240 return 2 * inet_csk(sk)->icsk_ack.rcv_mss;
237 241
238 truesize >>= 1; 242 truesize >>= 1;
239 window >>= 1; 243 window >>= 1;
@@ -260,7 +264,7 @@ static inline void tcp_grow_window(struct sock *sk, struct tcp_sock *tp,
260 264
261 if (incr) { 265 if (incr) {
262 tp->rcv_ssthresh = min(tp->rcv_ssthresh + incr, tp->window_clamp); 266 tp->rcv_ssthresh = min(tp->rcv_ssthresh + incr, tp->window_clamp);
263 tp->ack.quick |= 1; 267 inet_csk(sk)->icsk_ack.quick |= 1;
264 } 268 }
265 } 269 }
266} 270}
@@ -325,7 +329,7 @@ static void tcp_clamp_window(struct sock *sk, struct tcp_sock *tp)
325 unsigned int app_win = tp->rcv_nxt - tp->copied_seq; 329 unsigned int app_win = tp->rcv_nxt - tp->copied_seq;
326 int ofo_win = 0; 330 int ofo_win = 0;
327 331
328 tp->ack.quick = 0; 332 inet_csk(sk)->icsk_ack.quick = 0;
329 333
330 skb_queue_walk(&tp->out_of_order_queue, skb) { 334 skb_queue_walk(&tp->out_of_order_queue, skb) {
331 ofo_win += skb->len; 335 ofo_win += skb->len;
@@ -346,8 +350,8 @@ static void tcp_clamp_window(struct sock *sk, struct tcp_sock *tp)
346 app_win += ofo_win; 350 app_win += ofo_win;
347 if (atomic_read(&sk->sk_rmem_alloc) >= 2 * sk->sk_rcvbuf) 351 if (atomic_read(&sk->sk_rmem_alloc) >= 2 * sk->sk_rcvbuf)
348 app_win >>= 1; 352 app_win >>= 1;
349 if (app_win > tp->ack.rcv_mss) 353 if (app_win > inet_csk(sk)->icsk_ack.rcv_mss)
350 app_win -= tp->ack.rcv_mss; 354 app_win -= inet_csk(sk)->icsk_ack.rcv_mss;
351 app_win = max(app_win, 2U*tp->advmss); 355 app_win = max(app_win, 2U*tp->advmss);
352 356
353 if (!ofo_win) 357 if (!ofo_win)
@@ -415,11 +419,12 @@ new_measure:
415 tp->rcv_rtt_est.time = tcp_time_stamp; 419 tp->rcv_rtt_est.time = tcp_time_stamp;
416} 420}
417 421
418static inline void tcp_rcv_rtt_measure_ts(struct tcp_sock *tp, struct sk_buff *skb) 422static inline void tcp_rcv_rtt_measure_ts(struct sock *sk, const struct sk_buff *skb)
419{ 423{
424 struct tcp_sock *tp = tcp_sk(sk);
420 if (tp->rx_opt.rcv_tsecr && 425 if (tp->rx_opt.rcv_tsecr &&
421 (TCP_SKB_CB(skb)->end_seq - 426 (TCP_SKB_CB(skb)->end_seq -
422 TCP_SKB_CB(skb)->seq >= tp->ack.rcv_mss)) 427 TCP_SKB_CB(skb)->seq >= inet_csk(sk)->icsk_ack.rcv_mss))
423 tcp_rcv_rtt_update(tp, tcp_time_stamp - tp->rx_opt.rcv_tsecr, 0); 428 tcp_rcv_rtt_update(tp, tcp_time_stamp - tp->rx_opt.rcv_tsecr, 0);
424} 429}
425 430
@@ -492,41 +497,42 @@ new_measure:
492 */ 497 */
493static void tcp_event_data_recv(struct sock *sk, struct tcp_sock *tp, struct sk_buff *skb) 498static void tcp_event_data_recv(struct sock *sk, struct tcp_sock *tp, struct sk_buff *skb)
494{ 499{
500 struct inet_connection_sock *icsk = inet_csk(sk);
495 u32 now; 501 u32 now;
496 502
497 tcp_schedule_ack(tp); 503 inet_csk_schedule_ack(sk);
498 504
499 tcp_measure_rcv_mss(tp, skb); 505 tcp_measure_rcv_mss(sk, skb);
500 506
501 tcp_rcv_rtt_measure(tp); 507 tcp_rcv_rtt_measure(tp);
502 508
503 now = tcp_time_stamp; 509 now = tcp_time_stamp;
504 510
505 if (!tp->ack.ato) { 511 if (!icsk->icsk_ack.ato) {
506 /* The _first_ data packet received, initialize 512 /* The _first_ data packet received, initialize
507 * delayed ACK engine. 513 * delayed ACK engine.
508 */ 514 */
509 tcp_incr_quickack(tp); 515 tcp_incr_quickack(sk);
510 tp->ack.ato = TCP_ATO_MIN; 516 icsk->icsk_ack.ato = TCP_ATO_MIN;
511 } else { 517 } else {
512 int m = now - tp->ack.lrcvtime; 518 int m = now - icsk->icsk_ack.lrcvtime;
513 519
514 if (m <= TCP_ATO_MIN/2) { 520 if (m <= TCP_ATO_MIN/2) {
515 /* The fastest case is the first. */ 521 /* The fastest case is the first. */
516 tp->ack.ato = (tp->ack.ato>>1) + TCP_ATO_MIN/2; 522 icsk->icsk_ack.ato = (icsk->icsk_ack.ato >> 1) + TCP_ATO_MIN / 2;
517 } else if (m < tp->ack.ato) { 523 } else if (m < icsk->icsk_ack.ato) {
518 tp->ack.ato = (tp->ack.ato>>1) + m; 524 icsk->icsk_ack.ato = (icsk->icsk_ack.ato >> 1) + m;
519 if (tp->ack.ato > tp->rto) 525 if (icsk->icsk_ack.ato > icsk->icsk_rto)
520 tp->ack.ato = tp->rto; 526 icsk->icsk_ack.ato = icsk->icsk_rto;
521 } else if (m > tp->rto) { 527 } else if (m > icsk->icsk_rto) {
522 /* Too long gap. Apparently sender falled to 528 /* Too long gap. Apparently sender falled to
523 * restart window, so that we send ACKs quickly. 529 * restart window, so that we send ACKs quickly.
524 */ 530 */
525 tcp_incr_quickack(tp); 531 tcp_incr_quickack(sk);
526 sk_stream_mem_reclaim(sk); 532 sk_stream_mem_reclaim(sk);
527 } 533 }
528 } 534 }
529 tp->ack.lrcvtime = now; 535 icsk->icsk_ack.lrcvtime = now;
530 536
531 TCP_ECN_check_ce(tp, skb); 537 TCP_ECN_check_ce(tp, skb);
532 538
@@ -611,8 +617,9 @@ static void tcp_rtt_estimator(struct tcp_sock *tp, __u32 mrtt, u32 *usrtt)
611/* Calculate rto without backoff. This is the second half of Van Jacobson's 617/* Calculate rto without backoff. This is the second half of Van Jacobson's
612 * routine referred to above. 618 * routine referred to above.
613 */ 619 */
614static inline void tcp_set_rto(struct tcp_sock *tp) 620static inline void tcp_set_rto(struct sock *sk)
615{ 621{
622 const struct tcp_sock *tp = tcp_sk(sk);
616 /* Old crap is replaced with new one. 8) 623 /* Old crap is replaced with new one. 8)
617 * 624 *
618 * More seriously: 625 * More seriously:
@@ -623,7 +630,7 @@ static inline void tcp_set_rto(struct tcp_sock *tp)
623 * is invisible. Actually, Linux-2.4 also generates erratic 630 * is invisible. Actually, Linux-2.4 also generates erratic
624 * ACKs in some curcumstances. 631 * ACKs in some curcumstances.
625 */ 632 */
626 tp->rto = (tp->srtt >> 3) + tp->rttvar; 633 inet_csk(sk)->icsk_rto = (tp->srtt >> 3) + tp->rttvar;
627 634
628 /* 2. Fixups made earlier cannot be right. 635 /* 2. Fixups made earlier cannot be right.
629 * If we do not estimate RTO correctly without them, 636 * If we do not estimate RTO correctly without them,
@@ -635,10 +642,10 @@ static inline void tcp_set_rto(struct tcp_sock *tp)
635/* NOTE: clamping at TCP_RTO_MIN is not required, current algo 642/* NOTE: clamping at TCP_RTO_MIN is not required, current algo
636 * guarantees that rto is higher. 643 * guarantees that rto is higher.
637 */ 644 */
638static inline void tcp_bound_rto(struct tcp_sock *tp) 645static inline void tcp_bound_rto(struct sock *sk)
639{ 646{
640 if (tp->rto > TCP_RTO_MAX) 647 if (inet_csk(sk)->icsk_rto > TCP_RTO_MAX)
641 tp->rto = TCP_RTO_MAX; 648 inet_csk(sk)->icsk_rto = TCP_RTO_MAX;
642} 649}
643 650
644/* Save metrics learned by this TCP session. 651/* Save metrics learned by this TCP session.
@@ -658,7 +665,7 @@ void tcp_update_metrics(struct sock *sk)
658 if (dst && (dst->flags&DST_HOST)) { 665 if (dst && (dst->flags&DST_HOST)) {
659 int m; 666 int m;
660 667
661 if (tp->backoff || !tp->srtt) { 668 if (inet_csk(sk)->icsk_backoff || !tp->srtt) {
662 /* This session failed to estimate rtt. Why? 669 /* This session failed to estimate rtt. Why?
663 * Probably, no packets returned in time. 670 * Probably, no packets returned in time.
664 * Reset our results. 671 * Reset our results.
@@ -801,9 +808,9 @@ static void tcp_init_metrics(struct sock *sk)
801 tp->mdev = dst_metric(dst, RTAX_RTTVAR); 808 tp->mdev = dst_metric(dst, RTAX_RTTVAR);
802 tp->mdev_max = tp->rttvar = max(tp->mdev, TCP_RTO_MIN); 809 tp->mdev_max = tp->rttvar = max(tp->mdev, TCP_RTO_MIN);
803 } 810 }
804 tcp_set_rto(tp); 811 tcp_set_rto(sk);
805 tcp_bound_rto(tp); 812 tcp_bound_rto(sk);
806 if (tp->rto < TCP_TIMEOUT_INIT && !tp->rx_opt.saw_tstamp) 813 if (inet_csk(sk)->icsk_rto < TCP_TIMEOUT_INIT && !tp->rx_opt.saw_tstamp)
807 goto reset; 814 goto reset;
808 tp->snd_cwnd = tcp_init_cwnd(tp, dst); 815 tp->snd_cwnd = tcp_init_cwnd(tp, dst);
809 tp->snd_cwnd_stamp = tcp_time_stamp; 816 tp->snd_cwnd_stamp = tcp_time_stamp;
@@ -817,7 +824,7 @@ reset:
817 if (!tp->rx_opt.saw_tstamp && tp->srtt) { 824 if (!tp->rx_opt.saw_tstamp && tp->srtt) {
818 tp->srtt = 0; 825 tp->srtt = 0;
819 tp->mdev = tp->mdev_max = tp->rttvar = TCP_TIMEOUT_INIT; 826 tp->mdev = tp->mdev_max = tp->rttvar = TCP_TIMEOUT_INIT;
820 tp->rto = TCP_TIMEOUT_INIT; 827 inet_csk(sk)->icsk_rto = TCP_TIMEOUT_INIT;
821 } 828 }
822} 829}
823 830
@@ -1118,7 +1125,7 @@ void tcp_enter_frto(struct sock *sk)
1118 1125
1119 if (tp->ca_state <= TCP_CA_Disorder || 1126 if (tp->ca_state <= TCP_CA_Disorder ||
1120 tp->snd_una == tp->high_seq || 1127 tp->snd_una == tp->high_seq ||
1121 (tp->ca_state == TCP_CA_Loss && !tp->retransmits)) { 1128 (tp->ca_state == TCP_CA_Loss && !inet_csk(sk)->icsk_retransmits)) {
1122 tp->prior_ssthresh = tcp_current_ssthresh(tp); 1129 tp->prior_ssthresh = tcp_current_ssthresh(tp);
1123 tp->snd_ssthresh = tp->ca_ops->ssthresh(tp); 1130 tp->snd_ssthresh = tp->ca_ops->ssthresh(tp);
1124 tcp_ca_event(tp, CA_EVENT_FRTO); 1131 tcp_ca_event(tp, CA_EVENT_FRTO);
@@ -1214,7 +1221,7 @@ void tcp_enter_loss(struct sock *sk, int how)
1214 1221
1215 /* Reduce ssthresh if it has not yet been made inside this window. */ 1222 /* Reduce ssthresh if it has not yet been made inside this window. */
1216 if (tp->ca_state <= TCP_CA_Disorder || tp->snd_una == tp->high_seq || 1223 if (tp->ca_state <= TCP_CA_Disorder || tp->snd_una == tp->high_seq ||
1217 (tp->ca_state == TCP_CA_Loss && !tp->retransmits)) { 1224 (tp->ca_state == TCP_CA_Loss && !inet_csk(sk)->icsk_retransmits)) {
1218 tp->prior_ssthresh = tcp_current_ssthresh(tp); 1225 tp->prior_ssthresh = tcp_current_ssthresh(tp);
1219 tp->snd_ssthresh = tp->ca_ops->ssthresh(tp); 1226 tp->snd_ssthresh = tp->ca_ops->ssthresh(tp);
1220 tcp_ca_event(tp, CA_EVENT_LOSS); 1227 tcp_ca_event(tp, CA_EVENT_LOSS);
@@ -1253,7 +1260,7 @@ void tcp_enter_loss(struct sock *sk, int how)
1253 TCP_ECN_queue_cwr(tp); 1260 TCP_ECN_queue_cwr(tp);
1254} 1261}
1255 1262
1256static int tcp_check_sack_reneging(struct sock *sk, struct tcp_sock *tp) 1263static int tcp_check_sack_reneging(struct sock *sk)
1257{ 1264{
1258 struct sk_buff *skb; 1265 struct sk_buff *skb;
1259 1266
@@ -1268,9 +1275,10 @@ static int tcp_check_sack_reneging(struct sock *sk, struct tcp_sock *tp)
1268 NET_INC_STATS_BH(LINUX_MIB_TCPSACKRENEGING); 1275 NET_INC_STATS_BH(LINUX_MIB_TCPSACKRENEGING);
1269 1276
1270 tcp_enter_loss(sk, 1); 1277 tcp_enter_loss(sk, 1);
1271 tp->retransmits++; 1278 inet_csk(sk)->icsk_retransmits++;
1272 tcp_retransmit_skb(sk, skb_peek(&sk->sk_write_queue)); 1279 tcp_retransmit_skb(sk, skb_peek(&sk->sk_write_queue));
1273 tcp_reset_xmit_timer(sk, TCP_TIME_RETRANS, tp->rto); 1280 inet_csk_reset_xmit_timer(sk, ICSK_TIME_RETRANS,
1281 inet_csk(sk)->icsk_rto);
1274 return 1; 1282 return 1;
1275 } 1283 }
1276 return 0; 1284 return 0;
@@ -1281,15 +1289,15 @@ static inline int tcp_fackets_out(struct tcp_sock *tp)
1281 return IsReno(tp) ? tp->sacked_out+1 : tp->fackets_out; 1289 return IsReno(tp) ? tp->sacked_out+1 : tp->fackets_out;
1282} 1290}
1283 1291
1284static inline int tcp_skb_timedout(struct tcp_sock *tp, struct sk_buff *skb) 1292static inline int tcp_skb_timedout(struct sock *sk, struct sk_buff *skb)
1285{ 1293{
1286 return (tcp_time_stamp - TCP_SKB_CB(skb)->when > tp->rto); 1294 return (tcp_time_stamp - TCP_SKB_CB(skb)->when > inet_csk(sk)->icsk_rto);
1287} 1295}
1288 1296
1289static inline int tcp_head_timedout(struct sock *sk, struct tcp_sock *tp) 1297static inline int tcp_head_timedout(struct sock *sk, struct tcp_sock *tp)
1290{ 1298{
1291 return tp->packets_out && 1299 return tp->packets_out &&
1292 tcp_skb_timedout(tp, skb_peek(&sk->sk_write_queue)); 1300 tcp_skb_timedout(sk, skb_peek(&sk->sk_write_queue));
1293} 1301}
1294 1302
1295/* Linux NewReno/SACK/FACK/ECN state machine. 1303/* Linux NewReno/SACK/FACK/ECN state machine.
@@ -1509,7 +1517,7 @@ static void tcp_update_scoreboard(struct sock *sk, struct tcp_sock *tp)
1509 struct sk_buff *skb; 1517 struct sk_buff *skb;
1510 1518
1511 sk_stream_for_retrans_queue(skb, sk) { 1519 sk_stream_for_retrans_queue(skb, sk) {
1512 if (tcp_skb_timedout(tp, skb) && 1520 if (tcp_skb_timedout(sk, skb) &&
1513 !(TCP_SKB_CB(skb)->sacked&TCPCB_TAGBITS)) { 1521 !(TCP_SKB_CB(skb)->sacked&TCPCB_TAGBITS)) {
1514 TCP_SKB_CB(skb)->sacked |= TCPCB_LOST; 1522 TCP_SKB_CB(skb)->sacked |= TCPCB_LOST;
1515 tp->lost_out += tcp_skb_pcount(skb); 1523 tp->lost_out += tcp_skb_pcount(skb);
@@ -1676,7 +1684,7 @@ static int tcp_try_undo_loss(struct sock *sk, struct tcp_sock *tp)
1676 tp->left_out = tp->sacked_out; 1684 tp->left_out = tp->sacked_out;
1677 tcp_undo_cwr(tp, 1); 1685 tcp_undo_cwr(tp, 1);
1678 NET_INC_STATS_BH(LINUX_MIB_TCPLOSSUNDO); 1686 NET_INC_STATS_BH(LINUX_MIB_TCPLOSSUNDO);
1679 tp->retransmits = 0; 1687 inet_csk(sk)->icsk_retransmits = 0;
1680 tp->undo_marker = 0; 1688 tp->undo_marker = 0;
1681 if (!IsReno(tp)) 1689 if (!IsReno(tp))
1682 tcp_set_ca_state(tp, TCP_CA_Open); 1690 tcp_set_ca_state(tp, TCP_CA_Open);
@@ -1750,7 +1758,7 @@ tcp_fastretrans_alert(struct sock *sk, u32 prior_snd_una,
1750 tp->prior_ssthresh = 0; 1758 tp->prior_ssthresh = 0;
1751 1759
1752 /* B. In all the states check for reneging SACKs. */ 1760 /* B. In all the states check for reneging SACKs. */
1753 if (tp->sacked_out && tcp_check_sack_reneging(sk, tp)) 1761 if (tp->sacked_out && tcp_check_sack_reneging(sk))
1754 return; 1762 return;
1755 1763
1756 /* C. Process data loss notification, provided it is valid. */ 1764 /* C. Process data loss notification, provided it is valid. */
@@ -1774,7 +1782,7 @@ tcp_fastretrans_alert(struct sock *sk, u32 prior_snd_una,
1774 } else if (!before(tp->snd_una, tp->high_seq)) { 1782 } else if (!before(tp->snd_una, tp->high_seq)) {
1775 switch (tp->ca_state) { 1783 switch (tp->ca_state) {
1776 case TCP_CA_Loss: 1784 case TCP_CA_Loss:
1777 tp->retransmits = 0; 1785 inet_csk(sk)->icsk_retransmits = 0;
1778 if (tcp_try_undo_recovery(sk, tp)) 1786 if (tcp_try_undo_recovery(sk, tp))
1779 return; 1787 return;
1780 break; 1788 break;
@@ -1824,7 +1832,7 @@ tcp_fastretrans_alert(struct sock *sk, u32 prior_snd_una,
1824 break; 1832 break;
1825 case TCP_CA_Loss: 1833 case TCP_CA_Loss:
1826 if (flag&FLAG_DATA_ACKED) 1834 if (flag&FLAG_DATA_ACKED)
1827 tp->retransmits = 0; 1835 inet_csk(sk)->icsk_retransmits = 0;
1828 if (!tcp_try_undo_loss(sk, tp)) { 1836 if (!tcp_try_undo_loss(sk, tp)) {
1829 tcp_moderate_cwnd(tp); 1837 tcp_moderate_cwnd(tp);
1830 tcp_xmit_retransmit_queue(sk); 1838 tcp_xmit_retransmit_queue(sk);
@@ -1881,10 +1889,8 @@ tcp_fastretrans_alert(struct sock *sk, u32 prior_snd_una,
1881/* Read draft-ietf-tcplw-high-performance before mucking 1889/* Read draft-ietf-tcplw-high-performance before mucking
1882 * with this code. (Superceeds RFC1323) 1890 * with this code. (Superceeds RFC1323)
1883 */ 1891 */
1884static void tcp_ack_saw_tstamp(struct tcp_sock *tp, u32 *usrtt, int flag) 1892static void tcp_ack_saw_tstamp(struct sock *sk, u32 *usrtt, int flag)
1885{ 1893{
1886 __u32 seq_rtt;
1887
1888 /* RTTM Rule: A TSecr value received in a segment is used to 1894 /* RTTM Rule: A TSecr value received in a segment is used to
1889 * update the averaged RTT measurement only if the segment 1895 * update the averaged RTT measurement only if the segment
1890 * acknowledges some new data, i.e., only if it advances the 1896 * acknowledges some new data, i.e., only if it advances the
@@ -1900,14 +1906,15 @@ static void tcp_ack_saw_tstamp(struct tcp_sock *tp, u32 *usrtt, int flag)
1900 * answer arrives rto becomes 120 seconds! If at least one of segments 1906 * answer arrives rto becomes 120 seconds! If at least one of segments
1901 * in window is lost... Voila. --ANK (010210) 1907 * in window is lost... Voila. --ANK (010210)
1902 */ 1908 */
1903 seq_rtt = tcp_time_stamp - tp->rx_opt.rcv_tsecr; 1909 struct tcp_sock *tp = tcp_sk(sk);
1910 const __u32 seq_rtt = tcp_time_stamp - tp->rx_opt.rcv_tsecr;
1904 tcp_rtt_estimator(tp, seq_rtt, usrtt); 1911 tcp_rtt_estimator(tp, seq_rtt, usrtt);
1905 tcp_set_rto(tp); 1912 tcp_set_rto(sk);
1906 tp->backoff = 0; 1913 inet_csk(sk)->icsk_backoff = 0;
1907 tcp_bound_rto(tp); 1914 tcp_bound_rto(sk);
1908} 1915}
1909 1916
1910static void tcp_ack_no_tstamp(struct tcp_sock *tp, u32 seq_rtt, u32 *usrtt, int flag) 1917static void tcp_ack_no_tstamp(struct sock *sk, u32 seq_rtt, u32 *usrtt, int flag)
1911{ 1918{
1912 /* We don't have a timestamp. Can only use 1919 /* We don't have a timestamp. Can only use
1913 * packets that are not retransmitted to determine 1920 * packets that are not retransmitted to determine
@@ -1921,20 +1928,21 @@ static void tcp_ack_no_tstamp(struct tcp_sock *tp, u32 seq_rtt, u32 *usrtt, int
1921 if (flag & FLAG_RETRANS_DATA_ACKED) 1928 if (flag & FLAG_RETRANS_DATA_ACKED)
1922 return; 1929 return;
1923 1930
1924 tcp_rtt_estimator(tp, seq_rtt, usrtt); 1931 tcp_rtt_estimator(tcp_sk(sk), seq_rtt, usrtt);
1925 tcp_set_rto(tp); 1932 tcp_set_rto(sk);
1926 tp->backoff = 0; 1933 inet_csk(sk)->icsk_backoff = 0;
1927 tcp_bound_rto(tp); 1934 tcp_bound_rto(sk);
1928} 1935}
1929 1936
1930static inline void tcp_ack_update_rtt(struct tcp_sock *tp, 1937static inline void tcp_ack_update_rtt(struct sock *sk, const int flag,
1931 int flag, s32 seq_rtt, u32 *usrtt) 1938 const s32 seq_rtt, u32 *usrtt)
1932{ 1939{
1940 const struct tcp_sock *tp = tcp_sk(sk);
1933 /* Note that peer MAY send zero echo. In this case it is ignored. (rfc1323) */ 1941 /* Note that peer MAY send zero echo. In this case it is ignored. (rfc1323) */
1934 if (tp->rx_opt.saw_tstamp && tp->rx_opt.rcv_tsecr) 1942 if (tp->rx_opt.saw_tstamp && tp->rx_opt.rcv_tsecr)
1935 tcp_ack_saw_tstamp(tp, usrtt, flag); 1943 tcp_ack_saw_tstamp(sk, usrtt, flag);
1936 else if (seq_rtt >= 0) 1944 else if (seq_rtt >= 0)
1937 tcp_ack_no_tstamp(tp, seq_rtt, usrtt, flag); 1945 tcp_ack_no_tstamp(sk, seq_rtt, usrtt, flag);
1938} 1946}
1939 1947
1940static inline void tcp_cong_avoid(struct tcp_sock *tp, u32 ack, u32 rtt, 1948static inline void tcp_cong_avoid(struct tcp_sock *tp, u32 ack, u32 rtt,
@@ -1951,9 +1959,9 @@ static inline void tcp_cong_avoid(struct tcp_sock *tp, u32 ack, u32 rtt,
1951static inline void tcp_ack_packets_out(struct sock *sk, struct tcp_sock *tp) 1959static inline void tcp_ack_packets_out(struct sock *sk, struct tcp_sock *tp)
1952{ 1960{
1953 if (!tp->packets_out) { 1961 if (!tp->packets_out) {
1954 tcp_clear_xmit_timer(sk, TCP_TIME_RETRANS); 1962 inet_csk_clear_xmit_timer(sk, ICSK_TIME_RETRANS);
1955 } else { 1963 } else {
1956 tcp_reset_xmit_timer(sk, TCP_TIME_RETRANS, tp->rto); 1964 inet_csk_reset_xmit_timer(sk, ICSK_TIME_RETRANS, inet_csk(sk)->icsk_rto);
1957 } 1965 }
1958} 1966}
1959 1967
@@ -2090,7 +2098,7 @@ static int tcp_clean_rtx_queue(struct sock *sk, __s32 *seq_rtt_p, s32 *seq_usrtt
2090 } 2098 }
2091 2099
2092 if (acked&FLAG_ACKED) { 2100 if (acked&FLAG_ACKED) {
2093 tcp_ack_update_rtt(tp, acked, seq_rtt, seq_usrtt); 2101 tcp_ack_update_rtt(sk, acked, seq_rtt, seq_usrtt);
2094 tcp_ack_packets_out(sk, tp); 2102 tcp_ack_packets_out(sk, tp);
2095 2103
2096 if (tp->ca_ops->pkts_acked) 2104 if (tp->ca_ops->pkts_acked)
@@ -2125,20 +2133,21 @@ static int tcp_clean_rtx_queue(struct sock *sk, __s32 *seq_rtt_p, s32 *seq_usrtt
2125 2133
2126static void tcp_ack_probe(struct sock *sk) 2134static void tcp_ack_probe(struct sock *sk)
2127{ 2135{
2128 struct tcp_sock *tp = tcp_sk(sk); 2136 const struct tcp_sock *tp = tcp_sk(sk);
2137 struct inet_connection_sock *icsk = inet_csk(sk);
2129 2138
2130 /* Was it a usable window open? */ 2139 /* Was it a usable window open? */
2131 2140
2132 if (!after(TCP_SKB_CB(sk->sk_send_head)->end_seq, 2141 if (!after(TCP_SKB_CB(sk->sk_send_head)->end_seq,
2133 tp->snd_una + tp->snd_wnd)) { 2142 tp->snd_una + tp->snd_wnd)) {
2134 tp->backoff = 0; 2143 icsk->icsk_backoff = 0;
2135 tcp_clear_xmit_timer(sk, TCP_TIME_PROBE0); 2144 inet_csk_clear_xmit_timer(sk, ICSK_TIME_PROBE0);
2136 /* Socket must be waked up by subsequent tcp_data_snd_check(). 2145 /* Socket must be waked up by subsequent tcp_data_snd_check().
2137 * This function is not for random using! 2146 * This function is not for random using!
2138 */ 2147 */
2139 } else { 2148 } else {
2140 tcp_reset_xmit_timer(sk, TCP_TIME_PROBE0, 2149 inet_csk_reset_xmit_timer(sk, ICSK_TIME_PROBE0,
2141 min(tp->rto << tp->backoff, TCP_RTO_MAX)); 2150 min(icsk->icsk_rto << icsk->icsk_backoff, TCP_RTO_MAX));
2142 } 2151 }
2143} 2152}
2144 2153
@@ -2157,8 +2166,8 @@ static inline int tcp_may_raise_cwnd(struct tcp_sock *tp, int flag)
2157/* Check that window update is acceptable. 2166/* Check that window update is acceptable.
2158 * The function assumes that snd_una<=ack<=snd_next. 2167 * The function assumes that snd_una<=ack<=snd_next.
2159 */ 2168 */
2160static inline int tcp_may_update_window(struct tcp_sock *tp, u32 ack, 2169static inline int tcp_may_update_window(const struct tcp_sock *tp, const u32 ack,
2161 u32 ack_seq, u32 nwin) 2170 const u32 ack_seq, const u32 nwin)
2162{ 2171{
2163 return (after(ack, tp->snd_una) || 2172 return (after(ack, tp->snd_una) ||
2164 after(ack_seq, tp->snd_wl1) || 2173 after(ack_seq, tp->snd_wl1) ||
@@ -2500,8 +2509,9 @@ static inline void tcp_replace_ts_recent(struct tcp_sock *tp, u32 seq)
2500 * up to bandwidth of 18Gigabit/sec. 8) ] 2509 * up to bandwidth of 18Gigabit/sec. 8) ]
2501 */ 2510 */
2502 2511
2503static int tcp_disordered_ack(struct tcp_sock *tp, struct sk_buff *skb) 2512static int tcp_disordered_ack(const struct sock *sk, const struct sk_buff *skb)
2504{ 2513{
2514 struct tcp_sock *tp = tcp_sk(sk);
2505 struct tcphdr *th = skb->h.th; 2515 struct tcphdr *th = skb->h.th;
2506 u32 seq = TCP_SKB_CB(skb)->seq; 2516 u32 seq = TCP_SKB_CB(skb)->seq;
2507 u32 ack = TCP_SKB_CB(skb)->ack_seq; 2517 u32 ack = TCP_SKB_CB(skb)->ack_seq;
@@ -2516,14 +2526,15 @@ static int tcp_disordered_ack(struct tcp_sock *tp, struct sk_buff *skb)
2516 !tcp_may_update_window(tp, ack, seq, ntohs(th->window) << tp->rx_opt.snd_wscale) && 2526 !tcp_may_update_window(tp, ack, seq, ntohs(th->window) << tp->rx_opt.snd_wscale) &&
2517 2527
2518 /* 4. ... and sits in replay window. */ 2528 /* 4. ... and sits in replay window. */
2519 (s32)(tp->rx_opt.ts_recent - tp->rx_opt.rcv_tsval) <= (tp->rto*1024)/HZ); 2529 (s32)(tp->rx_opt.ts_recent - tp->rx_opt.rcv_tsval) <= (inet_csk(sk)->icsk_rto * 1024) / HZ);
2520} 2530}
2521 2531
2522static inline int tcp_paws_discard(struct tcp_sock *tp, struct sk_buff *skb) 2532static inline int tcp_paws_discard(const struct sock *sk, const struct sk_buff *skb)
2523{ 2533{
2534 const struct tcp_sock *tp = tcp_sk(sk);
2524 return ((s32)(tp->rx_opt.ts_recent - tp->rx_opt.rcv_tsval) > TCP_PAWS_WINDOW && 2535 return ((s32)(tp->rx_opt.ts_recent - tp->rx_opt.rcv_tsval) > TCP_PAWS_WINDOW &&
2525 xtime.tv_sec < tp->rx_opt.ts_recent_stamp + TCP_PAWS_24DAYS && 2536 xtime.tv_sec < tp->rx_opt.ts_recent_stamp + TCP_PAWS_24DAYS &&
2526 !tcp_disordered_ack(tp, skb)); 2537 !tcp_disordered_ack(sk, skb));
2527} 2538}
2528 2539
2529/* Check segment sequence number for validity. 2540/* Check segment sequence number for validity.
@@ -2586,7 +2597,7 @@ static void tcp_fin(struct sk_buff *skb, struct sock *sk, struct tcphdr *th)
2586{ 2597{
2587 struct tcp_sock *tp = tcp_sk(sk); 2598 struct tcp_sock *tp = tcp_sk(sk);
2588 2599
2589 tcp_schedule_ack(tp); 2600 inet_csk_schedule_ack(sk);
2590 2601
2591 sk->sk_shutdown |= RCV_SHUTDOWN; 2602 sk->sk_shutdown |= RCV_SHUTDOWN;
2592 sock_set_flag(sk, SOCK_DONE); 2603 sock_set_flag(sk, SOCK_DONE);
@@ -2596,7 +2607,7 @@ static void tcp_fin(struct sk_buff *skb, struct sock *sk, struct tcphdr *th)
2596 case TCP_ESTABLISHED: 2607 case TCP_ESTABLISHED:
2597 /* Move to CLOSE_WAIT */ 2608 /* Move to CLOSE_WAIT */
2598 tcp_set_state(sk, TCP_CLOSE_WAIT); 2609 tcp_set_state(sk, TCP_CLOSE_WAIT);
2599 tp->ack.pingpong = 1; 2610 inet_csk(sk)->icsk_ack.pingpong = 1;
2600 break; 2611 break;
2601 2612
2602 case TCP_CLOSE_WAIT: 2613 case TCP_CLOSE_WAIT:
@@ -2694,7 +2705,7 @@ static void tcp_send_dupack(struct sock *sk, struct sk_buff *skb)
2694 if (TCP_SKB_CB(skb)->end_seq != TCP_SKB_CB(skb)->seq && 2705 if (TCP_SKB_CB(skb)->end_seq != TCP_SKB_CB(skb)->seq &&
2695 before(TCP_SKB_CB(skb)->seq, tp->rcv_nxt)) { 2706 before(TCP_SKB_CB(skb)->seq, tp->rcv_nxt)) {
2696 NET_INC_STATS_BH(LINUX_MIB_DELAYEDACKLOST); 2707 NET_INC_STATS_BH(LINUX_MIB_DELAYEDACKLOST);
2697 tcp_enter_quickack_mode(tp); 2708 tcp_enter_quickack_mode(sk);
2698 2709
2699 if (tp->rx_opt.sack_ok && sysctl_tcp_dsack) { 2710 if (tp->rx_opt.sack_ok && sysctl_tcp_dsack) {
2700 u32 end_seq = TCP_SKB_CB(skb)->end_seq; 2711 u32 end_seq = TCP_SKB_CB(skb)->end_seq;
@@ -2942,7 +2953,7 @@ queue_and_out:
2942 * gap in queue is filled. 2953 * gap in queue is filled.
2943 */ 2954 */
2944 if (skb_queue_empty(&tp->out_of_order_queue)) 2955 if (skb_queue_empty(&tp->out_of_order_queue))
2945 tp->ack.pingpong = 0; 2956 inet_csk(sk)->icsk_ack.pingpong = 0;
2946 } 2957 }
2947 2958
2948 if (tp->rx_opt.num_sacks) 2959 if (tp->rx_opt.num_sacks)
@@ -2963,8 +2974,8 @@ queue_and_out:
2963 tcp_dsack_set(tp, TCP_SKB_CB(skb)->seq, TCP_SKB_CB(skb)->end_seq); 2974 tcp_dsack_set(tp, TCP_SKB_CB(skb)->seq, TCP_SKB_CB(skb)->end_seq);
2964 2975
2965out_of_window: 2976out_of_window:
2966 tcp_enter_quickack_mode(tp); 2977 tcp_enter_quickack_mode(sk);
2967 tcp_schedule_ack(tp); 2978 inet_csk_schedule_ack(sk);
2968drop: 2979drop:
2969 __kfree_skb(skb); 2980 __kfree_skb(skb);
2970 return; 2981 return;
@@ -2974,7 +2985,7 @@ drop:
2974 if (!before(TCP_SKB_CB(skb)->seq, tp->rcv_nxt + tcp_receive_window(tp))) 2985 if (!before(TCP_SKB_CB(skb)->seq, tp->rcv_nxt + tcp_receive_window(tp)))
2975 goto out_of_window; 2986 goto out_of_window;
2976 2987
2977 tcp_enter_quickack_mode(tp); 2988 tcp_enter_quickack_mode(sk);
2978 2989
2979 if (before(TCP_SKB_CB(skb)->seq, tp->rcv_nxt)) { 2990 if (before(TCP_SKB_CB(skb)->seq, tp->rcv_nxt)) {
2980 /* Partial packet, seq < rcv_next < end_seq */ 2991 /* Partial packet, seq < rcv_next < end_seq */
@@ -3003,7 +3014,7 @@ drop:
3003 3014
3004 /* Disable header prediction. */ 3015 /* Disable header prediction. */
3005 tp->pred_flags = 0; 3016 tp->pred_flags = 0;
3006 tcp_schedule_ack(tp); 3017 inet_csk_schedule_ack(sk);
3007 3018
3008 SOCK_DEBUG(sk, "out of order segment: rcv_next %X seq %X - %X\n", 3019 SOCK_DEBUG(sk, "out of order segment: rcv_next %X seq %X - %X\n",
3009 tp->rcv_nxt, TCP_SKB_CB(skb)->seq, TCP_SKB_CB(skb)->end_seq); 3020 tp->rcv_nxt, TCP_SKB_CB(skb)->seq, TCP_SKB_CB(skb)->end_seq);
@@ -3373,13 +3384,13 @@ static void __tcp_ack_snd_check(struct sock *sk, int ofo_possible)
3373 struct tcp_sock *tp = tcp_sk(sk); 3384 struct tcp_sock *tp = tcp_sk(sk);
3374 3385
3375 /* More than one full frame received... */ 3386 /* More than one full frame received... */
3376 if (((tp->rcv_nxt - tp->rcv_wup) > tp->ack.rcv_mss 3387 if (((tp->rcv_nxt - tp->rcv_wup) > inet_csk(sk)->icsk_ack.rcv_mss
3377 /* ... and right edge of window advances far enough. 3388 /* ... and right edge of window advances far enough.
3378 * (tcp_recvmsg() will send ACK otherwise). Or... 3389 * (tcp_recvmsg() will send ACK otherwise). Or...
3379 */ 3390 */
3380 && __tcp_select_window(sk) >= tp->rcv_wnd) || 3391 && __tcp_select_window(sk) >= tp->rcv_wnd) ||
3381 /* We ACK each frame or... */ 3392 /* We ACK each frame or... */
3382 tcp_in_quickack_mode(tp) || 3393 tcp_in_quickack_mode(sk) ||
3383 /* We have out of order data. */ 3394 /* We have out of order data. */
3384 (ofo_possible && 3395 (ofo_possible &&
3385 skb_peek(&tp->out_of_order_queue))) { 3396 skb_peek(&tp->out_of_order_queue))) {
@@ -3393,8 +3404,7 @@ static void __tcp_ack_snd_check(struct sock *sk, int ofo_possible)
3393 3404
3394static __inline__ void tcp_ack_snd_check(struct sock *sk) 3405static __inline__ void tcp_ack_snd_check(struct sock *sk)
3395{ 3406{
3396 struct tcp_sock *tp = tcp_sk(sk); 3407 if (!inet_csk_ack_scheduled(sk)) {
3397 if (!tcp_ack_scheduled(tp)) {
3398 /* We sent a data segment already. */ 3408 /* We sent a data segment already. */
3399 return; 3409 return;
3400 } 3410 }
@@ -3648,7 +3658,7 @@ int tcp_rcv_established(struct sock *sk, struct sk_buff *skb,
3648 tp->rcv_nxt == tp->rcv_wup) 3658 tp->rcv_nxt == tp->rcv_wup)
3649 tcp_store_ts_recent(tp); 3659 tcp_store_ts_recent(tp);
3650 3660
3651 tcp_rcv_rtt_measure_ts(tp, skb); 3661 tcp_rcv_rtt_measure_ts(sk, skb);
3652 3662
3653 /* We know that such packets are checksummed 3663 /* We know that such packets are checksummed
3654 * on entry. 3664 * on entry.
@@ -3681,7 +3691,7 @@ int tcp_rcv_established(struct sock *sk, struct sk_buff *skb,
3681 tp->rcv_nxt == tp->rcv_wup) 3691 tp->rcv_nxt == tp->rcv_wup)
3682 tcp_store_ts_recent(tp); 3692 tcp_store_ts_recent(tp);
3683 3693
3684 tcp_rcv_rtt_measure_ts(tp, skb); 3694 tcp_rcv_rtt_measure_ts(sk, skb);
3685 3695
3686 __skb_pull(skb, tcp_header_len); 3696 __skb_pull(skb, tcp_header_len);
3687 tp->rcv_nxt = TCP_SKB_CB(skb)->end_seq; 3697 tp->rcv_nxt = TCP_SKB_CB(skb)->end_seq;
@@ -3702,7 +3712,7 @@ int tcp_rcv_established(struct sock *sk, struct sk_buff *skb,
3702 tp->rcv_nxt == tp->rcv_wup) 3712 tp->rcv_nxt == tp->rcv_wup)
3703 tcp_store_ts_recent(tp); 3713 tcp_store_ts_recent(tp);
3704 3714
3705 tcp_rcv_rtt_measure_ts(tp, skb); 3715 tcp_rcv_rtt_measure_ts(sk, skb);
3706 3716
3707 if ((int)skb->truesize > sk->sk_forward_alloc) 3717 if ((int)skb->truesize > sk->sk_forward_alloc)
3708 goto step5; 3718 goto step5;
@@ -3722,7 +3732,7 @@ int tcp_rcv_established(struct sock *sk, struct sk_buff *skb,
3722 /* Well, only one small jumplet in fast path... */ 3732 /* Well, only one small jumplet in fast path... */
3723 tcp_ack(sk, skb, FLAG_DATA); 3733 tcp_ack(sk, skb, FLAG_DATA);
3724 tcp_data_snd_check(sk, tp); 3734 tcp_data_snd_check(sk, tp);
3725 if (!tcp_ack_scheduled(tp)) 3735 if (!inet_csk_ack_scheduled(sk))
3726 goto no_ack; 3736 goto no_ack;
3727 } 3737 }
3728 3738
@@ -3744,7 +3754,7 @@ slow_path:
3744 * RFC1323: H1. Apply PAWS check first. 3754 * RFC1323: H1. Apply PAWS check first.
3745 */ 3755 */
3746 if (tcp_fast_parse_options(skb, th, tp) && tp->rx_opt.saw_tstamp && 3756 if (tcp_fast_parse_options(skb, th, tp) && tp->rx_opt.saw_tstamp &&
3747 tcp_paws_discard(tp, skb)) { 3757 tcp_paws_discard(sk, skb)) {
3748 if (!th->rst) { 3758 if (!th->rst) {
3749 NET_INC_STATS_BH(LINUX_MIB_PAWSESTABREJECTED); 3759 NET_INC_STATS_BH(LINUX_MIB_PAWSESTABREJECTED);
3750 tcp_send_dupack(sk, skb); 3760 tcp_send_dupack(sk, skb);
@@ -3791,7 +3801,7 @@ step5:
3791 if(th->ack) 3801 if(th->ack)
3792 tcp_ack(sk, skb, FLAG_SLOWPATH); 3802 tcp_ack(sk, skb, FLAG_SLOWPATH);
3793 3803
3794 tcp_rcv_rtt_measure_ts(tp, skb); 3804 tcp_rcv_rtt_measure_ts(sk, skb);
3795 3805
3796 /* Process urgent data. */ 3806 /* Process urgent data. */
3797 tcp_urg(sk, skb, th); 3807 tcp_urg(sk, skb, th);
@@ -3933,7 +3943,7 @@ static int tcp_rcv_synsent_state_process(struct sock *sk, struct sk_buff *skb,
3933 tcp_init_buffer_space(sk); 3943 tcp_init_buffer_space(sk);
3934 3944
3935 if (sock_flag(sk, SOCK_KEEPOPEN)) 3945 if (sock_flag(sk, SOCK_KEEPOPEN))
3936 tcp_reset_keepalive_timer(sk, keepalive_time_when(tp)); 3946 inet_csk_reset_keepalive_timer(sk, keepalive_time_when(tp));
3937 3947
3938 if (!tp->rx_opt.snd_wscale) 3948 if (!tp->rx_opt.snd_wscale)
3939 __tcp_fast_path_on(tp, tp->snd_wnd); 3949 __tcp_fast_path_on(tp, tp->snd_wnd);
@@ -3945,7 +3955,7 @@ static int tcp_rcv_synsent_state_process(struct sock *sk, struct sk_buff *skb,
3945 sk_wake_async(sk, 0, POLL_OUT); 3955 sk_wake_async(sk, 0, POLL_OUT);
3946 } 3956 }
3947 3957
3948 if (sk->sk_write_pending || tp->defer_accept || tp->ack.pingpong) { 3958 if (sk->sk_write_pending || tp->defer_accept || inet_csk(sk)->icsk_ack.pingpong) {
3949 /* Save one ACK. Data will be ready after 3959 /* Save one ACK. Data will be ready after
3950 * several ticks, if write_pending is set. 3960 * several ticks, if write_pending is set.
3951 * 3961 *
@@ -3953,12 +3963,12 @@ static int tcp_rcv_synsent_state_process(struct sock *sk, struct sk_buff *skb,
3953 * look so _wonderfully_ clever, that I was not able 3963 * look so _wonderfully_ clever, that I was not able
3954 * to stand against the temptation 8) --ANK 3964 * to stand against the temptation 8) --ANK
3955 */ 3965 */
3956 tcp_schedule_ack(tp); 3966 inet_csk_schedule_ack(sk);
3957 tp->ack.lrcvtime = tcp_time_stamp; 3967 inet_csk(sk)->icsk_ack.lrcvtime = tcp_time_stamp;
3958 tp->ack.ato = TCP_ATO_MIN; 3968 inet_csk(sk)->icsk_ack.ato = TCP_ATO_MIN;
3959 tcp_incr_quickack(tp); 3969 tcp_incr_quickack(sk);
3960 tcp_enter_quickack_mode(tp); 3970 tcp_enter_quickack_mode(sk);
3961 tcp_reset_xmit_timer(sk, TCP_TIME_DACK, TCP_DELACK_MAX); 3971 inet_csk_reset_xmit_timer(sk, ICSK_TIME_DACK, TCP_DELACK_MAX);
3962 3972
3963discard: 3973discard:
3964 __kfree_skb(skb); 3974 __kfree_skb(skb);
@@ -4114,7 +4124,7 @@ int tcp_rcv_state_process(struct sock *sk, struct sk_buff *skb,
4114 } 4124 }
4115 4125
4116 if (tcp_fast_parse_options(skb, th, tp) && tp->rx_opt.saw_tstamp && 4126 if (tcp_fast_parse_options(skb, th, tp) && tp->rx_opt.saw_tstamp &&
4117 tcp_paws_discard(tp, skb)) { 4127 tcp_paws_discard(sk, skb)) {
4118 if (!th->rst) { 4128 if (!th->rst) {
4119 NET_INC_STATS_BH(LINUX_MIB_PAWSESTABREJECTED); 4129 NET_INC_STATS_BH(LINUX_MIB_PAWSESTABREJECTED);
4120 tcp_send_dupack(sk, skb); 4130 tcp_send_dupack(sk, skb);
@@ -4183,7 +4193,7 @@ int tcp_rcv_state_process(struct sock *sk, struct sk_buff *skb,
4183 */ 4193 */
4184 if (tp->rx_opt.saw_tstamp && tp->rx_opt.rcv_tsecr && 4194 if (tp->rx_opt.saw_tstamp && tp->rx_opt.rcv_tsecr &&
4185 !tp->srtt) 4195 !tp->srtt)
4186 tcp_ack_saw_tstamp(tp, 0, 0); 4196 tcp_ack_saw_tstamp(sk, 0, 0);
4187 4197
4188 if (tp->rx_opt.tstamp_ok) 4198 if (tp->rx_opt.tstamp_ok)
4189 tp->advmss -= TCPOLEN_TSTAMP_ALIGNED; 4199 tp->advmss -= TCPOLEN_TSTAMP_ALIGNED;
@@ -4230,9 +4240,9 @@ int tcp_rcv_state_process(struct sock *sk, struct sk_buff *skb,
4230 return 1; 4240 return 1;
4231 } 4241 }
4232 4242
4233 tmo = tcp_fin_time(tp); 4243 tmo = tcp_fin_time(sk);
4234 if (tmo > TCP_TIMEWAIT_LEN) { 4244 if (tmo > TCP_TIMEWAIT_LEN) {
4235 tcp_reset_keepalive_timer(sk, tmo - TCP_TIMEWAIT_LEN); 4245 inet_csk_reset_keepalive_timer(sk, tmo - TCP_TIMEWAIT_LEN);
4236 } else if (th->fin || sock_owned_by_user(sk)) { 4246 } else if (th->fin || sock_owned_by_user(sk)) {
4237 /* Bad case. We could lose such FIN otherwise. 4247 /* Bad case. We could lose such FIN otherwise.
4238 * It is not a big problem, but it looks confusing 4248 * It is not a big problem, but it looks confusing
@@ -4240,7 +4250,7 @@ int tcp_rcv_state_process(struct sock *sk, struct sk_buff *skb,
4240 * if it spins in bh_lock_sock(), but it is really 4250 * if it spins in bh_lock_sock(), but it is really
4241 * marginal case. 4251 * marginal case.
4242 */ 4252 */
4243 tcp_reset_keepalive_timer(sk, tmo); 4253 inet_csk_reset_keepalive_timer(sk, tmo);
4244 } else { 4254 } else {
4245 tcp_time_wait(sk, TCP_FIN_WAIT2, tmo); 4255 tcp_time_wait(sk, TCP_FIN_WAIT2, tmo);
4246 goto discard; 4256 goto discard;
diff --git a/net/ipv4/tcp_ipv4.c b/net/ipv4/tcp_ipv4.c
index e7e91e60ac74..2cd41265d17f 100644
--- a/net/ipv4/tcp_ipv4.c
+++ b/net/ipv4/tcp_ipv4.c
@@ -104,7 +104,7 @@ struct inet_hashinfo __cacheline_aligned tcp_hashinfo = {
104 */ 104 */
105int sysctl_local_port_range[2] = { 1024, 4999 }; 105int sysctl_local_port_range[2] = { 1024, 4999 };
106 106
107static inline int tcp_bind_conflict(struct sock *sk, struct inet_bind_bucket *tb) 107static inline int inet_csk_bind_conflict(struct sock *sk, struct inet_bind_bucket *tb)
108{ 108{
109 const u32 sk_rcv_saddr = inet_rcv_saddr(sk); 109 const u32 sk_rcv_saddr = inet_rcv_saddr(sk);
110 struct sock *sk2; 110 struct sock *sk2;
@@ -113,7 +113,7 @@ static inline int tcp_bind_conflict(struct sock *sk, struct inet_bind_bucket *tb
113 113
114 sk_for_each_bound(sk2, node, &tb->owners) { 114 sk_for_each_bound(sk2, node, &tb->owners) {
115 if (sk != sk2 && 115 if (sk != sk2 &&
116 !tcp_v6_ipv6only(sk2) && 116 !inet_v6_ipv6only(sk2) &&
117 (!sk->sk_bound_dev_if || 117 (!sk->sk_bound_dev_if ||
118 !sk2->sk_bound_dev_if || 118 !sk2->sk_bound_dev_if ||
119 sk->sk_bound_dev_if == sk2->sk_bound_dev_if)) { 119 sk->sk_bound_dev_if == sk2->sk_bound_dev_if)) {
@@ -132,7 +132,8 @@ static inline int tcp_bind_conflict(struct sock *sk, struct inet_bind_bucket *tb
132/* Obtain a reference to a local port for the given sock, 132/* Obtain a reference to a local port for the given sock,
133 * if snum is zero it means select any available local port. 133 * if snum is zero it means select any available local port.
134 */ 134 */
135static int tcp_v4_get_port(struct sock *sk, unsigned short snum) 135int inet_csk_get_port(struct inet_hashinfo *hashinfo,
136 struct sock *sk, unsigned short snum)
136{ 137{
137 struct inet_bind_hashbucket *head; 138 struct inet_bind_hashbucket *head;
138 struct hlist_node *node; 139 struct hlist_node *node;
@@ -146,16 +147,16 @@ static int tcp_v4_get_port(struct sock *sk, unsigned short snum)
146 int remaining = (high - low) + 1; 147 int remaining = (high - low) + 1;
147 int rover; 148 int rover;
148 149
149 spin_lock(&tcp_hashinfo.portalloc_lock); 150 spin_lock(&hashinfo->portalloc_lock);
150 if (tcp_hashinfo.port_rover < low) 151 if (hashinfo->port_rover < low)
151 rover = low; 152 rover = low;
152 else 153 else
153 rover = tcp_hashinfo.port_rover; 154 rover = hashinfo->port_rover;
154 do { 155 do {
155 rover++; 156 rover++;
156 if (rover > high) 157 if (rover > high)
157 rover = low; 158 rover = low;
158 head = &tcp_hashinfo.bhash[inet_bhashfn(rover, tcp_hashinfo.bhash_size)]; 159 head = &hashinfo->bhash[inet_bhashfn(rover, hashinfo->bhash_size)];
159 spin_lock(&head->lock); 160 spin_lock(&head->lock);
160 inet_bind_bucket_for_each(tb, node, &head->chain) 161 inet_bind_bucket_for_each(tb, node, &head->chain)
161 if (tb->port == rover) 162 if (tb->port == rover)
@@ -164,8 +165,8 @@ static int tcp_v4_get_port(struct sock *sk, unsigned short snum)
164 next: 165 next:
165 spin_unlock(&head->lock); 166 spin_unlock(&head->lock);
166 } while (--remaining > 0); 167 } while (--remaining > 0);
167 tcp_hashinfo.port_rover = rover; 168 hashinfo->port_rover = rover;
168 spin_unlock(&tcp_hashinfo.portalloc_lock); 169 spin_unlock(&hashinfo->portalloc_lock);
169 170
170 /* Exhausted local port range during search? It is not 171 /* Exhausted local port range during search? It is not
171 * possible for us to be holding one of the bind hash 172 * possible for us to be holding one of the bind hash
@@ -182,7 +183,7 @@ static int tcp_v4_get_port(struct sock *sk, unsigned short snum)
182 */ 183 */
183 snum = rover; 184 snum = rover;
184 } else { 185 } else {
185 head = &tcp_hashinfo.bhash[inet_bhashfn(snum, tcp_hashinfo.bhash_size)]; 186 head = &hashinfo->bhash[inet_bhashfn(snum, hashinfo->bhash_size)];
186 spin_lock(&head->lock); 187 spin_lock(&head->lock);
187 inet_bind_bucket_for_each(tb, node, &head->chain) 188 inet_bind_bucket_for_each(tb, node, &head->chain)
188 if (tb->port == snum) 189 if (tb->port == snum)
@@ -199,13 +200,13 @@ tb_found:
199 goto success; 200 goto success;
200 } else { 201 } else {
201 ret = 1; 202 ret = 1;
202 if (tcp_bind_conflict(sk, tb)) 203 if (inet_csk_bind_conflict(sk, tb))
203 goto fail_unlock; 204 goto fail_unlock;
204 } 205 }
205 } 206 }
206tb_not_found: 207tb_not_found:
207 ret = 1; 208 ret = 1;
208 if (!tb && (tb = inet_bind_bucket_create(tcp_hashinfo.bind_bucket_cachep, head, snum)) == NULL) 209 if (!tb && (tb = inet_bind_bucket_create(hashinfo->bind_bucket_cachep, head, snum)) == NULL)
209 goto fail_unlock; 210 goto fail_unlock;
210 if (hlist_empty(&tb->owners)) { 211 if (hlist_empty(&tb->owners)) {
211 if (sk->sk_reuse && sk->sk_state != TCP_LISTEN) 212 if (sk->sk_reuse && sk->sk_state != TCP_LISTEN)
@@ -216,9 +217,9 @@ tb_not_found:
216 (!sk->sk_reuse || sk->sk_state == TCP_LISTEN)) 217 (!sk->sk_reuse || sk->sk_state == TCP_LISTEN))
217 tb->fastreuse = 0; 218 tb->fastreuse = 0;
218success: 219success:
219 if (!inet_sk(sk)->bind_hash) 220 if (!inet_csk(sk)->icsk_bind_hash)
220 inet_bind_hash(sk, tb, snum); 221 inet_bind_hash(sk, tb, snum);
221 BUG_TRAP(inet_sk(sk)->bind_hash == tb); 222 BUG_TRAP(inet_csk(sk)->icsk_bind_hash == tb);
222 ret = 0; 223 ret = 0;
223 224
224fail_unlock: 225fail_unlock:
@@ -228,6 +229,11 @@ fail:
228 return ret; 229 return ret;
229} 230}
230 231
232static int tcp_v4_get_port(struct sock *sk, unsigned short snum)
233{
234 return inet_csk_get_port(&tcp_hashinfo, sk, snum);
235}
236
231static void tcp_v4_hash(struct sock *sk) 237static void tcp_v4_hash(struct sock *sk)
232{ 238{
233 inet_hash(&tcp_hashinfo, sk); 239 inet_hash(&tcp_hashinfo, sk);
@@ -426,7 +432,7 @@ ok:
426 } 432 }
427 433
428 head = &tcp_hashinfo.bhash[inet_bhashfn(snum, tcp_hashinfo.bhash_size)]; 434 head = &tcp_hashinfo.bhash[inet_bhashfn(snum, tcp_hashinfo.bhash_size)];
429 tb = inet_sk(sk)->bind_hash; 435 tb = inet_csk(sk)->icsk_bind_hash;
430 spin_lock_bh(&head->lock); 436 spin_lock_bh(&head->lock);
431 if (sk_head(&tb->owners) == sk && !sk->sk_bind_node.next) { 437 if (sk_head(&tb->owners) == sk && !sk->sk_bind_node.next) {
432 __inet_hash(&tcp_hashinfo, sk, 0); 438 __inet_hash(&tcp_hashinfo, sk, 0);
@@ -557,25 +563,28 @@ failure:
557 return err; 563 return err;
558} 564}
559 565
560static __inline__ int tcp_v4_iif(struct sk_buff *skb) 566static inline int inet_iif(const struct sk_buff *skb)
561{ 567{
562 return ((struct rtable *)skb->dst)->rt_iif; 568 return ((struct rtable *)skb->dst)->rt_iif;
563} 569}
564 570
565static __inline__ u32 tcp_v4_synq_hash(u32 raddr, u16 rport, u32 rnd) 571static inline u32 inet_synq_hash(const u32 raddr, const u16 rport,
572 const u32 rnd, const u16 synq_hsize)
566{ 573{
567 return (jhash_2words(raddr, (u32) rport, rnd) & (TCP_SYNQ_HSIZE - 1)); 574 return jhash_2words(raddr, (u32)rport, rnd) & (synq_hsize - 1);
568} 575}
569 576
570static struct request_sock *tcp_v4_search_req(struct tcp_sock *tp, 577struct request_sock *inet_csk_search_req(const struct sock *sk,
571 struct request_sock ***prevp, 578 struct request_sock ***prevp,
572 __u16 rport, 579 const __u16 rport, const __u32 raddr,
573 __u32 raddr, __u32 laddr) 580 const __u32 laddr)
574{ 581{
575 struct listen_sock *lopt = tp->accept_queue.listen_opt; 582 const struct inet_connection_sock *icsk = inet_csk(sk);
583 struct listen_sock *lopt = icsk->icsk_accept_queue.listen_opt;
576 struct request_sock *req, **prev; 584 struct request_sock *req, **prev;
577 585
578 for (prev = &lopt->syn_table[tcp_v4_synq_hash(raddr, rport, lopt->hash_rnd)]; 586 for (prev = &lopt->syn_table[inet_synq_hash(raddr, rport, lopt->hash_rnd,
587 lopt->nr_table_entries)];
579 (req = *prev) != NULL; 588 (req = *prev) != NULL;
580 prev = &req->dl_next) { 589 prev = &req->dl_next) {
581 const struct inet_request_sock *ireq = inet_rsk(req); 590 const struct inet_request_sock *ireq = inet_rsk(req);
@@ -583,7 +592,7 @@ static struct request_sock *tcp_v4_search_req(struct tcp_sock *tp,
583 if (ireq->rmt_port == rport && 592 if (ireq->rmt_port == rport &&
584 ireq->rmt_addr == raddr && 593 ireq->rmt_addr == raddr &&
585 ireq->loc_addr == laddr && 594 ireq->loc_addr == laddr &&
586 TCP_INET_FAMILY(req->rsk_ops->family)) { 595 AF_INET_FAMILY(req->rsk_ops->family)) {
587 BUG_TRAP(!req->sk); 596 BUG_TRAP(!req->sk);
588 *prevp = prev; 597 *prevp = prev;
589 break; 598 break;
@@ -595,12 +604,13 @@ static struct request_sock *tcp_v4_search_req(struct tcp_sock *tp,
595 604
596static void tcp_v4_synq_add(struct sock *sk, struct request_sock *req) 605static void tcp_v4_synq_add(struct sock *sk, struct request_sock *req)
597{ 606{
598 struct tcp_sock *tp = tcp_sk(sk); 607 struct inet_connection_sock *icsk = inet_csk(sk);
599 struct listen_sock *lopt = tp->accept_queue.listen_opt; 608 struct listen_sock *lopt = icsk->icsk_accept_queue.listen_opt;
600 u32 h = tcp_v4_synq_hash(inet_rsk(req)->rmt_addr, inet_rsk(req)->rmt_port, lopt->hash_rnd); 609 const u32 h = inet_synq_hash(inet_rsk(req)->rmt_addr, inet_rsk(req)->rmt_port,
610 lopt->hash_rnd, lopt->nr_table_entries);
601 611
602 reqsk_queue_hash_req(&tp->accept_queue, h, req, TCP_TIMEOUT_INIT); 612 reqsk_queue_hash_req(&icsk->icsk_accept_queue, h, req, TCP_TIMEOUT_INIT);
603 tcp_synq_added(sk); 613 inet_csk_reqsk_queue_added(sk, TCP_TIMEOUT_INIT);
604} 614}
605 615
606 616
@@ -687,7 +697,7 @@ void tcp_v4_err(struct sk_buff *skb, u32 info)
687 } 697 }
688 698
689 sk = inet_lookup(&tcp_hashinfo, iph->daddr, th->dest, iph->saddr, 699 sk = inet_lookup(&tcp_hashinfo, iph->daddr, th->dest, iph->saddr,
690 th->source, tcp_v4_iif(skb)); 700 th->source, inet_iif(skb));
691 if (!sk) { 701 if (!sk) {
692 ICMP_INC_STATS_BH(ICMP_MIB_INERRORS); 702 ICMP_INC_STATS_BH(ICMP_MIB_INERRORS);
693 return; 703 return;
@@ -747,8 +757,8 @@ void tcp_v4_err(struct sk_buff *skb, u32 info)
747 if (sock_owned_by_user(sk)) 757 if (sock_owned_by_user(sk))
748 goto out; 758 goto out;
749 759
750 req = tcp_v4_search_req(tp, &prev, th->dest, 760 req = inet_csk_search_req(sk, &prev, th->dest,
751 iph->daddr, iph->saddr); 761 iph->daddr, iph->saddr);
752 if (!req) 762 if (!req)
753 goto out; 763 goto out;
754 764
@@ -768,7 +778,7 @@ void tcp_v4_err(struct sk_buff *skb, u32 info)
768 * created socket, and POSIX does not want network 778 * created socket, and POSIX does not want network
769 * errors returned from accept(). 779 * errors returned from accept().
770 */ 780 */
771 tcp_synq_drop(sk, req, prev); 781 inet_csk_reqsk_queue_drop(sk, req, prev);
772 goto out; 782 goto out;
773 783
774 case TCP_SYN_SENT: 784 case TCP_SYN_SENT:
@@ -953,8 +963,8 @@ static void tcp_v4_reqsk_send_ack(struct sk_buff *skb, struct request_sock *req)
953 req->ts_recent); 963 req->ts_recent);
954} 964}
955 965
956static struct dst_entry* tcp_v4_route_req(struct sock *sk, 966struct dst_entry* inet_csk_route_req(struct sock *sk,
957 struct request_sock *req) 967 const struct request_sock *req)
958{ 968{
959 struct rtable *rt; 969 struct rtable *rt;
960 const struct inet_request_sock *ireq = inet_rsk(req); 970 const struct inet_request_sock *ireq = inet_rsk(req);
@@ -966,7 +976,7 @@ static struct dst_entry* tcp_v4_route_req(struct sock *sk,
966 ireq->rmt_addr), 976 ireq->rmt_addr),
967 .saddr = ireq->loc_addr, 977 .saddr = ireq->loc_addr,
968 .tos = RT_CONN_FLAGS(sk) } }, 978 .tos = RT_CONN_FLAGS(sk) } },
969 .proto = IPPROTO_TCP, 979 .proto = sk->sk_protocol,
970 .uli_u = { .ports = 980 .uli_u = { .ports =
971 { .sport = inet_sk(sk)->sport, 981 { .sport = inet_sk(sk)->sport,
972 .dport = ireq->rmt_port } } }; 982 .dport = ireq->rmt_port } } };
@@ -996,7 +1006,7 @@ static int tcp_v4_send_synack(struct sock *sk, struct request_sock *req,
996 struct sk_buff * skb; 1006 struct sk_buff * skb;
997 1007
998 /* First, grab a route. */ 1008 /* First, grab a route. */
999 if (!dst && (dst = tcp_v4_route_req(sk, req)) == NULL) 1009 if (!dst && (dst = inet_csk_route_req(sk, req)) == NULL)
1000 goto out; 1010 goto out;
1001 1011
1002 skb = tcp_make_synack(sk, dst, req); 1012 skb = tcp_make_synack(sk, dst, req);
@@ -1098,7 +1108,7 @@ int tcp_v4_conn_request(struct sock *sk, struct sk_buff *skb)
1098 * limitations, they conserve resources and peer is 1108 * limitations, they conserve resources and peer is
1099 * evidently real one. 1109 * evidently real one.
1100 */ 1110 */
1101 if (tcp_synq_is_full(sk) && !isn) { 1111 if (inet_csk_reqsk_queue_is_full(sk) && !isn) {
1102#ifdef CONFIG_SYN_COOKIES 1112#ifdef CONFIG_SYN_COOKIES
1103 if (sysctl_tcp_syncookies) { 1113 if (sysctl_tcp_syncookies) {
1104 want_cookie = 1; 1114 want_cookie = 1;
@@ -1112,7 +1122,7 @@ int tcp_v4_conn_request(struct sock *sk, struct sk_buff *skb)
1112 * clogging syn queue with openreqs with exponentially increasing 1122 * clogging syn queue with openreqs with exponentially increasing
1113 * timeout. 1123 * timeout.
1114 */ 1124 */
1115 if (sk_acceptq_is_full(sk) && tcp_synq_young(sk) > 1) 1125 if (sk_acceptq_is_full(sk) && inet_csk_reqsk_queue_young(sk) > 1)
1116 goto drop; 1126 goto drop;
1117 1127
1118 req = reqsk_alloc(&tcp_request_sock_ops); 1128 req = reqsk_alloc(&tcp_request_sock_ops);
@@ -1169,7 +1179,7 @@ int tcp_v4_conn_request(struct sock *sk, struct sk_buff *skb)
1169 */ 1179 */
1170 if (tmp_opt.saw_tstamp && 1180 if (tmp_opt.saw_tstamp &&
1171 sysctl_tcp_tw_recycle && 1181 sysctl_tcp_tw_recycle &&
1172 (dst = tcp_v4_route_req(sk, req)) != NULL && 1182 (dst = inet_csk_route_req(sk, req)) != NULL &&
1173 (peer = rt_get_peer((struct rtable *)dst)) != NULL && 1183 (peer = rt_get_peer((struct rtable *)dst)) != NULL &&
1174 peer->v4daddr == saddr) { 1184 peer->v4daddr == saddr) {
1175 if (xtime.tv_sec < peer->tcp_ts_stamp + TCP_PAWS_MSL && 1185 if (xtime.tv_sec < peer->tcp_ts_stamp + TCP_PAWS_MSL &&
@@ -1182,7 +1192,7 @@ int tcp_v4_conn_request(struct sock *sk, struct sk_buff *skb)
1182 } 1192 }
1183 /* Kill the following clause, if you dislike this way. */ 1193 /* Kill the following clause, if you dislike this way. */
1184 else if (!sysctl_tcp_syncookies && 1194 else if (!sysctl_tcp_syncookies &&
1185 (sysctl_max_syn_backlog - tcp_synq_len(sk) < 1195 (sysctl_max_syn_backlog - inet_csk_reqsk_queue_len(sk) <
1186 (sysctl_max_syn_backlog >> 2)) && 1196 (sysctl_max_syn_backlog >> 2)) &&
1187 (!peer || !peer->tcp_ts_stamp) && 1197 (!peer || !peer->tcp_ts_stamp) &&
1188 (!dst || !dst_metric(dst, RTAX_RTT))) { 1198 (!dst || !dst_metric(dst, RTAX_RTT))) {
@@ -1240,7 +1250,7 @@ struct sock *tcp_v4_syn_recv_sock(struct sock *sk, struct sk_buff *skb,
1240 if (sk_acceptq_is_full(sk)) 1250 if (sk_acceptq_is_full(sk))
1241 goto exit_overflow; 1251 goto exit_overflow;
1242 1252
1243 if (!dst && (dst = tcp_v4_route_req(sk, req)) == NULL) 1253 if (!dst && (dst = inet_csk_route_req(sk, req)) == NULL)
1244 goto exit; 1254 goto exit;
1245 1255
1246 newsk = tcp_create_openreq_child(sk, req, skb); 1256 newsk = tcp_create_openreq_child(sk, req, skb);
@@ -1257,7 +1267,7 @@ struct sock *tcp_v4_syn_recv_sock(struct sock *sk, struct sk_buff *skb,
1257 newinet->saddr = ireq->loc_addr; 1267 newinet->saddr = ireq->loc_addr;
1258 newinet->opt = ireq->opt; 1268 newinet->opt = ireq->opt;
1259 ireq->opt = NULL; 1269 ireq->opt = NULL;
1260 newinet->mc_index = tcp_v4_iif(skb); 1270 newinet->mc_index = inet_iif(skb);
1261 newinet->mc_ttl = skb->nh.iph->ttl; 1271 newinet->mc_ttl = skb->nh.iph->ttl;
1262 newtp->ext_header_len = 0; 1272 newtp->ext_header_len = 0;
1263 if (newinet->opt) 1273 if (newinet->opt)
@@ -1285,18 +1295,17 @@ static struct sock *tcp_v4_hnd_req(struct sock *sk, struct sk_buff *skb)
1285{ 1295{
1286 struct tcphdr *th = skb->h.th; 1296 struct tcphdr *th = skb->h.th;
1287 struct iphdr *iph = skb->nh.iph; 1297 struct iphdr *iph = skb->nh.iph;
1288 struct tcp_sock *tp = tcp_sk(sk);
1289 struct sock *nsk; 1298 struct sock *nsk;
1290 struct request_sock **prev; 1299 struct request_sock **prev;
1291 /* Find possible connection requests. */ 1300 /* Find possible connection requests. */
1292 struct request_sock *req = tcp_v4_search_req(tp, &prev, th->source, 1301 struct request_sock *req = inet_csk_search_req(sk, &prev, th->source,
1293 iph->saddr, iph->daddr); 1302 iph->saddr, iph->daddr);
1294 if (req) 1303 if (req)
1295 return tcp_check_req(sk, skb, req, prev); 1304 return tcp_check_req(sk, skb, req, prev);
1296 1305
1297 nsk = __inet_lookup_established(&tcp_hashinfo, skb->nh.iph->saddr, 1306 nsk = __inet_lookup_established(&tcp_hashinfo, skb->nh.iph->saddr,
1298 th->source, skb->nh.iph->daddr, 1307 th->source, skb->nh.iph->daddr,
1299 ntohs(th->dest), tcp_v4_iif(skb)); 1308 ntohs(th->dest), inet_iif(skb));
1300 1309
1301 if (nsk) { 1310 if (nsk) {
1302 if (nsk->sk_state != TCP_TIME_WAIT) { 1311 if (nsk->sk_state != TCP_TIME_WAIT) {
@@ -1440,7 +1449,7 @@ int tcp_v4_rcv(struct sk_buff *skb)
1440 1449
1441 sk = __inet_lookup(&tcp_hashinfo, skb->nh.iph->saddr, th->source, 1450 sk = __inet_lookup(&tcp_hashinfo, skb->nh.iph->saddr, th->source,
1442 skb->nh.iph->daddr, ntohs(th->dest), 1451 skb->nh.iph->daddr, ntohs(th->dest),
1443 tcp_v4_iif(skb)); 1452 inet_iif(skb));
1444 1453
1445 if (!sk) 1454 if (!sk)
1446 goto no_tcp_socket; 1455 goto no_tcp_socket;
@@ -1507,7 +1516,7 @@ do_time_wait:
1507 struct sock *sk2 = inet_lookup_listener(&tcp_hashinfo, 1516 struct sock *sk2 = inet_lookup_listener(&tcp_hashinfo,
1508 skb->nh.iph->daddr, 1517 skb->nh.iph->daddr,
1509 ntohs(th->dest), 1518 ntohs(th->dest),
1510 tcp_v4_iif(skb)); 1519 inet_iif(skb));
1511 if (sk2) { 1520 if (sk2) {
1512 tcp_tw_deschedule((struct inet_timewait_sock *)sk); 1521 tcp_tw_deschedule((struct inet_timewait_sock *)sk);
1513 inet_twsk_put((struct inet_timewait_sock *)sk); 1522 inet_twsk_put((struct inet_timewait_sock *)sk);
@@ -1619,7 +1628,7 @@ static int tcp_v4_init_sock(struct sock *sk)
1619 tcp_init_xmit_timers(sk); 1628 tcp_init_xmit_timers(sk);
1620 tcp_prequeue_init(tp); 1629 tcp_prequeue_init(tp);
1621 1630
1622 tp->rto = TCP_TIMEOUT_INIT; 1631 inet_csk(sk)->icsk_rto = TCP_TIMEOUT_INIT;
1623 tp->mdev = TCP_TIMEOUT_INIT; 1632 tp->mdev = TCP_TIMEOUT_INIT;
1624 1633
1625 /* So many TCP implementations out there (incorrectly) count the 1634 /* So many TCP implementations out there (incorrectly) count the
@@ -1672,7 +1681,7 @@ int tcp_v4_destroy_sock(struct sock *sk)
1672 __skb_queue_purge(&tp->ucopy.prequeue); 1681 __skb_queue_purge(&tp->ucopy.prequeue);
1673 1682
1674 /* Clean up a referenced TCP bind bucket. */ 1683 /* Clean up a referenced TCP bind bucket. */
1675 if (inet_sk(sk)->bind_hash) 1684 if (inet_csk(sk)->icsk_bind_hash)
1676 inet_put_port(&tcp_hashinfo, sk); 1685 inet_put_port(&tcp_hashinfo, sk);
1677 1686
1678 /* 1687 /*
@@ -1707,7 +1716,7 @@ static inline struct inet_timewait_sock *tw_next(struct inet_timewait_sock *tw)
1707 1716
1708static void *listening_get_next(struct seq_file *seq, void *cur) 1717static void *listening_get_next(struct seq_file *seq, void *cur)
1709{ 1718{
1710 struct tcp_sock *tp; 1719 struct inet_connection_sock *icsk;
1711 struct hlist_node *node; 1720 struct hlist_node *node;
1712 struct sock *sk = cur; 1721 struct sock *sk = cur;
1713 struct tcp_iter_state* st = seq->private; 1722 struct tcp_iter_state* st = seq->private;
@@ -1723,7 +1732,7 @@ static void *listening_get_next(struct seq_file *seq, void *cur)
1723 if (st->state == TCP_SEQ_STATE_OPENREQ) { 1732 if (st->state == TCP_SEQ_STATE_OPENREQ) {
1724 struct request_sock *req = cur; 1733 struct request_sock *req = cur;
1725 1734
1726 tp = tcp_sk(st->syn_wait_sk); 1735 icsk = inet_csk(st->syn_wait_sk);
1727 req = req->dl_next; 1736 req = req->dl_next;
1728 while (1) { 1737 while (1) {
1729 while (req) { 1738 while (req) {
@@ -1736,17 +1745,17 @@ static void *listening_get_next(struct seq_file *seq, void *cur)
1736 if (++st->sbucket >= TCP_SYNQ_HSIZE) 1745 if (++st->sbucket >= TCP_SYNQ_HSIZE)
1737 break; 1746 break;
1738get_req: 1747get_req:
1739 req = tp->accept_queue.listen_opt->syn_table[st->sbucket]; 1748 req = icsk->icsk_accept_queue.listen_opt->syn_table[st->sbucket];
1740 } 1749 }
1741 sk = sk_next(st->syn_wait_sk); 1750 sk = sk_next(st->syn_wait_sk);
1742 st->state = TCP_SEQ_STATE_LISTENING; 1751 st->state = TCP_SEQ_STATE_LISTENING;
1743 read_unlock_bh(&tp->accept_queue.syn_wait_lock); 1752 read_unlock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
1744 } else { 1753 } else {
1745 tp = tcp_sk(sk); 1754 icsk = inet_csk(sk);
1746 read_lock_bh(&tp->accept_queue.syn_wait_lock); 1755 read_lock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
1747 if (reqsk_queue_len(&tp->accept_queue)) 1756 if (reqsk_queue_len(&icsk->icsk_accept_queue))
1748 goto start_req; 1757 goto start_req;
1749 read_unlock_bh(&tp->accept_queue.syn_wait_lock); 1758 read_unlock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
1750 sk = sk_next(sk); 1759 sk = sk_next(sk);
1751 } 1760 }
1752get_sk: 1761get_sk:
@@ -1755,9 +1764,9 @@ get_sk:
1755 cur = sk; 1764 cur = sk;
1756 goto out; 1765 goto out;
1757 } 1766 }
1758 tp = tcp_sk(sk); 1767 icsk = inet_csk(sk);
1759 read_lock_bh(&tp->accept_queue.syn_wait_lock); 1768 read_lock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
1760 if (reqsk_queue_len(&tp->accept_queue)) { 1769 if (reqsk_queue_len(&icsk->icsk_accept_queue)) {
1761start_req: 1770start_req:
1762 st->uid = sock_i_uid(sk); 1771 st->uid = sock_i_uid(sk);
1763 st->syn_wait_sk = sk; 1772 st->syn_wait_sk = sk;
@@ -1765,7 +1774,7 @@ start_req:
1765 st->sbucket = 0; 1774 st->sbucket = 0;
1766 goto get_req; 1775 goto get_req;
1767 } 1776 }
1768 read_unlock_bh(&tp->accept_queue.syn_wait_lock); 1777 read_unlock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
1769 } 1778 }
1770 if (++st->bucket < INET_LHTABLE_SIZE) { 1779 if (++st->bucket < INET_LHTABLE_SIZE) {
1771 sk = sk_head(&tcp_hashinfo.listening_hash[st->bucket]); 1780 sk = sk_head(&tcp_hashinfo.listening_hash[st->bucket]);
@@ -1951,8 +1960,8 @@ static void tcp_seq_stop(struct seq_file *seq, void *v)
1951 switch (st->state) { 1960 switch (st->state) {
1952 case TCP_SEQ_STATE_OPENREQ: 1961 case TCP_SEQ_STATE_OPENREQ:
1953 if (v) { 1962 if (v) {
1954 struct tcp_sock *tp = tcp_sk(st->syn_wait_sk); 1963 struct inet_connection_sock *icsk = inet_csk(st->syn_wait_sk);
1955 read_unlock_bh(&tp->accept_queue.syn_wait_lock); 1964 read_unlock_bh(&icsk->icsk_accept_queue.syn_wait_lock);
1956 } 1965 }
1957 case TCP_SEQ_STATE_LISTENING: 1966 case TCP_SEQ_STATE_LISTENING:
1958 if (v != SEQ_START_TOKEN) 1967 if (v != SEQ_START_TOKEN)
@@ -2058,18 +2067,19 @@ static void get_tcp4_sock(struct sock *sp, char *tmpbuf, int i)
2058 int timer_active; 2067 int timer_active;
2059 unsigned long timer_expires; 2068 unsigned long timer_expires;
2060 struct tcp_sock *tp = tcp_sk(sp); 2069 struct tcp_sock *tp = tcp_sk(sp);
2070 const struct inet_connection_sock *icsk = inet_csk(sp);
2061 struct inet_sock *inet = inet_sk(sp); 2071 struct inet_sock *inet = inet_sk(sp);
2062 unsigned int dest = inet->daddr; 2072 unsigned int dest = inet->daddr;
2063 unsigned int src = inet->rcv_saddr; 2073 unsigned int src = inet->rcv_saddr;
2064 __u16 destp = ntohs(inet->dport); 2074 __u16 destp = ntohs(inet->dport);
2065 __u16 srcp = ntohs(inet->sport); 2075 __u16 srcp = ntohs(inet->sport);
2066 2076
2067 if (tp->pending == TCP_TIME_RETRANS) { 2077 if (icsk->icsk_pending == ICSK_TIME_RETRANS) {
2068 timer_active = 1; 2078 timer_active = 1;
2069 timer_expires = tp->timeout; 2079 timer_expires = icsk->icsk_timeout;
2070 } else if (tp->pending == TCP_TIME_PROBE0) { 2080 } else if (icsk->icsk_pending == ICSK_TIME_PROBE0) {
2071 timer_active = 4; 2081 timer_active = 4;
2072 timer_expires = tp->timeout; 2082 timer_expires = icsk->icsk_timeout;
2073 } else if (timer_pending(&sp->sk_timer)) { 2083 } else if (timer_pending(&sp->sk_timer)) {
2074 timer_active = 2; 2084 timer_active = 2;
2075 timer_expires = sp->sk_timer.expires; 2085 timer_expires = sp->sk_timer.expires;
@@ -2084,12 +2094,14 @@ static void get_tcp4_sock(struct sock *sp, char *tmpbuf, int i)
2084 tp->write_seq - tp->snd_una, tp->rcv_nxt - tp->copied_seq, 2094 tp->write_seq - tp->snd_una, tp->rcv_nxt - tp->copied_seq,
2085 timer_active, 2095 timer_active,
2086 jiffies_to_clock_t(timer_expires - jiffies), 2096 jiffies_to_clock_t(timer_expires - jiffies),
2087 tp->retransmits, 2097 icsk->icsk_retransmits,
2088 sock_i_uid(sp), 2098 sock_i_uid(sp),
2089 tp->probes_out, 2099 tp->probes_out,
2090 sock_i_ino(sp), 2100 sock_i_ino(sp),
2091 atomic_read(&sp->sk_refcnt), sp, 2101 atomic_read(&sp->sk_refcnt), sp,
2092 tp->rto, tp->ack.ato, (tp->ack.quick << 1) | tp->ack.pingpong, 2102 icsk->icsk_rto,
2103 icsk->icsk_ack.ato,
2104 (icsk->icsk_ack.quick << 1) | icsk->icsk_ack.pingpong,
2093 tp->snd_cwnd, 2105 tp->snd_cwnd,
2094 tp->snd_ssthresh >= 0xFFFF ? -1 : tp->snd_ssthresh); 2106 tp->snd_ssthresh >= 0xFFFF ? -1 : tp->snd_ssthresh);
2095} 2107}
@@ -2174,7 +2186,7 @@ struct proto tcp_prot = {
2174 .close = tcp_close, 2186 .close = tcp_close,
2175 .connect = tcp_v4_connect, 2187 .connect = tcp_v4_connect,
2176 .disconnect = tcp_disconnect, 2188 .disconnect = tcp_disconnect,
2177 .accept = tcp_accept, 2189 .accept = inet_csk_accept,
2178 .ioctl = tcp_ioctl, 2190 .ioctl = tcp_ioctl,
2179 .init = tcp_v4_init_sock, 2191 .init = tcp_v4_init_sock,
2180 .destroy = tcp_v4_destroy_sock, 2192 .destroy = tcp_v4_destroy_sock,
diff --git a/net/ipv4/tcp_minisocks.c b/net/ipv4/tcp_minisocks.c
index 8b6cd8d80662..56823704eb7d 100644
--- a/net/ipv4/tcp_minisocks.c
+++ b/net/ipv4/tcp_minisocks.c
@@ -271,7 +271,8 @@ void tcp_time_wait(struct sock *sk, int state, int timeo)
271 271
272 if (tw != NULL) { 272 if (tw != NULL) {
273 struct tcp_timewait_sock *tcptw = tcp_twsk((struct sock *)tw); 273 struct tcp_timewait_sock *tcptw = tcp_twsk((struct sock *)tw);
274 const int rto = (tp->rto << 2) - (tp->rto >> 1); 274 const struct inet_connection_sock *icsk = inet_csk(sk);
275 const int rto = (icsk->icsk_rto << 2) - (icsk->icsk_rto >> 1);
275 276
276 tw->tw_rcv_wscale = tp->rx_opt.rcv_wscale; 277 tw->tw_rcv_wscale = tp->rx_opt.rcv_wscale;
277 tcptw->tw_rcv_nxt = tp->rcv_nxt; 278 tcptw->tw_rcv_nxt = tp->rcv_nxt;
@@ -605,10 +606,11 @@ struct sock *tcp_create_openreq_child(struct sock *sk, struct request_sock *req,
605 struct inet_request_sock *ireq = inet_rsk(req); 606 struct inet_request_sock *ireq = inet_rsk(req);
606 struct tcp_request_sock *treq = tcp_rsk(req); 607 struct tcp_request_sock *treq = tcp_rsk(req);
607 struct inet_sock *newinet = inet_sk(newsk); 608 struct inet_sock *newinet = inet_sk(newsk);
609 struct inet_connection_sock *newicsk = inet_csk(newsk);
608 struct tcp_sock *newtp; 610 struct tcp_sock *newtp;
609 611
610 newsk->sk_state = TCP_SYN_RECV; 612 newsk->sk_state = TCP_SYN_RECV;
611 newinet->bind_hash = NULL; 613 newicsk->icsk_bind_hash = NULL;
612 614
613 /* Clone the TCP header template */ 615 /* Clone the TCP header template */
614 newinet->dport = ireq->rmt_port; 616 newinet->dport = ireq->rmt_port;
@@ -624,11 +626,11 @@ struct sock *tcp_create_openreq_child(struct sock *sk, struct request_sock *req,
624 626
625 tcp_init_wl(newtp, treq->snt_isn, treq->rcv_isn); 627 tcp_init_wl(newtp, treq->snt_isn, treq->rcv_isn);
626 628
627 newtp->retransmits = 0; 629 newicsk->icsk_retransmits = 0;
628 newtp->backoff = 0; 630 newicsk->icsk_backoff = 0;
629 newtp->srtt = 0; 631 newtp->srtt = 0;
630 newtp->mdev = TCP_TIMEOUT_INIT; 632 newtp->mdev = TCP_TIMEOUT_INIT;
631 newtp->rto = TCP_TIMEOUT_INIT; 633 newicsk->icsk_rto = TCP_TIMEOUT_INIT;
632 634
633 newtp->packets_out = 0; 635 newtp->packets_out = 0;
634 newtp->left_out = 0; 636 newtp->left_out = 0;
@@ -667,11 +669,11 @@ struct sock *tcp_create_openreq_child(struct sock *sk, struct request_sock *req,
667 newtp->rx_opt.num_sacks = 0; 669 newtp->rx_opt.num_sacks = 0;
668 newtp->urg_data = 0; 670 newtp->urg_data = 0;
669 /* Deinitialize accept_queue to trap illegal accesses. */ 671 /* Deinitialize accept_queue to trap illegal accesses. */
670 memset(&newtp->accept_queue, 0, sizeof(newtp->accept_queue)); 672 memset(&newicsk->icsk_accept_queue, 0, sizeof(newicsk->icsk_accept_queue));
671 673
672 if (sock_flag(newsk, SOCK_KEEPOPEN)) 674 if (sock_flag(newsk, SOCK_KEEPOPEN))
673 tcp_reset_keepalive_timer(newsk, 675 inet_csk_reset_keepalive_timer(newsk,
674 keepalive_time_when(newtp)); 676 keepalive_time_when(newtp));
675 677
676 newtp->rx_opt.tstamp_ok = ireq->tstamp_ok; 678 newtp->rx_opt.tstamp_ok = ireq->tstamp_ok;
677 if((newtp->rx_opt.sack_ok = ireq->sack_ok) != 0) { 679 if((newtp->rx_opt.sack_ok = ireq->sack_ok) != 0) {
@@ -701,7 +703,7 @@ struct sock *tcp_create_openreq_child(struct sock *sk, struct request_sock *req,
701 newtp->tcp_header_len = sizeof(struct tcphdr); 703 newtp->tcp_header_len = sizeof(struct tcphdr);
702 } 704 }
703 if (skb->len >= TCP_MIN_RCVMSS+newtp->tcp_header_len) 705 if (skb->len >= TCP_MIN_RCVMSS+newtp->tcp_header_len)
704 newtp->ack.last_seg_size = skb->len-newtp->tcp_header_len; 706 newicsk->icsk_ack.last_seg_size = skb->len - newtp->tcp_header_len;
705 newtp->rx_opt.mss_clamp = req->mss; 707 newtp->rx_opt.mss_clamp = req->mss;
706 TCP_ECN_openreq_child(newtp, req); 708 TCP_ECN_openreq_child(newtp, req);
707 if (newtp->ecn_flags&TCP_ECN_OK) 709 if (newtp->ecn_flags&TCP_ECN_OK)
@@ -881,10 +883,10 @@ struct sock *tcp_check_req(struct sock *sk,struct sk_buff *skb,
881 if (child == NULL) 883 if (child == NULL)
882 goto listen_overflow; 884 goto listen_overflow;
883 885
884 tcp_synq_unlink(tp, req, prev); 886 inet_csk_reqsk_queue_unlink(sk, req, prev);
885 tcp_synq_removed(sk, req); 887 inet_csk_reqsk_queue_removed(sk, req);
886 888
887 tcp_acceptq_queue(sk, req, child); 889 inet_csk_reqsk_queue_add(sk, req, child);
888 return child; 890 return child;
889 891
890 listen_overflow: 892 listen_overflow:
@@ -898,7 +900,7 @@ struct sock *tcp_check_req(struct sock *sk,struct sk_buff *skb,
898 if (!(flg & TCP_FLAG_RST)) 900 if (!(flg & TCP_FLAG_RST))
899 req->rsk_ops->send_reset(skb); 901 req->rsk_ops->send_reset(skb);
900 902
901 tcp_synq_drop(sk, req, prev); 903 inet_csk_reqsk_queue_drop(sk, req, prev);
902 return NULL; 904 return NULL;
903} 905}
904 906
diff --git a/net/ipv4/tcp_output.c b/net/ipv4/tcp_output.c
index a4d1eb9a0926..6f0a7e30ceac 100644
--- a/net/ipv4/tcp_output.c
+++ b/net/ipv4/tcp_output.c
@@ -105,8 +105,9 @@ static __u16 tcp_advertise_mss(struct sock *sk)
105 105
106/* RFC2861. Reset CWND after idle period longer RTO to "restart window". 106/* RFC2861. Reset CWND after idle period longer RTO to "restart window".
107 * This is the first part of cwnd validation mechanism. */ 107 * This is the first part of cwnd validation mechanism. */
108static void tcp_cwnd_restart(struct tcp_sock *tp, struct dst_entry *dst) 108static void tcp_cwnd_restart(struct sock *sk, struct dst_entry *dst)
109{ 109{
110 struct tcp_sock *tp = tcp_sk(sk);
110 s32 delta = tcp_time_stamp - tp->lsndtime; 111 s32 delta = tcp_time_stamp - tp->lsndtime;
111 u32 restart_cwnd = tcp_init_cwnd(tp, dst); 112 u32 restart_cwnd = tcp_init_cwnd(tp, dst);
112 u32 cwnd = tp->snd_cwnd; 113 u32 cwnd = tp->snd_cwnd;
@@ -116,7 +117,7 @@ static void tcp_cwnd_restart(struct tcp_sock *tp, struct dst_entry *dst)
116 tp->snd_ssthresh = tcp_current_ssthresh(tp); 117 tp->snd_ssthresh = tcp_current_ssthresh(tp);
117 restart_cwnd = min(restart_cwnd, cwnd); 118 restart_cwnd = min(restart_cwnd, cwnd);
118 119
119 while ((delta -= tp->rto) > 0 && cwnd > restart_cwnd) 120 while ((delta -= inet_csk(sk)->icsk_rto) > 0 && cwnd > restart_cwnd)
120 cwnd >>= 1; 121 cwnd >>= 1;
121 tp->snd_cwnd = max(cwnd, restart_cwnd); 122 tp->snd_cwnd = max(cwnd, restart_cwnd);
122 tp->snd_cwnd_stamp = tcp_time_stamp; 123 tp->snd_cwnd_stamp = tcp_time_stamp;
@@ -126,26 +127,25 @@ static void tcp_cwnd_restart(struct tcp_sock *tp, struct dst_entry *dst)
126static inline void tcp_event_data_sent(struct tcp_sock *tp, 127static inline void tcp_event_data_sent(struct tcp_sock *tp,
127 struct sk_buff *skb, struct sock *sk) 128 struct sk_buff *skb, struct sock *sk)
128{ 129{
129 u32 now = tcp_time_stamp; 130 struct inet_connection_sock *icsk = inet_csk(sk);
131 const u32 now = tcp_time_stamp;
130 132
131 if (!tp->packets_out && (s32)(now - tp->lsndtime) > tp->rto) 133 if (!tp->packets_out && (s32)(now - tp->lsndtime) > icsk->icsk_rto)
132 tcp_cwnd_restart(tp, __sk_dst_get(sk)); 134 tcp_cwnd_restart(sk, __sk_dst_get(sk));
133 135
134 tp->lsndtime = now; 136 tp->lsndtime = now;
135 137
136 /* If it is a reply for ato after last received 138 /* If it is a reply for ato after last received
137 * packet, enter pingpong mode. 139 * packet, enter pingpong mode.
138 */ 140 */
139 if ((u32)(now - tp->ack.lrcvtime) < tp->ack.ato) 141 if ((u32)(now - icsk->icsk_ack.lrcvtime) < icsk->icsk_ack.ato)
140 tp->ack.pingpong = 1; 142 icsk->icsk_ack.pingpong = 1;
141} 143}
142 144
143static __inline__ void tcp_event_ack_sent(struct sock *sk, unsigned int pkts) 145static __inline__ void tcp_event_ack_sent(struct sock *sk, unsigned int pkts)
144{ 146{
145 struct tcp_sock *tp = tcp_sk(sk); 147 tcp_dec_quickack_mode(sk, pkts);
146 148 inet_csk_clear_xmit_timer(sk, ICSK_TIME_DACK);
147 tcp_dec_quickack_mode(tp, pkts);
148 tcp_clear_xmit_timer(sk, TCP_TIME_DACK);
149} 149}
150 150
151/* Determine a window scaling and initial window to offer. 151/* Determine a window scaling and initial window to offer.
@@ -696,7 +696,7 @@ static inline void tcp_cwnd_validate(struct sock *sk, struct tcp_sock *tp)
696 if (tp->packets_out > tp->snd_cwnd_used) 696 if (tp->packets_out > tp->snd_cwnd_used)
697 tp->snd_cwnd_used = tp->packets_out; 697 tp->snd_cwnd_used = tp->packets_out;
698 698
699 if ((s32)(tcp_time_stamp - tp->snd_cwnd_stamp) >= tp->rto) 699 if ((s32)(tcp_time_stamp - tp->snd_cwnd_stamp) >= inet_csk(sk)->icsk_rto)
700 tcp_cwnd_application_limited(sk); 700 tcp_cwnd_application_limited(sk);
701 } 701 }
702} 702}
@@ -1147,6 +1147,7 @@ void tcp_push_one(struct sock *sk, unsigned int mss_now)
1147 */ 1147 */
1148u32 __tcp_select_window(struct sock *sk) 1148u32 __tcp_select_window(struct sock *sk)
1149{ 1149{
1150 struct inet_connection_sock *icsk = inet_csk(sk);
1150 struct tcp_sock *tp = tcp_sk(sk); 1151 struct tcp_sock *tp = tcp_sk(sk);
1151 /* MSS for the peer's data. Previous verions used mss_clamp 1152 /* MSS for the peer's data. Previous verions used mss_clamp
1152 * here. I don't know if the value based on our guesses 1153 * here. I don't know if the value based on our guesses
@@ -1154,7 +1155,7 @@ u32 __tcp_select_window(struct sock *sk)
1154 * but may be worse for the performance because of rcv_mss 1155 * but may be worse for the performance because of rcv_mss
1155 * fluctuations. --SAW 1998/11/1 1156 * fluctuations. --SAW 1998/11/1
1156 */ 1157 */
1157 int mss = tp->ack.rcv_mss; 1158 int mss = icsk->icsk_ack.rcv_mss;
1158 int free_space = tcp_space(sk); 1159 int free_space = tcp_space(sk);
1159 int full_space = min_t(int, tp->window_clamp, tcp_full_space(sk)); 1160 int full_space = min_t(int, tp->window_clamp, tcp_full_space(sk));
1160 int window; 1161 int window;
@@ -1163,7 +1164,7 @@ u32 __tcp_select_window(struct sock *sk)
1163 mss = full_space; 1164 mss = full_space;
1164 1165
1165 if (free_space < full_space/2) { 1166 if (free_space < full_space/2) {
1166 tp->ack.quick = 0; 1167 icsk->icsk_ack.quick = 0;
1167 1168
1168 if (tcp_memory_pressure) 1169 if (tcp_memory_pressure)
1169 tp->rcv_ssthresh = min(tp->rcv_ssthresh, 4U*tp->advmss); 1170 tp->rcv_ssthresh = min(tp->rcv_ssthresh, 4U*tp->advmss);
@@ -1491,7 +1492,8 @@ void tcp_xmit_retransmit_queue(struct sock *sk)
1491 1492
1492 if (skb == 1493 if (skb ==
1493 skb_peek(&sk->sk_write_queue)) 1494 skb_peek(&sk->sk_write_queue))
1494 tcp_reset_xmit_timer(sk, TCP_TIME_RETRANS, tp->rto); 1495 inet_csk_reset_xmit_timer(sk, ICSK_TIME_RETRANS,
1496 inet_csk(sk)->icsk_rto);
1495 } 1497 }
1496 1498
1497 packet_cnt -= tcp_skb_pcount(skb); 1499 packet_cnt -= tcp_skb_pcount(skb);
@@ -1544,7 +1546,7 @@ void tcp_xmit_retransmit_queue(struct sock *sk)
1544 break; 1546 break;
1545 1547
1546 if (skb == skb_peek(&sk->sk_write_queue)) 1548 if (skb == skb_peek(&sk->sk_write_queue))
1547 tcp_reset_xmit_timer(sk, TCP_TIME_RETRANS, tp->rto); 1549 inet_csk_reset_xmit_timer(sk, ICSK_TIME_RETRANS, inet_csk(sk)->icsk_rto);
1548 1550
1549 NET_INC_STATS_BH(LINUX_MIB_TCPFORWARDRETRANS); 1551 NET_INC_STATS_BH(LINUX_MIB_TCPFORWARDRETRANS);
1550 } 1552 }
@@ -1780,8 +1782,8 @@ static inline void tcp_connect_init(struct sock *sk)
1780 tp->rcv_wup = 0; 1782 tp->rcv_wup = 0;
1781 tp->copied_seq = 0; 1783 tp->copied_seq = 0;
1782 1784
1783 tp->rto = TCP_TIMEOUT_INIT; 1785 inet_csk(sk)->icsk_rto = TCP_TIMEOUT_INIT;
1784 tp->retransmits = 0; 1786 inet_csk(sk)->icsk_retransmits = 0;
1785 tcp_clear_retrans(tp); 1787 tcp_clear_retrans(tp);
1786} 1788}
1787 1789
@@ -1824,7 +1826,7 @@ int tcp_connect(struct sock *sk)
1824 TCP_INC_STATS(TCP_MIB_ACTIVEOPENS); 1826 TCP_INC_STATS(TCP_MIB_ACTIVEOPENS);
1825 1827
1826 /* Timer for repeating the SYN until an answer. */ 1828 /* Timer for repeating the SYN until an answer. */
1827 tcp_reset_xmit_timer(sk, TCP_TIME_RETRANS, tp->rto); 1829 inet_csk_reset_xmit_timer(sk, ICSK_TIME_RETRANS, inet_csk(sk)->icsk_rto);
1828 return 0; 1830 return 0;
1829} 1831}
1830 1832
@@ -1834,20 +1836,21 @@ int tcp_connect(struct sock *sk)
1834 */ 1836 */
1835void tcp_send_delayed_ack(struct sock *sk) 1837void tcp_send_delayed_ack(struct sock *sk)
1836{ 1838{
1837 struct tcp_sock *tp = tcp_sk(sk); 1839 struct inet_connection_sock *icsk = inet_csk(sk);
1838 int ato = tp->ack.ato; 1840 int ato = icsk->icsk_ack.ato;
1839 unsigned long timeout; 1841 unsigned long timeout;
1840 1842
1841 if (ato > TCP_DELACK_MIN) { 1843 if (ato > TCP_DELACK_MIN) {
1844 const struct tcp_sock *tp = tcp_sk(sk);
1842 int max_ato = HZ/2; 1845 int max_ato = HZ/2;
1843 1846
1844 if (tp->ack.pingpong || (tp->ack.pending&TCP_ACK_PUSHED)) 1847 if (icsk->icsk_ack.pingpong || (icsk->icsk_ack.pending & ICSK_ACK_PUSHED))
1845 max_ato = TCP_DELACK_MAX; 1848 max_ato = TCP_DELACK_MAX;
1846 1849
1847 /* Slow path, intersegment interval is "high". */ 1850 /* Slow path, intersegment interval is "high". */
1848 1851
1849 /* If some rtt estimate is known, use it to bound delayed ack. 1852 /* If some rtt estimate is known, use it to bound delayed ack.
1850 * Do not use tp->rto here, use results of rtt measurements 1853 * Do not use inet_csk(sk)->icsk_rto here, use results of rtt measurements
1851 * directly. 1854 * directly.
1852 */ 1855 */
1853 if (tp->srtt) { 1856 if (tp->srtt) {
@@ -1864,21 +1867,22 @@ void tcp_send_delayed_ack(struct sock *sk)
1864 timeout = jiffies + ato; 1867 timeout = jiffies + ato;
1865 1868
1866 /* Use new timeout only if there wasn't a older one earlier. */ 1869 /* Use new timeout only if there wasn't a older one earlier. */
1867 if (tp->ack.pending&TCP_ACK_TIMER) { 1870 if (icsk->icsk_ack.pending & ICSK_ACK_TIMER) {
1868 /* If delack timer was blocked or is about to expire, 1871 /* If delack timer was blocked or is about to expire,
1869 * send ACK now. 1872 * send ACK now.
1870 */ 1873 */
1871 if (tp->ack.blocked || time_before_eq(tp->ack.timeout, jiffies+(ato>>2))) { 1874 if (icsk->icsk_ack.blocked ||
1875 time_before_eq(icsk->icsk_ack.timeout, jiffies + (ato >> 2))) {
1872 tcp_send_ack(sk); 1876 tcp_send_ack(sk);
1873 return; 1877 return;
1874 } 1878 }
1875 1879
1876 if (!time_before(timeout, tp->ack.timeout)) 1880 if (!time_before(timeout, icsk->icsk_ack.timeout))
1877 timeout = tp->ack.timeout; 1881 timeout = icsk->icsk_ack.timeout;
1878 } 1882 }
1879 tp->ack.pending |= TCP_ACK_SCHED|TCP_ACK_TIMER; 1883 icsk->icsk_ack.pending |= ICSK_ACK_SCHED | ICSK_ACK_TIMER;
1880 tp->ack.timeout = timeout; 1884 icsk->icsk_ack.timeout = timeout;
1881 sk_reset_timer(sk, &tp->delack_timer, timeout); 1885 sk_reset_timer(sk, &icsk->icsk_delack_timer, timeout);
1882} 1886}
1883 1887
1884/* This routine sends an ack and also updates the window. */ 1888/* This routine sends an ack and also updates the window. */
@@ -1895,9 +1899,9 @@ void tcp_send_ack(struct sock *sk)
1895 */ 1899 */
1896 buff = alloc_skb(MAX_TCP_HEADER, GFP_ATOMIC); 1900 buff = alloc_skb(MAX_TCP_HEADER, GFP_ATOMIC);
1897 if (buff == NULL) { 1901 if (buff == NULL) {
1898 tcp_schedule_ack(tp); 1902 inet_csk_schedule_ack(sk);
1899 tp->ack.ato = TCP_ATO_MIN; 1903 inet_csk(sk)->icsk_ack.ato = TCP_ATO_MIN;
1900 tcp_reset_xmit_timer(sk, TCP_TIME_DACK, TCP_DELACK_MAX); 1904 inet_csk_reset_xmit_timer(sk, ICSK_TIME_DACK, TCP_DELACK_MAX);
1901 return; 1905 return;
1902 } 1906 }
1903 1907
@@ -2011,6 +2015,7 @@ int tcp_write_wakeup(struct sock *sk)
2011 */ 2015 */
2012void tcp_send_probe0(struct sock *sk) 2016void tcp_send_probe0(struct sock *sk)
2013{ 2017{
2018 struct inet_connection_sock *icsk = inet_csk(sk);
2014 struct tcp_sock *tp = tcp_sk(sk); 2019 struct tcp_sock *tp = tcp_sk(sk);
2015 int err; 2020 int err;
2016 2021
@@ -2019,16 +2024,16 @@ void tcp_send_probe0(struct sock *sk)
2019 if (tp->packets_out || !sk->sk_send_head) { 2024 if (tp->packets_out || !sk->sk_send_head) {
2020 /* Cancel probe timer, if it is not required. */ 2025 /* Cancel probe timer, if it is not required. */
2021 tp->probes_out = 0; 2026 tp->probes_out = 0;
2022 tp->backoff = 0; 2027 icsk->icsk_backoff = 0;
2023 return; 2028 return;
2024 } 2029 }
2025 2030
2026 if (err <= 0) { 2031 if (err <= 0) {
2027 if (tp->backoff < sysctl_tcp_retries2) 2032 if (icsk->icsk_backoff < sysctl_tcp_retries2)
2028 tp->backoff++; 2033 icsk->icsk_backoff++;
2029 tp->probes_out++; 2034 tp->probes_out++;
2030 tcp_reset_xmit_timer (sk, TCP_TIME_PROBE0, 2035 inet_csk_reset_xmit_timer(sk, ICSK_TIME_PROBE0,
2031 min(tp->rto << tp->backoff, TCP_RTO_MAX)); 2036 min(icsk->icsk_rto << icsk->icsk_backoff, TCP_RTO_MAX));
2032 } else { 2037 } else {
2033 /* If packet was not sent due to local congestion, 2038 /* If packet was not sent due to local congestion,
2034 * do not backoff and do not remember probes_out. 2039 * do not backoff and do not remember probes_out.
@@ -2038,8 +2043,9 @@ void tcp_send_probe0(struct sock *sk)
2038 */ 2043 */
2039 if (!tp->probes_out) 2044 if (!tp->probes_out)
2040 tp->probes_out=1; 2045 tp->probes_out=1;
2041 tcp_reset_xmit_timer (sk, TCP_TIME_PROBE0, 2046 inet_csk_reset_xmit_timer(sk, ICSK_TIME_PROBE0,
2042 min(tp->rto << tp->backoff, TCP_RESOURCE_PROBE_INTERVAL)); 2047 min(icsk->icsk_rto << icsk->icsk_backoff,
2048 TCP_RESOURCE_PROBE_INTERVAL));
2043 } 2049 }
2044} 2050}
2045 2051
diff --git a/net/ipv4/tcp_timer.c b/net/ipv4/tcp_timer.c
index 0084227438c2..0b71380ee42f 100644
--- a/net/ipv4/tcp_timer.c
+++ b/net/ipv4/tcp_timer.c
@@ -36,9 +36,9 @@ static void tcp_write_timer(unsigned long);
36static void tcp_delack_timer(unsigned long); 36static void tcp_delack_timer(unsigned long);
37static void tcp_keepalive_timer (unsigned long data); 37static void tcp_keepalive_timer (unsigned long data);
38 38
39#ifdef TCP_DEBUG 39#ifdef INET_CSK_DEBUG
40const char tcp_timer_bug_msg[] = KERN_DEBUG "tcpbug: unknown timer value\n"; 40const char inet_csk_timer_bug_msg[] = "inet_csk BUG: unknown timer value\n";
41EXPORT_SYMBOL(tcp_timer_bug_msg); 41EXPORT_SYMBOL(inet_csk_timer_bug_msg);
42#endif 42#endif
43 43
44/* 44/*
@@ -46,40 +46,45 @@ EXPORT_SYMBOL(tcp_timer_bug_msg);
46 * We may wish use just one timer maintaining a list of expire jiffies 46 * We may wish use just one timer maintaining a list of expire jiffies
47 * to optimize. 47 * to optimize.
48 */ 48 */
49 49void inet_csk_init_xmit_timers(struct sock *sk,
50void tcp_init_xmit_timers(struct sock *sk) 50 void (*retransmit_handler)(unsigned long),
51 void (*delack_handler)(unsigned long),
52 void (*keepalive_handler)(unsigned long))
51{ 53{
52 struct tcp_sock *tp = tcp_sk(sk); 54 struct inet_connection_sock *icsk = inet_csk(sk);
53 55
54 init_timer(&tp->retransmit_timer); 56 init_timer(&icsk->icsk_retransmit_timer);
55 tp->retransmit_timer.function=&tcp_write_timer; 57 init_timer(&icsk->icsk_delack_timer);
56 tp->retransmit_timer.data = (unsigned long) sk; 58 init_timer(&sk->sk_timer);
57 tp->pending = 0;
58 59
59 init_timer(&tp->delack_timer); 60 icsk->icsk_retransmit_timer.function = retransmit_handler;
60 tp->delack_timer.function=&tcp_delack_timer; 61 icsk->icsk_delack_timer.function = delack_handler;
61 tp->delack_timer.data = (unsigned long) sk; 62 sk->sk_timer.function = keepalive_handler;
62 tp->ack.pending = 0;
63 63
64 init_timer(&sk->sk_timer); 64 icsk->icsk_retransmit_timer.data =
65 sk->sk_timer.function = &tcp_keepalive_timer; 65 icsk->icsk_delack_timer.data =
66 sk->sk_timer.data = (unsigned long)sk; 66 sk->sk_timer.data = (unsigned long)sk;
67
68 icsk->icsk_pending = icsk->icsk_ack.pending = 0;
67} 69}
68 70
69void tcp_clear_xmit_timers(struct sock *sk) 71void inet_csk_clear_xmit_timers(struct sock *sk)
70{ 72{
71 struct tcp_sock *tp = tcp_sk(sk); 73 struct inet_connection_sock *icsk = inet_csk(sk);
72 74
73 tp->pending = 0; 75 icsk->icsk_pending = icsk->icsk_ack.pending = icsk->icsk_ack.blocked = 0;
74 sk_stop_timer(sk, &tp->retransmit_timer);
75
76 tp->ack.pending = 0;
77 tp->ack.blocked = 0;
78 sk_stop_timer(sk, &tp->delack_timer);
79 76
77 sk_stop_timer(sk, &icsk->icsk_retransmit_timer);
78 sk_stop_timer(sk, &icsk->icsk_delack_timer);
80 sk_stop_timer(sk, &sk->sk_timer); 79 sk_stop_timer(sk, &sk->sk_timer);
81} 80}
82 81
82void tcp_init_xmit_timers(struct sock *sk)
83{
84 inet_csk_init_xmit_timers(sk, &tcp_write_timer, &tcp_delack_timer,
85 &tcp_keepalive_timer);
86}
87
83static void tcp_write_err(struct sock *sk) 88static void tcp_write_err(struct sock *sk)
84{ 89{
85 sk->sk_err = sk->sk_err_soft ? : ETIMEDOUT; 90 sk->sk_err = sk->sk_err_soft ? : ETIMEDOUT;
@@ -155,15 +160,15 @@ static int tcp_orphan_retries(struct sock *sk, int alive)
155/* A write timeout has occurred. Process the after effects. */ 160/* A write timeout has occurred. Process the after effects. */
156static int tcp_write_timeout(struct sock *sk) 161static int tcp_write_timeout(struct sock *sk)
157{ 162{
158 struct tcp_sock *tp = tcp_sk(sk); 163 const struct inet_connection_sock *icsk = inet_csk(sk);
159 int retry_until; 164 int retry_until;
160 165
161 if ((1 << sk->sk_state) & (TCPF_SYN_SENT | TCPF_SYN_RECV)) { 166 if ((1 << sk->sk_state) & (TCPF_SYN_SENT | TCPF_SYN_RECV)) {
162 if (tp->retransmits) 167 if (icsk->icsk_retransmits)
163 dst_negative_advice(&sk->sk_dst_cache); 168 dst_negative_advice(&sk->sk_dst_cache);
164 retry_until = tp->syn_retries ? : sysctl_tcp_syn_retries; 169 retry_until = icsk->icsk_syn_retries ? : sysctl_tcp_syn_retries;
165 } else { 170 } else {
166 if (tp->retransmits >= sysctl_tcp_retries1) { 171 if (icsk->icsk_retransmits >= sysctl_tcp_retries1) {
167 /* NOTE. draft-ietf-tcpimpl-pmtud-01.txt requires pmtu black 172 /* NOTE. draft-ietf-tcpimpl-pmtud-01.txt requires pmtu black
168 hole detection. :-( 173 hole detection. :-(
169 174
@@ -189,16 +194,16 @@ static int tcp_write_timeout(struct sock *sk)
189 194
190 retry_until = sysctl_tcp_retries2; 195 retry_until = sysctl_tcp_retries2;
191 if (sock_flag(sk, SOCK_DEAD)) { 196 if (sock_flag(sk, SOCK_DEAD)) {
192 int alive = (tp->rto < TCP_RTO_MAX); 197 const int alive = (icsk->icsk_rto < TCP_RTO_MAX);
193 198
194 retry_until = tcp_orphan_retries(sk, alive); 199 retry_until = tcp_orphan_retries(sk, alive);
195 200
196 if (tcp_out_of_resources(sk, alive || tp->retransmits < retry_until)) 201 if (tcp_out_of_resources(sk, alive || icsk->icsk_retransmits < retry_until))
197 return 1; 202 return 1;
198 } 203 }
199 } 204 }
200 205
201 if (tp->retransmits >= retry_until) { 206 if (icsk->icsk_retransmits >= retry_until) {
202 /* Has it gone just too far? */ 207 /* Has it gone just too far? */
203 tcp_write_err(sk); 208 tcp_write_err(sk);
204 return 1; 209 return 1;
@@ -210,26 +215,27 @@ static void tcp_delack_timer(unsigned long data)
210{ 215{
211 struct sock *sk = (struct sock*)data; 216 struct sock *sk = (struct sock*)data;
212 struct tcp_sock *tp = tcp_sk(sk); 217 struct tcp_sock *tp = tcp_sk(sk);
218 struct inet_connection_sock *icsk = inet_csk(sk);
213 219
214 bh_lock_sock(sk); 220 bh_lock_sock(sk);
215 if (sock_owned_by_user(sk)) { 221 if (sock_owned_by_user(sk)) {
216 /* Try again later. */ 222 /* Try again later. */
217 tp->ack.blocked = 1; 223 icsk->icsk_ack.blocked = 1;
218 NET_INC_STATS_BH(LINUX_MIB_DELAYEDACKLOCKED); 224 NET_INC_STATS_BH(LINUX_MIB_DELAYEDACKLOCKED);
219 sk_reset_timer(sk, &tp->delack_timer, jiffies + TCP_DELACK_MIN); 225 sk_reset_timer(sk, &icsk->icsk_delack_timer, jiffies + TCP_DELACK_MIN);
220 goto out_unlock; 226 goto out_unlock;
221 } 227 }
222 228
223 sk_stream_mem_reclaim(sk); 229 sk_stream_mem_reclaim(sk);
224 230
225 if (sk->sk_state == TCP_CLOSE || !(tp->ack.pending & TCP_ACK_TIMER)) 231 if (sk->sk_state == TCP_CLOSE || !(icsk->icsk_ack.pending & ICSK_ACK_TIMER))
226 goto out; 232 goto out;
227 233
228 if (time_after(tp->ack.timeout, jiffies)) { 234 if (time_after(icsk->icsk_ack.timeout, jiffies)) {
229 sk_reset_timer(sk, &tp->delack_timer, tp->ack.timeout); 235 sk_reset_timer(sk, &icsk->icsk_delack_timer, icsk->icsk_ack.timeout);
230 goto out; 236 goto out;
231 } 237 }
232 tp->ack.pending &= ~TCP_ACK_TIMER; 238 icsk->icsk_ack.pending &= ~ICSK_ACK_TIMER;
233 239
234 if (!skb_queue_empty(&tp->ucopy.prequeue)) { 240 if (!skb_queue_empty(&tp->ucopy.prequeue)) {
235 struct sk_buff *skb; 241 struct sk_buff *skb;
@@ -242,16 +248,16 @@ static void tcp_delack_timer(unsigned long data)
242 tp->ucopy.memory = 0; 248 tp->ucopy.memory = 0;
243 } 249 }
244 250
245 if (tcp_ack_scheduled(tp)) { 251 if (inet_csk_ack_scheduled(sk)) {
246 if (!tp->ack.pingpong) { 252 if (!icsk->icsk_ack.pingpong) {
247 /* Delayed ACK missed: inflate ATO. */ 253 /* Delayed ACK missed: inflate ATO. */
248 tp->ack.ato = min(tp->ack.ato << 1, tp->rto); 254 icsk->icsk_ack.ato = min(icsk->icsk_ack.ato << 1, icsk->icsk_rto);
249 } else { 255 } else {
250 /* Delayed ACK missed: leave pingpong mode and 256 /* Delayed ACK missed: leave pingpong mode and
251 * deflate ATO. 257 * deflate ATO.
252 */ 258 */
253 tp->ack.pingpong = 0; 259 icsk->icsk_ack.pingpong = 0;
254 tp->ack.ato = TCP_ATO_MIN; 260 icsk->icsk_ack.ato = TCP_ATO_MIN;
255 } 261 }
256 tcp_send_ack(sk); 262 tcp_send_ack(sk);
257 NET_INC_STATS_BH(LINUX_MIB_DELAYEDACKS); 263 NET_INC_STATS_BH(LINUX_MIB_DELAYEDACKS);
@@ -294,7 +300,8 @@ static void tcp_probe_timer(struct sock *sk)
294 max_probes = sysctl_tcp_retries2; 300 max_probes = sysctl_tcp_retries2;
295 301
296 if (sock_flag(sk, SOCK_DEAD)) { 302 if (sock_flag(sk, SOCK_DEAD)) {
297 int alive = ((tp->rto<<tp->backoff) < TCP_RTO_MAX); 303 const struct inet_connection_sock *icsk = inet_csk(sk);
304 const int alive = ((icsk->icsk_rto << icsk->icsk_backoff) < TCP_RTO_MAX);
298 305
299 max_probes = tcp_orphan_retries(sk, alive); 306 max_probes = tcp_orphan_retries(sk, alive);
300 307
@@ -317,6 +324,7 @@ static void tcp_probe_timer(struct sock *sk)
317static void tcp_retransmit_timer(struct sock *sk) 324static void tcp_retransmit_timer(struct sock *sk)
318{ 325{
319 struct tcp_sock *tp = tcp_sk(sk); 326 struct tcp_sock *tp = tcp_sk(sk);
327 struct inet_connection_sock *icsk = inet_csk(sk);
320 328
321 if (!tp->packets_out) 329 if (!tp->packets_out)
322 goto out; 330 goto out;
@@ -351,7 +359,7 @@ static void tcp_retransmit_timer(struct sock *sk)
351 if (tcp_write_timeout(sk)) 359 if (tcp_write_timeout(sk))
352 goto out; 360 goto out;
353 361
354 if (tp->retransmits == 0) { 362 if (icsk->icsk_retransmits == 0) {
355 if (tp->ca_state == TCP_CA_Disorder || tp->ca_state == TCP_CA_Recovery) { 363 if (tp->ca_state == TCP_CA_Disorder || tp->ca_state == TCP_CA_Recovery) {
356 if (tp->rx_opt.sack_ok) { 364 if (tp->rx_opt.sack_ok) {
357 if (tp->ca_state == TCP_CA_Recovery) 365 if (tp->ca_state == TCP_CA_Recovery)
@@ -381,10 +389,10 @@ static void tcp_retransmit_timer(struct sock *sk)
381 /* Retransmission failed because of local congestion, 389 /* Retransmission failed because of local congestion,
382 * do not backoff. 390 * do not backoff.
383 */ 391 */
384 if (!tp->retransmits) 392 if (!icsk->icsk_retransmits)
385 tp->retransmits=1; 393 icsk->icsk_retransmits = 1;
386 tcp_reset_xmit_timer(sk, TCP_TIME_RETRANS, 394 inet_csk_reset_xmit_timer(sk, ICSK_TIME_RETRANS,
387 min(tp->rto, TCP_RESOURCE_PROBE_INTERVAL)); 395 min(icsk->icsk_rto, TCP_RESOURCE_PROBE_INTERVAL));
388 goto out; 396 goto out;
389 } 397 }
390 398
@@ -403,13 +411,13 @@ static void tcp_retransmit_timer(struct sock *sk)
403 * implemented ftp to mars will work nicely. We will have to fix 411 * implemented ftp to mars will work nicely. We will have to fix
404 * the 120 second clamps though! 412 * the 120 second clamps though!
405 */ 413 */
406 tp->backoff++; 414 icsk->icsk_backoff++;
407 tp->retransmits++; 415 icsk->icsk_retransmits++;
408 416
409out_reset_timer: 417out_reset_timer:
410 tp->rto = min(tp->rto << 1, TCP_RTO_MAX); 418 icsk->icsk_rto = min(icsk->icsk_rto << 1, TCP_RTO_MAX);
411 tcp_reset_xmit_timer(sk, TCP_TIME_RETRANS, tp->rto); 419 inet_csk_reset_xmit_timer(sk, ICSK_TIME_RETRANS, icsk->icsk_rto);
412 if (tp->retransmits > sysctl_tcp_retries1) 420 if (icsk->icsk_retransmits > sysctl_tcp_retries1)
413 __sk_dst_reset(sk); 421 __sk_dst_reset(sk);
414 422
415out:; 423out:;
@@ -418,32 +426,32 @@ out:;
418static void tcp_write_timer(unsigned long data) 426static void tcp_write_timer(unsigned long data)
419{ 427{
420 struct sock *sk = (struct sock*)data; 428 struct sock *sk = (struct sock*)data;
421 struct tcp_sock *tp = tcp_sk(sk); 429 struct inet_connection_sock *icsk = inet_csk(sk);
422 int event; 430 int event;
423 431
424 bh_lock_sock(sk); 432 bh_lock_sock(sk);
425 if (sock_owned_by_user(sk)) { 433 if (sock_owned_by_user(sk)) {
426 /* Try again later */ 434 /* Try again later */
427 sk_reset_timer(sk, &tp->retransmit_timer, jiffies + (HZ / 20)); 435 sk_reset_timer(sk, &icsk->icsk_retransmit_timer, jiffies + (HZ / 20));
428 goto out_unlock; 436 goto out_unlock;
429 } 437 }
430 438
431 if (sk->sk_state == TCP_CLOSE || !tp->pending) 439 if (sk->sk_state == TCP_CLOSE || !icsk->icsk_pending)
432 goto out; 440 goto out;
433 441
434 if (time_after(tp->timeout, jiffies)) { 442 if (time_after(icsk->icsk_timeout, jiffies)) {
435 sk_reset_timer(sk, &tp->retransmit_timer, tp->timeout); 443 sk_reset_timer(sk, &icsk->icsk_retransmit_timer, icsk->icsk_timeout);
436 goto out; 444 goto out;
437 } 445 }
438 446
439 event = tp->pending; 447 event = icsk->icsk_pending;
440 tp->pending = 0; 448 icsk->icsk_pending = 0;
441 449
442 switch (event) { 450 switch (event) {
443 case TCP_TIME_RETRANS: 451 case ICSK_TIME_RETRANS:
444 tcp_retransmit_timer(sk); 452 tcp_retransmit_timer(sk);
445 break; 453 break;
446 case TCP_TIME_PROBE0: 454 case ICSK_TIME_PROBE0:
447 tcp_probe_timer(sk); 455 tcp_probe_timer(sk);
448 break; 456 break;
449 } 457 }
@@ -463,8 +471,9 @@ out_unlock:
463static void tcp_synack_timer(struct sock *sk) 471static void tcp_synack_timer(struct sock *sk)
464{ 472{
465 struct tcp_sock *tp = tcp_sk(sk); 473 struct tcp_sock *tp = tcp_sk(sk);
466 struct listen_sock *lopt = tp->accept_queue.listen_opt; 474 struct inet_connection_sock *icsk = inet_csk(sk);
467 int max_retries = tp->syn_retries ? : sysctl_tcp_synack_retries; 475 struct listen_sock *lopt = icsk->icsk_accept_queue.listen_opt;
476 int max_retries = icsk->icsk_syn_retries ? : sysctl_tcp_synack_retries;
468 int thresh = max_retries; 477 int thresh = max_retries;
469 unsigned long now = jiffies; 478 unsigned long now = jiffies;
470 struct request_sock **reqp, *req; 479 struct request_sock **reqp, *req;
@@ -526,8 +535,8 @@ static void tcp_synack_timer(struct sock *sk)
526 } 535 }
527 536
528 /* Drop this request */ 537 /* Drop this request */
529 tcp_synq_unlink(tp, req, reqp); 538 inet_csk_reqsk_queue_unlink(sk, req, reqp);
530 reqsk_queue_removed(&tp->accept_queue, req); 539 reqsk_queue_removed(&icsk->icsk_accept_queue, req);
531 reqsk_free(req); 540 reqsk_free(req);
532 continue; 541 continue;
533 } 542 }
@@ -541,15 +550,15 @@ static void tcp_synack_timer(struct sock *sk)
541 lopt->clock_hand = i; 550 lopt->clock_hand = i;
542 551
543 if (lopt->qlen) 552 if (lopt->qlen)
544 tcp_reset_keepalive_timer(sk, TCP_SYNQ_INTERVAL); 553 inet_csk_reset_keepalive_timer(sk, TCP_SYNQ_INTERVAL);
545} 554}
546 555
547void tcp_delete_keepalive_timer (struct sock *sk) 556void inet_csk_delete_keepalive_timer(struct sock *sk)
548{ 557{
549 sk_stop_timer(sk, &sk->sk_timer); 558 sk_stop_timer(sk, &sk->sk_timer);
550} 559}
551 560
552void tcp_reset_keepalive_timer (struct sock *sk, unsigned long len) 561void inet_csk_reset_keepalive_timer(struct sock *sk, unsigned long len)
553{ 562{
554 sk_reset_timer(sk, &sk->sk_timer, jiffies + len); 563 sk_reset_timer(sk, &sk->sk_timer, jiffies + len);
555} 564}
@@ -560,9 +569,9 @@ void tcp_set_keepalive(struct sock *sk, int val)
560 return; 569 return;
561 570
562 if (val && !sock_flag(sk, SOCK_KEEPOPEN)) 571 if (val && !sock_flag(sk, SOCK_KEEPOPEN))
563 tcp_reset_keepalive_timer(sk, keepalive_time_when(tcp_sk(sk))); 572 inet_csk_reset_keepalive_timer(sk, keepalive_time_when(tcp_sk(sk)));
564 else if (!val) 573 else if (!val)
565 tcp_delete_keepalive_timer(sk); 574 inet_csk_delete_keepalive_timer(sk);
566} 575}
567 576
568 577
@@ -576,7 +585,7 @@ static void tcp_keepalive_timer (unsigned long data)
576 bh_lock_sock(sk); 585 bh_lock_sock(sk);
577 if (sock_owned_by_user(sk)) { 586 if (sock_owned_by_user(sk)) {
578 /* Try again later. */ 587 /* Try again later. */
579 tcp_reset_keepalive_timer (sk, HZ/20); 588 inet_csk_reset_keepalive_timer (sk, HZ/20);
580 goto out; 589 goto out;
581 } 590 }
582 591
@@ -587,7 +596,7 @@ static void tcp_keepalive_timer (unsigned long data)
587 596
588 if (sk->sk_state == TCP_FIN_WAIT2 && sock_flag(sk, SOCK_DEAD)) { 597 if (sk->sk_state == TCP_FIN_WAIT2 && sock_flag(sk, SOCK_DEAD)) {
589 if (tp->linger2 >= 0) { 598 if (tp->linger2 >= 0) {
590 int tmo = tcp_fin_time(tp) - TCP_TIMEWAIT_LEN; 599 const int tmo = tcp_fin_time(sk) - TCP_TIMEWAIT_LEN;
591 600
592 if (tmo > 0) { 601 if (tmo > 0) {
593 tcp_time_wait(sk, TCP_FIN_WAIT2, tmo); 602 tcp_time_wait(sk, TCP_FIN_WAIT2, tmo);
@@ -634,7 +643,7 @@ static void tcp_keepalive_timer (unsigned long data)
634 sk_stream_mem_reclaim(sk); 643 sk_stream_mem_reclaim(sk);
635 644
636resched: 645resched:
637 tcp_reset_keepalive_timer (sk, elapsed); 646 inet_csk_reset_keepalive_timer (sk, elapsed);
638 goto out; 647 goto out;
639 648
640death: 649death:
@@ -645,7 +654,7 @@ out:
645 sock_put(sk); 654 sock_put(sk);
646} 655}
647 656
648EXPORT_SYMBOL(tcp_clear_xmit_timers); 657EXPORT_SYMBOL(inet_csk_clear_xmit_timers);
649EXPORT_SYMBOL(tcp_delete_keepalive_timer); 658EXPORT_SYMBOL(inet_csk_delete_keepalive_timer);
650EXPORT_SYMBOL(tcp_init_xmit_timers); 659EXPORT_SYMBOL(tcp_init_xmit_timers);
651EXPORT_SYMBOL(tcp_reset_keepalive_timer); 660EXPORT_SYMBOL(inet_csk_reset_keepalive_timer);
generated by cgit v1.2.2 (git 2.25.0) at 2024-11-20 09:18:28 -0500