[NET] Rename open_request to request_sock

Ok, this one just renames some stuff to have a better namespace and to
dissassociate it from TCP:

struct open_request  -> struct request_sock
tcp_openreq_alloc    -> reqsk_alloc
tcp_openreq_free     -> reqsk_free
tcp_openreq_fastfree -> __reqsk_free

With this most of the infrastructure closely resembles a struct
sock methods subset.

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

diff --git a/include/linux/ip.h b/include/linux/ip.h
index d5b7c907204efa2d004d2b7bd5f8521646d36157..31e7cedd9f844b3e6d28dffe271da3b724e0f644 100644 (file)
--- a/include/linux/ip.h
+++ b/include/linux/ip.h
@@ -109,7 +109,7 @@ struct ip_options {
 #define optlength(opt) (sizeof(struct ip_options) + opt->optlen)
 
 struct inet_request_sock {
-       struct open_request     req;
+       struct request_sock     req;
        u32                     loc_addr;
        u32                     rmt_addr;
        u16                     rmt_port;
@@ -123,7 +123,7 @@ struct inet_request_sock {
        struct ip_options       *opt;
 };
 
-static inline struct inet_request_sock *inet_rsk(const struct open_request *sk)
+static inline struct inet_request_sock *inet_rsk(const struct request_sock *sk)
 {
        return (struct inet_request_sock *)sk;
 }

diff --git a/include/linux/ipv6.h b/include/linux/ipv6.h
index 98acdbf3d446341b2c0b033d0e30bf48c8f26fad..6fcd6a0ade24860807917b746abc5179c6338f6a 100644 (file)
--- a/include/linux/ipv6.h
+++ b/include/linux/ipv6.h
@@ -201,7 +201,7 @@ struct tcp6_request_sock {
        int                     iif;
 };
 
-static inline struct tcp6_request_sock *tcp6_rsk(const struct open_request *sk)
+static inline struct tcp6_request_sock *tcp6_rsk(const struct request_sock *sk)
 {
        return (struct tcp6_request_sock *)sk;
 }

diff --git a/include/linux/tcp.h b/include/linux/tcp.h
index 86771b37b80db03cab1c2c25e700790aeaa431b0..fb54292a15aab646d357c9f9dfd2e2131d753daf 100644 (file)
--- a/include/linux/tcp.h
+++ b/include/linux/tcp.h
@@ -236,7 +236,7 @@ struct tcp_request_sock {
        __u32                    snt_isn;
 };
 
-static inline struct tcp_request_sock *tcp_rsk(const struct open_request *req)
+static inline struct tcp_request_sock *tcp_rsk(const struct request_sock *req)
 {
        return (struct tcp_request_sock *)req;
 }
@@ -393,8 +393,8 @@ struct tcp_sock {
        struct tcp_listen_opt   *listen_opt;
 
        /* FIFO of established children */
-       struct open_request     *accept_queue;
-       struct open_request     *accept_queue_tail;
+       struct request_sock     *accept_queue;
+       struct request_sock     *accept_queue_tail;
 
        unsigned int            keepalive_time;   /* time before keep alive takes place */
        unsigned int            keepalive_intvl;  /* time interval between keep alive probes */

diff --git a/include/net/request_sock.h b/include/net/request_sock.h
index 9502f5587931d1a6427c8e7cee3ec4d392b29054..08a8fd1d1610ac0e95e7025023cbd0fad819d272 100644 (file)
--- a/include/net/request_sock.h
+++ b/include/net/request_sock.h
@@ -19,28 +19,28 @@
 #include <linux/types.h>
 #include <net/sock.h>
 
-struct open_request;
+struct request_sock;
 struct sk_buff;
 struct dst_entry;
 struct proto;
 
-struct or_calltable {
+struct request_sock_ops {
        int             family;
        kmem_cache_t    *slab;
        int             obj_size;
        int             (*rtx_syn_ack)(struct sock *sk,
-                                      struct open_request *req,
+                                      struct request_sock *req,
                                       struct dst_entry *dst);
        void            (*send_ack)(struct sk_buff *skb,
-                                   struct open_request *req);
+                                   struct request_sock *req);
        void            (*send_reset)(struct sk_buff *skb);
-       void            (*destructor)(struct open_request *req);
+       void            (*destructor)(struct request_sock *req);
 };
 
-/* struct open_request - mini sock to represent a connection request
+/* struct request_sock - mini sock to represent a connection request
  */
-struct open_request {
-       struct open_request             *dl_next; /* Must be first member! */
+struct request_sock {
+       struct request_sock             *dl_next; /* Must be first member! */
        u16                             mss;
        u8                              retrans;
        u8                              __pad;
@@ -49,29 +49,29 @@ struct open_request {
        u32                             rcv_wnd;          /* rcv_wnd offered first time */
        u32                             ts_recent;
        unsigned long                   expires;
-       struct or_calltable             *class;
+       struct request_sock_ops         *rsk_ops;
        struct sock                     *sk;
 };
 
-static inline struct open_request *tcp_openreq_alloc(struct or_calltable *class)
+static inline struct request_sock *reqsk_alloc(struct request_sock_ops *ops)
 {
-       struct open_request *req = kmem_cache_alloc(class->slab, SLAB_ATOMIC);
+       struct request_sock *req = kmem_cache_alloc(ops->slab, SLAB_ATOMIC);
 
        if (req != NULL)
-               req->class = class;
+               req->rsk_ops = ops;
 
        return req;
 }
 
-static inline void tcp_openreq_fastfree(struct open_request *req)
+static inline void __reqsk_free(struct request_sock *req)
 {
-       kmem_cache_free(req->class->slab, req);
+       kmem_cache_free(req->rsk_ops->slab, req);
 }
 
-static inline void tcp_openreq_free(struct open_request *req)
+static inline void reqsk_free(struct request_sock *req)
 {
-       req->class->destructor(req);
-       tcp_openreq_fastfree(req);
+       req->rsk_ops->destructor(req);
+       __reqsk_free(req);
 }
 
 #endif /* _REQUEST_SOCK_H */

diff --git a/include/net/sock.h b/include/net/sock.h
index 6919276af8af13234ccaaaeaf036eff6b41ebaa0..e593af5b1ecce5db772ae22a17521be6833dd699 100644 (file)
--- a/include/net/sock.h
+++ b/include/net/sock.h
@@ -484,7 +484,7 @@ extern void sk_stream_kill_queues(struct sock *sk);
 
 extern int sk_wait_data(struct sock *sk, long *timeo);
 
-struct or_calltable;
+struct request_sock_ops;
 
 /* Networking protocol blocks we attach to sockets.
  * socket layer -> transport layer interface
@@ -549,7 +549,7 @@ struct proto {
        kmem_cache_t            *slab;
        unsigned int            obj_size;
 
-       struct or_calltable     *rsk_prot;
+       struct request_sock_ops *rsk_prot;
 
        struct module           *owner;
 

diff --git a/include/net/tcp.h b/include/net/tcp.h
index d438ba566b8925a0309496201d20debc4545becc..6663086a5e357ca60029b70d979cec19fe277e8f 100644 (file)
--- a/include/net/tcp.h
+++ b/include/net/tcp.h
@@ -641,7 +641,7 @@ struct tcp_func {
 
        struct sock *           (*syn_recv_sock)        (struct sock *sk,
                                                         struct sk_buff *skb,
-                                                        struct open_request *req,
+                                                        struct request_sock *req,
                                                         struct dst_entry *dst);
     
        int                     (*remember_stamp)       (struct sock *sk);
@@ -785,8 +785,8 @@ extern enum tcp_tw_status   tcp_timewait_state_process(struct tcp_tw_bucket *tw,
                                                           unsigned len);
 
 extern struct sock *           tcp_check_req(struct sock *sk,struct sk_buff *skb,
-                                             struct open_request *req,
-                                             struct open_request **prev);
+                                             struct request_sock *req,
+                                             struct request_sock **prev);
 extern int                     tcp_child_process(struct sock *parent,
                                                  struct sock *child,
                                                  struct sk_buff *skb);
@@ -836,12 +836,12 @@ extern int                        tcp_v4_conn_request(struct sock *sk,
                                                    struct sk_buff *skb);
 
 extern struct sock *           tcp_create_openreq_child(struct sock *sk,
-                                                        struct open_request *req,
+                                                        struct request_sock *req,
                                                         struct sk_buff *skb);
 
 extern struct sock *           tcp_v4_syn_recv_sock(struct sock *sk,
                                                     struct sk_buff *skb,
-                                                    struct open_request *req,
+                                                    struct request_sock *req,
                                                        struct dst_entry *dst);
 
 extern int                     tcp_v4_do_rcv(struct sock *sk,
@@ -855,7 +855,7 @@ extern int                  tcp_connect(struct sock *sk);
 
 extern struct sk_buff *                tcp_make_synack(struct sock *sk,
                                                struct dst_entry *dst,
-                                               struct open_request *req);
+                                               struct request_sock *req);
 
 extern int                     tcp_disconnect(struct sock *sk, int flags);
 
@@ -1683,7 +1683,7 @@ static inline int tcp_full_space(const struct sock *sk)
        return tcp_win_from_space(sk->sk_rcvbuf); 
 }
 
-static inline void tcp_acceptq_queue(struct sock *sk, struct open_request *req,
+static inline void tcp_acceptq_queue(struct sock *sk, struct request_sock *req,
                                         struct sock *child)
 {
        struct tcp_sock *tp = tcp_sk(sk);
@@ -1707,11 +1707,11 @@ struct tcp_listen_opt
        int                     qlen_young;
        int                     clock_hand;
        u32                     hash_rnd;
-       struct open_request     *syn_table[TCP_SYNQ_HSIZE];
+       struct request_sock     *syn_table[TCP_SYNQ_HSIZE];
 };
 
 static inline void
-tcp_synq_removed(struct sock *sk, struct open_request *req)
+tcp_synq_removed(struct sock *sk, struct request_sock *req)
 {
        struct tcp_listen_opt *lopt = tcp_sk(sk)->listen_opt;
 
@@ -1745,23 +1745,23 @@ static inline int tcp_synq_is_full(struct sock *sk)
        return tcp_synq_len(sk) >> tcp_sk(sk)->listen_opt->max_qlen_log;
 }
 
-static inline void tcp_synq_unlink(struct tcp_sock *tp, struct open_request *req,
-                                      struct open_request **prev)
+static inline void tcp_synq_unlink(struct tcp_sock *tp, struct request_sock *req,
+                                      struct request_sock **prev)
 {
        write_lock(&tp->syn_wait_lock);
        *prev = req->dl_next;
        write_unlock(&tp->syn_wait_lock);
 }
 
-static inline void tcp_synq_drop(struct sock *sk, struct open_request *req,
-                                    struct open_request **prev)
+static inline void tcp_synq_drop(struct sock *sk, struct request_sock *req,
+                                    struct request_sock **prev)
 {
        tcp_synq_unlink(tcp_sk(sk), req, prev);
        tcp_synq_removed(sk, req);
-       tcp_openreq_free(req);
+       reqsk_free(req);
 }
 
-static __inline__ void tcp_openreq_init(struct open_request *req,
+static __inline__ void tcp_openreq_init(struct request_sock *req,
                                        struct tcp_options_received *rx_opt,
                                        struct sk_buff *skb)
 {

diff --git a/include/net/tcp_ecn.h b/include/net/tcp_ecn.h
index 94ad970e844af333c82d2d39557a361c9b87fcf8..64980ee8c92a9ee77d6c57b1806f7acd290883cf 100644 (file)
--- a/include/net/tcp_ecn.h
+++ b/include/net/tcp_ecn.h
@@ -39,7 +39,7 @@ static inline void TCP_ECN_send_syn(struct sock *sk, struct tcp_sock *tp,
 }
 
 static __inline__ void
-TCP_ECN_make_synack(struct open_request *req, struct tcphdr *th)
+TCP_ECN_make_synack(struct request_sock *req, struct tcphdr *th)
 {
        if (inet_rsk(req)->ecn_ok)
                th->ece = 1;
@@ -112,13 +112,13 @@ static inline int TCP_ECN_rcv_ecn_echo(struct tcp_sock *tp, struct tcphdr *th)
 }
 
 static inline void TCP_ECN_openreq_child(struct tcp_sock *tp,
-                                        struct open_request *req)
+                                        struct request_sock *req)
 {
        tp->ecn_flags = inet_rsk(req)->ecn_ok ? TCP_ECN_OK : 0;
 }
 
 static __inline__ void
-TCP_ECN_create_request(struct open_request *req, struct tcphdr *th)
+TCP_ECN_create_request(struct request_sock *req, struct tcphdr *th)
 {
        if (sysctl_tcp_ecn && th->ece && th->cwr)
                inet_rsk(req)->ecn_ok = 1;

diff --git a/net/ipv4/syncookies.c b/net/ipv4/syncookies.c
index dd47e6da6fb33e73b3e40917a6183f6ad79fe8d1..72d014442185fcb1d29ee855b17da26a5bb82988 100644 (file)
--- a/net/ipv4/syncookies.c
+++ b/net/ipv4/syncookies.c
@@ -169,10 +169,10 @@ static inline int cookie_check(struct sk_buff *skb, __u32 cookie)
        return mssind < NUM_MSS ? msstab[mssind] + 1 : 0;
 }
 
-extern struct or_calltable or_ipv4;
+extern struct request_sock_ops tcp_request_sock_ops;
 
 static inline struct sock *get_cookie_sock(struct sock *sk, struct sk_buff *skb,
-                                          struct open_request *req,
+                                          struct request_sock *req,
                                           struct dst_entry *dst)
 {
        struct tcp_sock *tp = tcp_sk(sk);
@@ -182,7 +182,7 @@ static inline struct sock *get_cookie_sock(struct sock *sk, struct sk_buff *skb,
        if (child)
                tcp_acceptq_queue(sk, req, child);
        else
-               tcp_openreq_free(req);
+               reqsk_free(req);
 
        return child;
 }
@@ -195,7 +195,7 @@ struct sock *cookie_v4_check(struct sock *sk, struct sk_buff *skb,
        struct tcp_sock *tp = tcp_sk(sk);
        __u32 cookie = ntohl(skb->h.th->ack_seq) - 1; 
        struct sock *ret = sk;
-       struct open_request *req; 
+       struct request_sock *req; 
        int mss; 
        struct rtable *rt; 
        __u8 rcv_wscale;
@@ -212,7 +212,7 @@ struct sock *cookie_v4_check(struct sock *sk, struct sk_buff *skb,
        NET_INC_STATS_BH(LINUX_MIB_SYNCOOKIESRECV);
 
        ret = NULL;
-       req = tcp_openreq_alloc(&or_ipv4); /* for safety */
+       req = reqsk_alloc(&tcp_request_sock_ops); /* for safety */
        if (!req)
                goto out;
 
@@ -262,7 +262,7 @@ struct sock *cookie_v4_check(struct sock *sk, struct sk_buff *skb,
                                               { .sport = skb->h.th->dest,
                                                 .dport = skb->h.th->source } } };
                if (ip_route_output_key(&rt, &fl)) {
-                       tcp_openreq_free(req);
+                       reqsk_free(req);
                        goto out; 
                }
        }

diff --git a/net/ipv4/tcp.c b/net/ipv4/tcp.c
index a3cabfa2022ae4afe5f7739b9b85e6b82c1a2bee..1c29feb6b35fb4d8d7de4a048a98c78995e158d9 100644 (file)
--- a/net/ipv4/tcp.c
+++ b/net/ipv4/tcp.c
@@ -516,8 +516,8 @@ static void tcp_listen_stop (struct sock *sk)
 {
        struct tcp_sock *tp = tcp_sk(sk);
        struct tcp_listen_opt *lopt = tp->listen_opt;
-       struct open_request *acc_req = tp->accept_queue;
-       struct open_request *req;
+       struct request_sock *acc_req = tp->accept_queue;
+       struct request_sock *req;
        int i;
 
        tcp_delete_keepalive_timer(sk);
@@ -533,7 +533,7 @@ static void tcp_listen_stop (struct sock *sk)
                        while ((req = lopt->syn_table[i]) != NULL) {
                                lopt->syn_table[i] = req->dl_next;
                                lopt->qlen--;
-                               tcp_openreq_free(req);
+                               reqsk_free(req);
 
                /* Following specs, it would be better either to send FIN
                 * (and enter FIN-WAIT-1, it is normal close)
@@ -573,7 +573,7 @@ static void tcp_listen_stop (struct sock *sk)
                sock_put(child);
 
                sk_acceptq_removed(sk);
-               tcp_openreq_fastfree(req);
+               __reqsk_free(req);
        }
        BUG_TRAP(!sk->sk_ack_backlog);
 }
@@ -1894,7 +1894,7 @@ static int wait_for_connect(struct sock *sk, long timeo)
 struct sock *tcp_accept(struct sock *sk, int flags, int *err)
 {
        struct tcp_sock *tp = tcp_sk(sk);
-       struct open_request *req;
+       struct request_sock *req;
        struct sock *newsk;
        int error;
 
@@ -1927,7 +1927,7 @@ struct sock *tcp_accept(struct sock *sk, int flags, int *err)
 
        newsk = req->sk;
        sk_acceptq_removed(sk);
-       tcp_openreq_fastfree(req);
+       __reqsk_free(req);
        BUG_TRAP(newsk->sk_state != TCP_SYN_RECV);
        release_sock(sk);
        return newsk;

diff --git a/net/ipv4/tcp_diag.c b/net/ipv4/tcp_diag.c
index 700ff2413588d41c71836026ae3298b06cb36d73..67277800d0c13538fe0695952ce6cc375d54966c 100644 (file)
--- a/net/ipv4/tcp_diag.c
+++ b/net/ipv4/tcp_diag.c
@@ -455,7 +455,7 @@ static int tcpdiag_dump_sock(struct sk_buff *skb, struct sock *sk,
 }
 
 static int tcpdiag_fill_req(struct sk_buff *skb, struct sock *sk,
-                           struct open_request *req,
+                           struct request_sock *req,
                            u32 pid, u32 seq)
 {
        const struct inet_request_sock *ireq = inet_rsk(req);
@@ -542,7 +542,7 @@ static int tcpdiag_dump_reqs(struct sk_buff *skb, struct sock *sk,
        }
 
        for (j = s_j; j < TCP_SYNQ_HSIZE; j++) {
-               struct open_request *req, *head = lopt->syn_table[j];
+               struct request_sock *req, *head = lopt->syn_table[j];
 
                reqnum = 0;
                for (req = head; req; reqnum++, req = req->dl_next) {

diff --git a/net/ipv4/tcp_ipv4.c b/net/ipv4/tcp_ipv4.c
index e156be90df14494f61c83076bcf8842b885c4ec2..95528a75a63d8f9c85f012aba8b747ebff70ee5e 100644 (file)
--- a/net/ipv4/tcp_ipv4.c
+++ b/net/ipv4/tcp_ipv4.c
@@ -36,7 +36,7 @@
  *                                     ACK bit.
  *             Andi Kleen :            Implemented fast path mtu discovery.
  *                                     Fixed many serious bugs in the
- *                                     open_request handling and moved
+ *                                     request_sock handling and moved
  *                                     most of it into the af independent code.
  *                                     Added tail drop and some other bugfixes.
  *                                     Added new listen sematics.
@@ -869,13 +869,13 @@ static __inline__ u32 tcp_v4_synq_hash(u32 raddr, u16 rport, u32 rnd)
        return (jhash_2words(raddr, (u32) rport, rnd) & (TCP_SYNQ_HSIZE - 1));
 }
 
-static struct open_request *tcp_v4_search_req(struct tcp_sock *tp,
-                                             struct open_request ***prevp,
+static struct request_sock *tcp_v4_search_req(struct tcp_sock *tp,
+                                             struct request_sock ***prevp,
                                              __u16 rport,
                                              __u32 raddr, __u32 laddr)
 {
        struct tcp_listen_opt *lopt = tp->listen_opt;
-       struct open_request *req, **prev;
+       struct request_sock *req, **prev;
 
        for (prev = &lopt->syn_table[tcp_v4_synq_hash(raddr, rport, lopt->hash_rnd)];
             (req = *prev) != NULL;
@@ -885,7 +885,7 @@ static struct open_request *tcp_v4_search_req(struct tcp_sock *tp,
                if (ireq->rmt_port == rport &&
                    ireq->rmt_addr == raddr &&
                    ireq->loc_addr == laddr &&
-                   TCP_INET_FAMILY(req->class->family)) {
+                   TCP_INET_FAMILY(req->rsk_ops->family)) {
                        BUG_TRAP(!req->sk);
                        *prevp = prev;
                        break;
@@ -895,7 +895,7 @@ static struct open_request *tcp_v4_search_req(struct tcp_sock *tp,
        return req;
 }
 
-static void tcp_v4_synq_add(struct sock *sk, struct open_request *req)
+static void tcp_v4_synq_add(struct sock *sk, struct request_sock *req)
 {
        struct tcp_sock *tp = tcp_sk(sk);
        struct tcp_listen_opt *lopt = tp->listen_opt;
@@ -1052,7 +1052,7 @@ void tcp_v4_err(struct sk_buff *skb, u32 info)
        }
 
        switch (sk->sk_state) {
-               struct open_request *req, **prev;
+               struct request_sock *req, **prev;
        case TCP_LISTEN:
                if (sock_owned_by_user(sk))
                        goto out;
@@ -1256,14 +1256,14 @@ static void tcp_v4_timewait_ack(struct sock *sk, struct sk_buff *skb)
        tcp_tw_put(tw);
 }
 
-static void tcp_v4_or_send_ack(struct sk_buff *skb, struct open_request *req)
+static void tcp_v4_reqsk_send_ack(struct sk_buff *skb, struct request_sock *req)
 {
        tcp_v4_send_ack(skb, tcp_rsk(req)->snt_isn + 1, tcp_rsk(req)->rcv_isn + 1, req->rcv_wnd,
                        req->ts_recent);
 }
 
 static struct dst_entry* tcp_v4_route_req(struct sock *sk,
-                                         struct open_request *req)
+                                         struct request_sock *req)
 {
        struct rtable *rt;
        const struct inet_request_sock *ireq = inet_rsk(req);
@@ -1294,10 +1294,10 @@ static struct dst_entry* tcp_v4_route_req(struct sock *sk,
 
 /*
  *     Send a SYN-ACK after having received an ACK.
- *     This still operates on a open_request only, not on a big
+ *     This still operates on a request_sock only, not on a big
  *     socket.
  */
-static int tcp_v4_send_synack(struct sock *sk, struct open_request *req,
+static int tcp_v4_send_synack(struct sock *sk, struct request_sock *req,
                              struct dst_entry *dst)
 {
        const struct inet_request_sock *ireq = inet_rsk(req);
@@ -1332,9 +1332,9 @@ out:
 }
 
 /*
- *     IPv4 open_request destructor.
+ *     IPv4 request_sock destructor.
  */
-static void tcp_v4_or_free(struct open_request *req)
+static void tcp_v4_reqsk_destructor(struct request_sock *req)
 {
        if (inet_rsk(req)->opt)
                kfree(inet_rsk(req)->opt);
@@ -1353,7 +1353,7 @@ static inline void syn_flood_warning(struct sk_buff *skb)
 }
 
 /*
- * Save and compile IPv4 options into the open_request if needed.
+ * Save and compile IPv4 options into the request_sock if needed.
  */
 static inline struct ip_options *tcp_v4_save_options(struct sock *sk,
                                                     struct sk_buff *skb)
@@ -1389,12 +1389,12 @@ static inline struct ip_options *tcp_v4_save_options(struct sock *sk,
  */
 int sysctl_max_syn_backlog = 256;
 
-struct or_calltable or_ipv4 = {
+struct request_sock_ops tcp_request_sock_ops = {
        .family         =       PF_INET,
        .obj_size       =       sizeof(struct tcp_request_sock),
        .rtx_syn_ack    =       tcp_v4_send_synack,
-       .send_ack       =       tcp_v4_or_send_ack,
-       .destructor     =       tcp_v4_or_free,
+       .send_ack       =       tcp_v4_reqsk_send_ack,
+       .destructor     =       tcp_v4_reqsk_destructor,
        .send_reset     =       tcp_v4_send_reset,
 };
 
@@ -1402,7 +1402,7 @@ int tcp_v4_conn_request(struct sock *sk, struct sk_buff *skb)
 {
        struct inet_request_sock *ireq;
        struct tcp_options_received tmp_opt;
-       struct open_request *req;
+       struct request_sock *req;
        __u32 saddr = skb->nh.iph->saddr;
        __u32 daddr = skb->nh.iph->daddr;
        __u32 isn = TCP_SKB_CB(skb)->when;
@@ -1439,7 +1439,7 @@ int tcp_v4_conn_request(struct sock *sk, struct sk_buff *skb)
        if (sk_acceptq_is_full(sk) && tcp_synq_young(sk) > 1)
                goto drop;
 
-       req = tcp_openreq_alloc(&or_ipv4);
+       req = reqsk_alloc(&tcp_request_sock_ops);
        if (!req)
                goto drop;
 
@@ -1535,14 +1535,14 @@ int tcp_v4_conn_request(struct sock *sk, struct sk_buff *skb)
                goto drop_and_free;
 
        if (want_cookie) {
-               tcp_openreq_free(req);
+               reqsk_free(req);
        } else {
                tcp_v4_synq_add(sk, req);
        }
        return 0;
 
 drop_and_free:
-       tcp_openreq_free(req);
+       reqsk_free(req);
 drop:
        TCP_INC_STATS_BH(TCP_MIB_ATTEMPTFAILS);
        return 0;
@@ -1554,7 +1554,7 @@ drop:
  * now create the new socket.
  */
 struct sock *tcp_v4_syn_recv_sock(struct sock *sk, struct sk_buff *skb,
-                                 struct open_request *req,
+                                 struct request_sock *req,
                                  struct dst_entry *dst)
 {
        struct inet_request_sock *ireq;
@@ -1613,9 +1613,9 @@ static struct sock *tcp_v4_hnd_req(struct sock *sk, struct sk_buff *skb)
        struct iphdr *iph = skb->nh.iph;
        struct tcp_sock *tp = tcp_sk(sk);
        struct sock *nsk;
-       struct open_request **prev;
+       struct request_sock **prev;
        /* Find possible connection requests. */
-       struct open_request *req = tcp_v4_search_req(tp, &prev, th->source,
+       struct request_sock *req = tcp_v4_search_req(tp, &prev, th->source,
                                                     iph->saddr, iph->daddr);
        if (req)
                return tcp_check_req(sk, skb, req, prev);
@@ -2152,13 +2152,13 @@ static void *listening_get_next(struct seq_file *seq, void *cur)
        ++st->num;
 
        if (st->state == TCP_SEQ_STATE_OPENREQ) {
-               struct open_request *req = cur;
+               struct request_sock *req = cur;
 
                tp = tcp_sk(st->syn_wait_sk);
                req = req->dl_next;
                while (1) {
                        while (req) {
-                               if (req->class->family == st->family) {
+                               if (req->rsk_ops->family == st->family) {
                                        cur = req;
                                        goto out;
                                }
@@ -2459,7 +2459,7 @@ void tcp_proc_unregister(struct tcp_seq_afinfo *afinfo)
        memset(afinfo->seq_fops, 0, sizeof(*afinfo->seq_fops)); 
 }
 
-static void get_openreq4(struct sock *sk, struct open_request *req,
+static void get_openreq4(struct sock *sk, struct request_sock *req,
                         char *tmpbuf, int i, int uid)
 {
        const struct inet_request_sock *ireq = inet_rsk(req);
@@ -2627,7 +2627,7 @@ struct proto tcp_prot = {
        .sysctl_rmem            = sysctl_tcp_rmem,
        .max_header             = MAX_TCP_HEADER,
        .obj_size               = sizeof(struct tcp_sock),
-       .rsk_prot               = &or_ipv4,
+       .rsk_prot               = &tcp_request_sock_ops,
 };
 
 

diff --git a/net/ipv4/tcp_minisocks.c b/net/ipv4/tcp_minisocks.c
index 1037401c7cc8df7a12c76772399cda99d9d184c0..0e6d525a83410d899ee6b5f373b5d68a2e5f4703 100644 (file)
--- a/net/ipv4/tcp_minisocks.c
+++ b/net/ipv4/tcp_minisocks.c
@@ -684,7 +684,7 @@ out:
  * Actually, we could lots of memory writes here. tp of listening
  * socket contains all necessary default parameters.
  */
-struct sock *tcp_create_openreq_child(struct sock *sk, struct open_request *req, struct sk_buff *skb)
+struct sock *tcp_create_openreq_child(struct sock *sk, struct request_sock *req, struct sk_buff *skb)
 {
        /* allocate the newsk from the same slab of the master sock,
         * if not, at sk_free time we'll try to free it from the wrong
@@ -853,12 +853,12 @@ struct sock *tcp_create_openreq_child(struct sock *sk, struct open_request *req,
 
 /* 
  *     Process an incoming packet for SYN_RECV sockets represented
- *     as an open_request.
+ *     as a request_sock.
  */
 
 struct sock *tcp_check_req(struct sock *sk,struct sk_buff *skb,
-                          struct open_request *req,
-                          struct open_request **prev)
+                          struct request_sock *req,
+                          struct request_sock **prev)
 {
        struct tcphdr *th = skb->h.th;
        struct tcp_sock *tp = tcp_sk(sk);
@@ -903,7 +903,7 @@ struct sock *tcp_check_req(struct sock *sk,struct sk_buff *skb,
                 * Enforce "SYN-ACK" according to figure 8, figure 6
                 * of RFC793, fixed by RFC1122.
                 */
-               req->class->rtx_syn_ack(sk, req, NULL);
+               req->rsk_ops->rtx_syn_ack(sk, req, NULL);
                return NULL;
        }
 
@@ -975,7 +975,7 @@ struct sock *tcp_check_req(struct sock *sk,struct sk_buff *skb,
                                          tcp_rsk(req)->rcv_isn + 1, tcp_rsk(req)->rcv_isn + 1 + req->rcv_wnd)) {
                /* Out of window: send ACK and drop. */
                if (!(flg & TCP_FLAG_RST))
-                       req->class->send_ack(skb, req);
+                       req->rsk_ops->send_ack(skb, req);
                if (paws_reject)
                        NET_INC_STATS_BH(LINUX_MIB_PAWSESTABREJECTED);
                return NULL;
@@ -1035,7 +1035,7 @@ struct sock *tcp_check_req(struct sock *sk,struct sk_buff *skb,
        embryonic_reset:
                NET_INC_STATS_BH(LINUX_MIB_EMBRYONICRSTS);
                if (!(flg & TCP_FLAG_RST))
-                       req->class->send_reset(skb);
+                       req->rsk_ops->send_reset(skb);
 
                tcp_synq_drop(sk, req, prev);
                return NULL;

diff --git a/net/ipv4/tcp_output.c b/net/ipv4/tcp_output.c
index f3c8747caf91ca9749cd5babab4ec61814d641f0..f17c6577e337f9383ebf2cecee99858167dbf7d7 100644 (file)
--- a/net/ipv4/tcp_output.c
+++ b/net/ipv4/tcp_output.c
@@ -1356,7 +1356,7 @@ int tcp_send_synack(struct sock *sk)
  * Prepare a SYN-ACK.
  */
 struct sk_buff * tcp_make_synack(struct sock *sk, struct dst_entry *dst,
-                                struct open_request *req)
+                                struct request_sock *req)
 {
        struct inet_request_sock *ireq = inet_rsk(req);
        struct tcp_sock *tp = tcp_sk(sk);

diff --git a/net/ipv4/tcp_timer.c b/net/ipv4/tcp_timer.c
index ba30ca0aa6a34399ce0cea32a29fd5ad48295a80..f03efe5fb76a5246e338a964f382ea35dd826605 100644 (file)
--- a/net/ipv4/tcp_timer.c
+++ b/net/ipv4/tcp_timer.c
@@ -468,7 +468,7 @@ static void tcp_synack_timer(struct sock *sk)
        int max_retries = tp->syn_retries ? : sysctl_tcp_synack_retries;
        int thresh = max_retries;
        unsigned long now = jiffies;
-       struct open_request **reqp, *req;
+       struct request_sock **reqp, *req;
        int i, budget;
 
        if (lopt == NULL || lopt->qlen == 0)
@@ -514,7 +514,7 @@ static void tcp_synack_timer(struct sock *sk)
                        if (time_after_eq(now, req->expires)) {
                                if ((req->retrans < thresh ||
                                     (inet_rsk(req)->acked && req->retrans < max_retries))
-                                   && !req->class->rtx_syn_ack(sk, req, NULL)) {
+                                   && !req->rsk_ops->rtx_syn_ack(sk, req, NULL)) {
                                        unsigned long timeo;
 
                                        if (req->retrans++ == 0)
@@ -533,7 +533,7 @@ static void tcp_synack_timer(struct sock *sk)
                                lopt->qlen--;
                                if (req->retrans == 0)
                                        lopt->qlen_young--;
-                               tcp_openreq_free(req);
+                               reqsk_free(req);
                                continue;
                        }
                        reqp = &req->dl_next;

diff --git a/net/ipv6/tcp_ipv6.c b/net/ipv6/tcp_ipv6.c
index 9199ad2fde0d6d2af9c4d634aa790f83f2499e64..068cd4a8c29280161f3fce02e6de486e95c10424 100644 (file)
--- a/net/ipv6/tcp_ipv6.c
+++ b/net/ipv6/tcp_ipv6.c
@@ -65,7 +65,7 @@
 #include <linux/seq_file.h>
 
 static void    tcp_v6_send_reset(struct sk_buff *skb);
-static void    tcp_v6_or_send_ack(struct sk_buff *skb, struct open_request *req);
+static void    tcp_v6_reqsk_send_ack(struct sk_buff *skb, struct request_sock *req);
 static void    tcp_v6_send_check(struct sock *sk, struct tcphdr *th, int len, 
                                  struct sk_buff *skb);
 
@@ -394,15 +394,15 @@ static u32 tcp_v6_synq_hash(struct in6_addr *raddr, u16 rport, u32 rnd)
        return c & (TCP_SYNQ_HSIZE - 1);
 }
 
-static struct open_request *tcp_v6_search_req(struct tcp_sock *tp,
-                                             struct open_request ***prevp,
+static struct request_sock *tcp_v6_search_req(struct tcp_sock *tp,
+                                             struct request_sock ***prevp,
                                              __u16 rport,
                                              struct in6_addr *raddr,
                                              struct in6_addr *laddr,
                                              int iif)
 {
        struct tcp_listen_opt *lopt = tp->listen_opt;
-       struct open_request *req, **prev;  
+       struct request_sock *req, **prev;  
 
        for (prev = &lopt->syn_table[tcp_v6_synq_hash(raddr, rport, lopt->hash_rnd)];
             (req = *prev) != NULL;
@@ -410,7 +410,7 @@ static struct open_request *tcp_v6_search_req(struct tcp_sock *tp,
                const struct tcp6_request_sock *treq = tcp6_rsk(req);
 
                if (inet_rsk(req)->rmt_port == rport &&
-                   req->class->family == AF_INET6 &&
+                   req->rsk_ops->family == AF_INET6 &&
                    ipv6_addr_equal(&treq->rmt_addr, raddr) &&
                    ipv6_addr_equal(&treq->loc_addr, laddr) &&
                    (!treq->iif || treq->iif == iif)) {
@@ -908,9 +908,9 @@ static void tcp_v6_err(struct sk_buff *skb, struct inet6_skb_parm *opt,
 
        icmpv6_err_convert(type, code, &err);
 
-       /* Might be for an open_request */
+       /* Might be for an request_sock */
        switch (sk->sk_state) {
-               struct open_request *req, **prev;
+               struct request_sock *req, **prev;
        case TCP_LISTEN:
                if (sock_owned_by_user(sk))
                        goto out;
@@ -959,7 +959,7 @@ out:
 }
 
 
-static int tcp_v6_send_synack(struct sock *sk, struct open_request *req,
+static int tcp_v6_send_synack(struct sock *sk, struct request_sock *req,
                              struct dst_entry *dst)
 {
        struct tcp6_request_sock *treq = tcp6_rsk(req);
@@ -1027,18 +1027,18 @@ done:
        return err;
 }
 
-static void tcp_v6_or_free(struct open_request *req)
+static void tcp_v6_reqsk_destructor(struct request_sock *req)
 {
        if (tcp6_rsk(req)->pktopts)
                kfree_skb(tcp6_rsk(req)->pktopts);
 }
 
-static struct or_calltable or_ipv6 = {
+static struct request_sock_ops tcp6_request_sock_ops = {
        .family         =       AF_INET6,
        .obj_size       =       sizeof(struct tcp6_request_sock),
        .rtx_syn_ack    =       tcp_v6_send_synack,
-       .send_ack       =       tcp_v6_or_send_ack,
-       .destructor     =       tcp_v6_or_free,
+       .send_ack       =       tcp_v6_reqsk_send_ack,
+       .destructor     =       tcp_v6_reqsk_destructor,
        .send_reset     =       tcp_v6_send_reset
 };
 
@@ -1223,7 +1223,7 @@ static void tcp_v6_timewait_ack(struct sock *sk, struct sk_buff *skb)
        tcp_tw_put(tw);
 }
 
-static void tcp_v6_or_send_ack(struct sk_buff *skb, struct open_request *req)
+static void tcp_v6_reqsk_send_ack(struct sk_buff *skb, struct request_sock *req)
 {
        tcp_v6_send_ack(skb, tcp_rsk(req)->snt_isn + 1, tcp_rsk(req)->rcv_isn + 1, req->rcv_wnd, req->ts_recent);
 }
@@ -1231,7 +1231,7 @@ static void tcp_v6_or_send_ack(struct sk_buff *skb, struct open_request *req)
 
 static struct sock *tcp_v6_hnd_req(struct sock *sk,struct sk_buff *skb)
 {
-       struct open_request *req, **prev;
+       struct request_sock *req, **prev;
        struct tcphdr *th = skb->h.th;
        struct tcp_sock *tp = tcp_sk(sk);
        struct sock *nsk;
@@ -1264,7 +1264,7 @@ static struct sock *tcp_v6_hnd_req(struct sock *sk,struct sk_buff *skb)
        return sk;
 }
 
-static void tcp_v6_synq_add(struct sock *sk, struct open_request *req)
+static void tcp_v6_synq_add(struct sock *sk, struct request_sock *req)
 {
        struct tcp_sock *tp = tcp_sk(sk);
        struct tcp_listen_opt *lopt = tp->listen_opt;
@@ -1292,7 +1292,7 @@ static int tcp_v6_conn_request(struct sock *sk, struct sk_buff *skb)
        struct ipv6_pinfo *np = inet6_sk(sk);
        struct tcp_options_received tmp_opt;
        struct tcp_sock *tp = tcp_sk(sk);
-       struct open_request *req = NULL;
+       struct request_sock *req = NULL;
        __u32 isn = TCP_SKB_CB(skb)->when;
 
        if (skb->protocol == htons(ETH_P_IP))
@@ -1313,7 +1313,7 @@ static int tcp_v6_conn_request(struct sock *sk, struct sk_buff *skb)
        if (sk_acceptq_is_full(sk) && tcp_synq_young(sk) > 1)
                goto drop;
 
-       req = tcp_openreq_alloc(&or_ipv6);
+       req = reqsk_alloc(&tcp6_request_sock_ops);
        if (req == NULL)
                goto drop;
 
@@ -1358,14 +1358,14 @@ static int tcp_v6_conn_request(struct sock *sk, struct sk_buff *skb)
 
 drop:
        if (req)
-               tcp_openreq_free(req);
+               reqsk_free(req);
 
        TCP_INC_STATS_BH(TCP_MIB_ATTEMPTFAILS);
        return 0; /* don't send reset */
 }
 
 static struct sock * tcp_v6_syn_recv_sock(struct sock *sk, struct sk_buff *skb,
-                                         struct open_request *req,
+                                         struct request_sock *req,
                                          struct dst_entry *dst)
 {
        struct tcp6_request_sock *treq = tcp6_rsk(req);
@@ -2055,7 +2055,7 @@ static int tcp_v6_destroy_sock(struct sock *sk)
 
 /* Proc filesystem TCPv6 sock list dumping. */
 static void get_openreq6(struct seq_file *seq, 
-                        struct sock *sk, struct open_request *req, int i, int uid)
+                        struct sock *sk, struct request_sock *req, int i, int uid)
 {
        struct in6_addr *dest, *src;
        int ttd = req->expires - jiffies;
@@ -2244,7 +2244,7 @@ struct proto tcpv6_prot = {
        .sysctl_rmem            = sysctl_tcp_rmem,
        .max_header             = MAX_TCP_HEADER,
        .obj_size               = sizeof(struct tcp6_sock),
-       .rsk_prot               = &or_ipv6,
+       .rsk_prot               = &tcp6_request_sock_ops,
 };
 
 static struct inet6_protocol tcpv6_protocol = {