[DCCP] CCID: Improve CCID infrastructure
authorArnaldo Carvalho de Melo <acme@mandriva.com>
Tue, 21 Mar 2006 03:21:44 +0000 (19:21 -0800)
committerDavid S. Miller <davem@davemloft.net>
Tue, 21 Mar 2006 03:21:44 +0000 (19:21 -0800)
1. No need for ->ccid_init nor ->ccid_exit, this is what module_{init,exit}
   does and anynways neither ccid2 nor ccid3 were using it.

2. Rename struct ccid to struct ccid_operations and introduce struct ccid
   with a pointer to ccid_operations and rigth after it the rx or tx
   private state.

3. Remove the pointer to the state of the half connections from struct
   dccp_sock, now its derived thru ccid_priv() from the ccid pointer.

Now we also can implement the setsockopt for changing the CCID easily as
no ccid init routines can affect struct dccp_sock in any way that prevents
other CCIDs from working if a CCID switch operation is asked by apps.

Signed-off-by: Arnaldo Carvalho de Melo <acme@mandriva.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
include/linux/dccp.h
net/dccp/ccid.c
net/dccp/ccid.h
net/dccp/ccids/ccid2.c
net/dccp/ccids/ccid2.h
net/dccp/ccids/ccid3.c
net/dccp/ccids/ccid3.h
net/dccp/input.c
net/dccp/ipv4.c
net/dccp/minisocks.c

index a70d1a27e7fc425dbf310d03fa4de53d124ae950..bdd756cc60b1607947a6d4c7186f48f4ffdf923f 100644 (file)
@@ -478,8 +478,6 @@ struct dccp_sock {
        __u32                           dccps_mss_cache;
        struct dccp_options             dccps_options;
        struct dccp_ackvec              *dccps_hc_rx_ackvec;
-       void                            *dccps_hc_rx_ccid_private;
-       void                            *dccps_hc_tx_ccid_private;
        struct ccid                     *dccps_hc_rx_ccid;
        struct ccid                     *dccps_hc_tx_ccid;
        struct dccp_options_received    dccps_options_received;
index 06b191a5740b4713ecb4a942dbad87e4df2b5b52..ff05e59043cdb33769f810d16a8a667320d9e075 100644 (file)
@@ -13,7 +13,7 @@
 
 #include "ccid.h"
 
-static struct ccid *ccids[CCID_MAX];
+static struct ccid_operations *ccids[CCID_MAX];
 #if defined(CONFIG_SMP) || defined(CONFIG_PREEMPT)
 static atomic_t ccids_lockct = ATOMIC_INIT(0);
 static DEFINE_SPINLOCK(ccids_lock);
@@ -55,82 +55,202 @@ static inline void ccids_read_unlock(void)
 #define ccids_read_unlock() do { } while(0)
 #endif
 
-int ccid_register(struct ccid *ccid)
+static kmem_cache_t *ccid_kmem_cache_create(int obj_size, const char *fmt,...)
 {
-       int err;
+       kmem_cache_t *slab;
+       char slab_name_fmt[32], *slab_name;
+       va_list args;
+
+       va_start(args, fmt);
+       vsnprintf(slab_name_fmt, sizeof(slab_name_fmt), fmt, args);
+       va_end(args);
+
+       slab_name = kstrdup(slab_name_fmt, GFP_KERNEL);
+       if (slab_name == NULL)
+               return NULL;
+       slab = kmem_cache_create(slab_name, sizeof(struct ccid) + obj_size, 0,
+                                SLAB_HWCACHE_ALIGN, NULL, NULL);
+       if (slab == NULL)
+               kfree(slab_name);
+       return slab;
+}
+
+static void ccid_kmem_cache_destroy(kmem_cache_t *slab)
+{
+       if (slab != NULL) {
+               const char *name = kmem_cache_name(slab);
+
+               kmem_cache_destroy(slab);
+               kfree(name);
+       }
+}
+
+int ccid_register(struct ccid_operations *ccid_ops)
+{
+       int err = -ENOBUFS;
+
+       ccid_ops->ccid_hc_rx_slab =
+                       ccid_kmem_cache_create(ccid_ops->ccid_hc_rx_obj_size,
+                                              "%s_hc_rx_sock",
+                                              ccid_ops->ccid_name);
+       if (ccid_ops->ccid_hc_rx_slab == NULL)
+               goto out;
+
+       ccid_ops->ccid_hc_tx_slab =
+                       ccid_kmem_cache_create(ccid_ops->ccid_hc_tx_obj_size,
+                                              "%s_hc_tx_sock",
+                                              ccid_ops->ccid_name);
+       if (ccid_ops->ccid_hc_tx_slab == NULL)
+               goto out_free_rx_slab;
 
        ccids_write_lock();
        err = -EEXIST;
-       if (ccids[ccid->ccid_id] == NULL) {
-               ccids[ccid->ccid_id] = ccid;
+       if (ccids[ccid_ops->ccid_id] == NULL) {
+               ccids[ccid_ops->ccid_id] = ccid_ops;
                err = 0;
        }
        ccids_write_unlock();
-       if (err == 0)
-               pr_info("CCID: Registered CCID %d (%s)\n",
-                       ccid->ccid_id, ccid->ccid_name);
+       if (err != 0)
+               goto out_free_tx_slab;
+
+       pr_info("CCID: Registered CCID %d (%s)\n",
+               ccid_ops->ccid_id, ccid_ops->ccid_name);
+out:
        return err;
+out_free_tx_slab:
+       ccid_kmem_cache_destroy(ccid_ops->ccid_hc_tx_slab);
+       ccid_ops->ccid_hc_tx_slab = NULL;
+       goto out;
+out_free_rx_slab:
+       ccid_kmem_cache_destroy(ccid_ops->ccid_hc_rx_slab);
+       ccid_ops->ccid_hc_rx_slab = NULL;
+       goto out;
 }
 
 EXPORT_SYMBOL_GPL(ccid_register);
 
-int ccid_unregister(struct ccid *ccid)
+int ccid_unregister(struct ccid_operations *ccid_ops)
 {
        ccids_write_lock();
-       ccids[ccid->ccid_id] = NULL;
+       ccids[ccid_ops->ccid_id] = NULL;
        ccids_write_unlock();
+
+       ccid_kmem_cache_destroy(ccid_ops->ccid_hc_tx_slab);
+       ccid_ops->ccid_hc_tx_slab = NULL;
+       ccid_kmem_cache_destroy(ccid_ops->ccid_hc_rx_slab);
+       ccid_ops->ccid_hc_rx_slab = NULL;
+
        pr_info("CCID: Unregistered CCID %d (%s)\n",
-               ccid->ccid_id, ccid->ccid_name);
+               ccid_ops->ccid_id, ccid_ops->ccid_name);
        return 0;
 }
 
 EXPORT_SYMBOL_GPL(ccid_unregister);
 
-struct ccid *ccid_init(unsigned char id, struct sock *sk)
+struct ccid *ccid_new(unsigned char id, struct sock *sk, int rx, gfp_t gfp)
 {
-       struct ccid *ccid;
+       struct ccid_operations *ccid_ops;
+       struct ccid *ccid = NULL;
 
+       ccids_read_lock();
 #ifdef CONFIG_KMOD
-       if (ccids[id] == NULL)
+       if (ccids[id] == NULL) {
+               /* We only try to load if in process context */
+               ccids_read_unlock();
+               if (gfp & GFP_ATOMIC)
+                       goto out;
                request_module("net-dccp-ccid-%d", id);
+               ccids_read_lock();
+       }
 #endif
-       ccids_read_lock();
+       ccid_ops = ccids[id];
+       if (ccid_ops == NULL)
+               goto out_unlock;
 
-       ccid = ccids[id];
-       if (ccid == NULL)
-               goto out;
+       if (!try_module_get(ccid_ops->ccid_owner))
+               goto out_unlock;
 
-       if (!try_module_get(ccid->ccid_owner))
-               goto out_err;
+       ccids_read_unlock();
 
-       if (ccid->ccid_init != NULL && ccid->ccid_init(sk) != 0)
+       ccid = kmem_cache_alloc(rx ? ccid_ops->ccid_hc_rx_slab :
+                                    ccid_ops->ccid_hc_tx_slab, gfp);
+       if (ccid == NULL)
                goto out_module_put;
+       ccid->ccid_ops = ccid_ops;
+       if (rx) {
+               memset(ccid + 1, 0, ccid_ops->ccid_hc_rx_obj_size);
+               if (ccid->ccid_ops->ccid_hc_rx_init != NULL &&
+                   ccid->ccid_ops->ccid_hc_rx_init(ccid, sk) != 0)
+                       goto out_free_ccid;
+       } else {
+               memset(ccid + 1, 0, ccid_ops->ccid_hc_tx_obj_size);
+               if (ccid->ccid_ops->ccid_hc_tx_init != NULL &&
+                   ccid->ccid_ops->ccid_hc_tx_init(ccid, sk) != 0)
+                       goto out_free_ccid;
+       }
 out:
-       ccids_read_unlock();
        return ccid;
-out_module_put:
-       module_put(ccid->ccid_owner);
-out_err:
+out_unlock:
+       ccids_read_unlock();
+       goto out;
+out_free_ccid:
+       kmem_cache_free(rx ? ccid_ops->ccid_hc_rx_slab :
+                       ccid_ops->ccid_hc_tx_slab, ccid);
        ccid = NULL;
+out_module_put:
+       module_put(ccid_ops->ccid_owner);
        goto out;
 }
 
-EXPORT_SYMBOL_GPL(ccid_init);
+EXPORT_SYMBOL_GPL(ccid_new);
 
-void ccid_exit(struct ccid *ccid, struct sock *sk)
+struct ccid *ccid_hc_rx_new(unsigned char id, struct sock *sk, gfp_t gfp)
 {
+       return ccid_new(id, sk, 1, gfp);
+}
+
+EXPORT_SYMBOL_GPL(ccid_hc_rx_new);
+
+struct ccid *ccid_hc_tx_new(unsigned char id,struct sock *sk,  gfp_t gfp)
+{
+       return ccid_new(id, sk, 0, gfp);
+}
+
+EXPORT_SYMBOL_GPL(ccid_hc_tx_new);
+
+static void ccid_delete(struct ccid *ccid, struct sock *sk, int rx)
+{
+       struct ccid_operations *ccid_ops;
+
        if (ccid == NULL)
                return;
 
+       ccid_ops = ccid->ccid_ops;
+       if (rx) {
+               if (ccid_ops->ccid_hc_rx_exit != NULL)
+                       ccid_ops->ccid_hc_rx_exit(sk);
+               kmem_cache_free(ccid_ops->ccid_hc_rx_slab,  ccid);
+       } else {
+               if (ccid_ops->ccid_hc_tx_exit != NULL)
+                       ccid_ops->ccid_hc_tx_exit(sk);
+               kmem_cache_free(ccid_ops->ccid_hc_tx_slab,  ccid);
+       }
        ccids_read_lock();
+       if (ccids[ccid_ops->ccid_id] != NULL)
+               module_put(ccid_ops->ccid_owner);
+       ccids_read_unlock();
+}
 
-       if (ccids[ccid->ccid_id] != NULL) {
-               if (ccid->ccid_exit != NULL)
-                       ccid->ccid_exit(sk);
-               module_put(ccid->ccid_owner);
-       }
+void ccid_hc_rx_delete(struct ccid *ccid, struct sock *sk)
+{
+       ccid_delete(ccid, sk, 1);
+}
 
-       ccids_read_unlock();
+EXPORT_SYMBOL_GPL(ccid_hc_rx_delete);
+
+void ccid_hc_tx_delete(struct ccid *ccid, struct sock *sk)
+{
+       ccid_delete(ccid, sk, 0);
 }
 
-EXPORT_SYMBOL_GPL(ccid_exit);
+EXPORT_SYMBOL_GPL(ccid_hc_tx_delete);
index de681c6ad081307c8fd1069eb6c370b4854177cd..3dec50d49731d6877d1bfa6ed81e98dd627ec827 100644 (file)
 
 struct tcp_info;
 
-struct ccid {
+struct ccid_operations {
        unsigned char   ccid_id;
        const char      *ccid_name;
        struct module   *ccid_owner;
-       int             (*ccid_init)(struct sock *sk);
-       void            (*ccid_exit)(struct sock *sk);
-       int             (*ccid_hc_rx_init)(struct sock *sk);
-       int             (*ccid_hc_tx_init)(struct sock *sk);
+       kmem_cache_t    *ccid_hc_rx_slab;
+       __u32           ccid_hc_rx_obj_size;
+       kmem_cache_t    *ccid_hc_tx_slab;
+       __u32           ccid_hc_tx_obj_size;
+       int             (*ccid_hc_rx_init)(struct ccid *ccid, struct sock *sk);
+       int             (*ccid_hc_tx_init)(struct ccid *ccid, struct sock *sk);
        void            (*ccid_hc_rx_exit)(struct sock *sk);
        void            (*ccid_hc_tx_exit)(struct sock *sk);
        void            (*ccid_hc_rx_packet_recv)(struct sock *sk,
@@ -67,75 +69,58 @@ struct ccid {
                                                 int __user *optlen);
 };
 
-extern int        ccid_register(struct ccid *ccid);
-extern int        ccid_unregister(struct ccid *ccid);
+extern int ccid_register(struct ccid_operations *ccid_ops);
+extern int ccid_unregister(struct ccid_operations *ccid_ops);
 
-extern struct ccid *ccid_init(unsigned char id, struct sock *sk);
-extern void       ccid_exit(struct ccid *ccid, struct sock *sk);
+struct ccid {
+       struct ccid_operations *ccid_ops;
+       char                   ccid_priv[0];
+};
 
-static inline void __ccid_get(struct ccid *ccid)
+static inline void *ccid_priv(const struct ccid *ccid)
 {
-       __module_get(ccid->ccid_owner);
+       return (void *)ccid->ccid_priv;
 }
 
+extern struct ccid *ccid_new(unsigned char id, struct sock *sk, int rx,
+                            gfp_t gfp);
+
+extern struct ccid *ccid_hc_rx_new(unsigned char id, struct sock *sk,
+                                  gfp_t gfp);
+extern struct ccid *ccid_hc_tx_new(unsigned char id, struct sock *sk,
+                                  gfp_t gfp);
+
+extern void ccid_hc_rx_delete(struct ccid *ccid, struct sock *sk);
+extern void ccid_hc_tx_delete(struct ccid *ccid, struct sock *sk);
+
 static inline int ccid_hc_tx_send_packet(struct ccid *ccid, struct sock *sk,
                                         struct sk_buff *skb, int len)
 {
        int rc = 0;
-       if (ccid->ccid_hc_tx_send_packet != NULL)
-               rc = ccid->ccid_hc_tx_send_packet(sk, skb, len);
+       if (ccid->ccid_ops->ccid_hc_tx_send_packet != NULL)
+               rc = ccid->ccid_ops->ccid_hc_tx_send_packet(sk, skb, len);
        return rc;
 }
 
 static inline void ccid_hc_tx_packet_sent(struct ccid *ccid, struct sock *sk,
                                          int more, int len)
 {
-       if (ccid->ccid_hc_tx_packet_sent != NULL)
-               ccid->ccid_hc_tx_packet_sent(sk, more, len);
-}
-
-static inline int ccid_hc_rx_init(struct ccid *ccid, struct sock *sk)
-{
-       int rc = 0;
-       if (ccid->ccid_hc_rx_init != NULL)
-               rc = ccid->ccid_hc_rx_init(sk);
-       return rc;
-}
-
-static inline int ccid_hc_tx_init(struct ccid *ccid, struct sock *sk)
-{
-       int rc = 0;
-       if (ccid->ccid_hc_tx_init != NULL)
-               rc = ccid->ccid_hc_tx_init(sk);
-       return rc;
-}
-
-static inline void ccid_hc_rx_exit(struct ccid *ccid, struct sock *sk)
-{
-       if (ccid != NULL && ccid->ccid_hc_rx_exit != NULL &&
-           dccp_sk(sk)->dccps_hc_rx_ccid_private != NULL)
-               ccid->ccid_hc_rx_exit(sk);
-}
-
-static inline void ccid_hc_tx_exit(struct ccid *ccid, struct sock *sk)
-{
-       if (ccid != NULL && ccid->ccid_hc_tx_exit != NULL &&
-           dccp_sk(sk)->dccps_hc_tx_ccid_private != NULL)
-               ccid->ccid_hc_tx_exit(sk);
+       if (ccid->ccid_ops->ccid_hc_tx_packet_sent != NULL)
+               ccid->ccid_ops->ccid_hc_tx_packet_sent(sk, more, len);
 }
 
 static inline void ccid_hc_rx_packet_recv(struct ccid *ccid, struct sock *sk,
                                          struct sk_buff *skb)
 {
-       if (ccid->ccid_hc_rx_packet_recv != NULL)
-               ccid->ccid_hc_rx_packet_recv(sk, skb);
+       if (ccid->ccid_ops->ccid_hc_rx_packet_recv != NULL)
+               ccid->ccid_ops->ccid_hc_rx_packet_recv(sk, skb);
 }
 
 static inline void ccid_hc_tx_packet_recv(struct ccid *ccid, struct sock *sk,
                                          struct sk_buff *skb)
 {
-       if (ccid->ccid_hc_tx_packet_recv != NULL)
-               ccid->ccid_hc_tx_packet_recv(sk, skb);
+       if (ccid->ccid_ops->ccid_hc_tx_packet_recv != NULL)
+               ccid->ccid_ops->ccid_hc_tx_packet_recv(sk, skb);
 }
 
 static inline int ccid_hc_tx_parse_options(struct ccid *ccid, struct sock *sk,
@@ -144,8 +129,8 @@ static inline int ccid_hc_tx_parse_options(struct ccid *ccid, struct sock *sk,
                                           unsigned char* value)
 {
        int rc = 0;
-       if (ccid->ccid_hc_tx_parse_options != NULL)
-               rc = ccid->ccid_hc_tx_parse_options(sk, option, len, idx,
+       if (ccid->ccid_ops->ccid_hc_tx_parse_options != NULL)
+               rc = ccid->ccid_ops->ccid_hc_tx_parse_options(sk, option, len, idx,
                                                    value);
        return rc;
 }
@@ -156,37 +141,37 @@ static inline int ccid_hc_rx_parse_options(struct ccid *ccid, struct sock *sk,
                                           unsigned char* value)
 {
        int rc = 0;
-       if (ccid->ccid_hc_rx_parse_options != NULL)
-               rc = ccid->ccid_hc_rx_parse_options(sk, option, len, idx, value);
+       if (ccid->ccid_ops->ccid_hc_rx_parse_options != NULL)
+               rc = ccid->ccid_ops->ccid_hc_rx_parse_options(sk, option, len, idx, value);
        return rc;
 }
 
 static inline void ccid_hc_tx_insert_options(struct ccid *ccid, struct sock *sk,
                                             struct sk_buff *skb)
 {
-       if (ccid->ccid_hc_tx_insert_options != NULL)
-               ccid->ccid_hc_tx_insert_options(sk, skb);
+       if (ccid->ccid_ops->ccid_hc_tx_insert_options != NULL)
+               ccid->ccid_ops->ccid_hc_tx_insert_options(sk, skb);
 }
 
 static inline void ccid_hc_rx_insert_options(struct ccid *ccid, struct sock *sk,
                                             struct sk_buff *skb)
 {
-       if (ccid->ccid_hc_rx_insert_options != NULL)
-               ccid->ccid_hc_rx_insert_options(sk, skb);
+       if (ccid->ccid_ops->ccid_hc_rx_insert_options != NULL)
+               ccid->ccid_ops->ccid_hc_rx_insert_options(sk, skb);
 }
 
 static inline void ccid_hc_rx_get_info(struct ccid *ccid, struct sock *sk,
                                       struct tcp_info *info)
 {
-       if (ccid->ccid_hc_rx_get_info != NULL)
-               ccid->ccid_hc_rx_get_info(sk, info);
+       if (ccid->ccid_ops->ccid_hc_rx_get_info != NULL)
+               ccid->ccid_ops->ccid_hc_rx_get_info(sk, info);
 }
 
 static inline void ccid_hc_tx_get_info(struct ccid *ccid, struct sock *sk,
                                       struct tcp_info *info)
 {
-       if (ccid->ccid_hc_tx_get_info != NULL)
-               ccid->ccid_hc_tx_get_info(sk, info);
+       if (ccid->ccid_ops->ccid_hc_tx_get_info != NULL)
+               ccid->ccid_ops->ccid_hc_tx_get_info(sk, info);
 }
 
 static inline int ccid_hc_rx_getsockopt(struct ccid *ccid, struct sock *sk,
@@ -194,8 +179,8 @@ static inline int ccid_hc_rx_getsockopt(struct ccid *ccid, struct sock *sk,
                                        u32 __user *optval, int __user *optlen)
 {
        int rc = -ENOPROTOOPT;
-       if (ccid->ccid_hc_rx_getsockopt != NULL)
-               rc = ccid->ccid_hc_rx_getsockopt(sk, optname, len,
+       if (ccid->ccid_ops->ccid_hc_rx_getsockopt != NULL)
+               rc = ccid->ccid_ops->ccid_hc_rx_getsockopt(sk, optname, len,
                                                 optval, optlen);
        return rc;
 }
@@ -205,8 +190,8 @@ static inline int ccid_hc_tx_getsockopt(struct ccid *ccid, struct sock *sk,
                                        u32 __user *optval, int __user *optlen)
 {
        int rc = -ENOPROTOOPT;
-       if (ccid->ccid_hc_tx_getsockopt != NULL)
-               rc = ccid->ccid_hc_tx_getsockopt(sk, optname, len,
+       if (ccid->ccid_ops->ccid_hc_tx_getsockopt != NULL)
+               rc = ccid->ccid_ops->ccid_hc_tx_getsockopt(sk, optname, len,
                                                 optval, optlen);
        return rc;
 }
index 3328d23c4be73f72aa1750b9ccd075b31e8d7b54..b40c4569a82031a0c34c3bc83e4c50d2450cfc90 100644 (file)
@@ -52,16 +52,6 @@ static int ccid2_debug;
 
 static const int ccid2_seq_len = 128;
 
-static inline struct ccid2_hc_tx_sock *ccid2_hc_tx_sk(const struct sock *sk)
-{
-       return dccp_sk(sk)->dccps_hc_tx_ccid_private;
-}
-
-static inline struct ccid2_hc_rx_sock *ccid2_hc_rx_sk(const struct sock *sk)
-{
-       return dccp_sk(sk)->dccps_hc_rx_ccid_private;
-}
-
 #ifdef CCID2_DEBUG
 static void ccid2_hc_tx_check_sanity(const struct ccid2_hc_tx_sock *hctx)
 {
@@ -707,19 +697,12 @@ static void ccid2_hc_tx_packet_recv(struct sock *sk, struct sk_buff *skb)
        ccid2_hc_tx_check_sanity(hctx);
 }
 
-static int ccid2_hc_tx_init(struct sock *sk)
+static int ccid2_hc_tx_init(struct ccid *ccid, struct sock *sk)
 {
-       struct dccp_sock *dp = dccp_sk(sk);
-        struct ccid2_hc_tx_sock *hctx;
+        struct ccid2_hc_tx_sock *hctx = ccid_priv(ccid);
        int seqcount = ccid2_seq_len;
        int i;
 
-        dp->dccps_hc_tx_ccid_private = kzalloc(sizeof(*hctx), gfp_any());
-        if (dp->dccps_hc_tx_ccid_private == NULL)
-                return -ENOMEM;
-
-        hctx = ccid2_hc_tx_sk(sk);
-
        /* XXX init variables with proper values */
        hctx->ccid2hctx_cwnd      = 1;
        hctx->ccid2hctx_ssthresh  = 10;
@@ -728,11 +711,9 @@ static int ccid2_hc_tx_init(struct sock *sk)
        /* XXX init ~ to window size... */
        hctx->ccid2hctx_seqbuf = kmalloc(sizeof(*hctx->ccid2hctx_seqbuf) *
                                         seqcount, gfp_any());
-       if (hctx->ccid2hctx_seqbuf == NULL) {
-               kfree(dp->dccps_hc_tx_ccid_private);
-               dp->dccps_hc_tx_ccid_private = NULL;
+       if (hctx->ccid2hctx_seqbuf == NULL)
                return -ENOMEM;
-       }
+
        for (i = 0; i < (seqcount - 1); i++) {
                hctx->ccid2hctx_seqbuf[i].ccid2s_next =
                                        &hctx->ccid2hctx_seqbuf[i + 1];
@@ -763,15 +744,11 @@ static int ccid2_hc_tx_init(struct sock *sk)
 
 static void ccid2_hc_tx_exit(struct sock *sk)
 {
-       struct dccp_sock *dp = dccp_sk(sk);
         struct ccid2_hc_tx_sock *hctx = ccid2_hc_tx_sk(sk);
 
        ccid2_hc_tx_kill_rto_timer(sk);
-
        kfree(hctx->ccid2hctx_seqbuf);
-
-       kfree(dp->dccps_hc_tx_ccid_private);
-       dp->dccps_hc_tx_ccid_private = NULL;
+       hctx->ccid2hctx_seqbuf = NULL;
 }
 
 static void ccid2_hc_rx_packet_recv(struct sock *sk, struct sk_buff *skb)
@@ -791,33 +768,17 @@ static void ccid2_hc_rx_packet_recv(struct sock *sk, struct sk_buff *skb)
        }
 }
 
-static int ccid2_hc_rx_init(struct sock *sk)
-{
-       struct dccp_sock *dp = dccp_sk(sk);
-        dp->dccps_hc_rx_ccid_private = kzalloc(sizeof(struct ccid2_hc_rx_sock),
-                                              gfp_any());
-        return dp->dccps_hc_rx_ccid_private == NULL ? -ENOMEM : 0;
-}
-
-static void ccid2_hc_rx_exit(struct sock *sk)
-{
-       struct dccp_sock *dp = dccp_sk(sk);
-
-       kfree(dp->dccps_hc_rx_ccid_private);
-       dp->dccps_hc_rx_ccid_private = NULL;
-}
-
-static struct ccid ccid2 = {
+static struct ccid_operations ccid2 = {
        .ccid_id                = 2,
        .ccid_name              = "ccid2",
        .ccid_owner             = THIS_MODULE,
+       .ccid_hc_tx_obj_size    = sizeof(struct ccid2_hc_tx_sock),
        .ccid_hc_tx_init        = ccid2_hc_tx_init,
        .ccid_hc_tx_exit        = ccid2_hc_tx_exit,
        .ccid_hc_tx_send_packet = ccid2_hc_tx_send_packet,
        .ccid_hc_tx_packet_sent = ccid2_hc_tx_packet_sent,
        .ccid_hc_tx_packet_recv = ccid2_hc_tx_packet_recv,
-       .ccid_hc_rx_init        = ccid2_hc_rx_init,
-       .ccid_hc_rx_exit        = ccid2_hc_rx_exit,
+       .ccid_hc_rx_obj_size    = sizeof(struct ccid2_hc_rx_sock),
        .ccid_hc_rx_packet_recv = ccid2_hc_rx_packet_recv,
 };
 
index 0b08c90955a9ff8a88d3576f65bb588ac5d1ca86..451a87464fa5d1c3ca12adc0c074e965dc4001bd 100644 (file)
 #ifndef _DCCP_CCID2_H_
 #define _DCCP_CCID2_H_
 
+#include <linux/dccp.h>
+#include <linux/timer.h>
+#include <linux/types.h>
+#include "../ccid.h"
+
+struct sock;
+
 struct ccid2_seq {
        u64                     ccid2s_seq;
        unsigned long           ccid2s_sent;
@@ -66,4 +73,13 @@ struct ccid2_hc_rx_sock {
        int     ccid2hcrx_data;
 };
 
+static inline struct ccid2_hc_tx_sock *ccid2_hc_tx_sk(const struct sock *sk)
+{
+       return ccid_priv(dccp_sk(sk)->dccps_hc_tx_ccid);
+}
+
+static inline struct ccid2_hc_rx_sock *ccid2_hc_rx_sk(const struct sock *sk)
+{
+       return ccid_priv(dccp_sk(sk)->dccps_hc_rx_ccid);
+}
 #endif /* _DCCP_CCID2_H_ */
index f9e16db09bef353435d700824539a829781ee777..0587f52e4af19b4bf1def00f1b5293631ef95d30 100644 (file)
@@ -647,17 +647,10 @@ static int ccid3_hc_tx_parse_options(struct sock *sk, unsigned char option,
        return rc;
 }
 
-static int ccid3_hc_tx_init(struct sock *sk)
+static int ccid3_hc_tx_init(struct ccid *ccid, struct sock *sk)
 {
        struct dccp_sock *dp = dccp_sk(sk);
-       struct ccid3_hc_tx_sock *hctx;
-
-       dp->dccps_hc_tx_ccid_private = kmalloc(sizeof(*hctx), gfp_any());
-       if (dp->dccps_hc_tx_ccid_private == NULL)
-               return -ENOMEM;
-
-       hctx = ccid3_hc_tx_sk(sk);
-       memset(hctx, 0, sizeof(*hctx));
+       struct ccid3_hc_tx_sock *hctx = ccid_priv(ccid);
 
        if (dp->dccps_packet_size >= TFRC_MIN_PACKET_SIZE &&
            dp->dccps_packet_size <= TFRC_MAX_PACKET_SIZE)
@@ -680,7 +673,6 @@ static int ccid3_hc_tx_init(struct sock *sk)
 
 static void ccid3_hc_tx_exit(struct sock *sk)
 {
-       struct dccp_sock *dp = dccp_sk(sk);
        struct ccid3_hc_tx_sock *hctx = ccid3_hc_tx_sk(sk);
 
        BUG_ON(hctx == NULL);
@@ -690,9 +682,6 @@ static void ccid3_hc_tx_exit(struct sock *sk)
 
        /* Empty packet history */
        dccp_tx_hist_purge(ccid3_tx_hist, &hctx->ccid3hctx_hist);
-
-       kfree(dp->dccps_hc_tx_ccid_private);
-       dp->dccps_hc_tx_ccid_private = NULL;
 }
 
 /*
@@ -1039,20 +1028,13 @@ static void ccid3_hc_rx_packet_recv(struct sock *sk, struct sk_buff *skb)
        }
 }
 
-static int ccid3_hc_rx_init(struct sock *sk)
+static int ccid3_hc_rx_init(struct ccid *ccid, struct sock *sk)
 {
        struct dccp_sock *dp = dccp_sk(sk);
-       struct ccid3_hc_rx_sock *hcrx;
+       struct ccid3_hc_rx_sock *hcrx = ccid_priv(ccid);
 
        ccid3_pr_debug("%s, sk=%p\n", dccp_role(sk), sk);
 
-       dp->dccps_hc_rx_ccid_private = kmalloc(sizeof(*hcrx), gfp_any());
-       if (dp->dccps_hc_rx_ccid_private == NULL)
-               return -ENOMEM;
-
-       hcrx = ccid3_hc_rx_sk(sk);
-       memset(hcrx, 0, sizeof(*hcrx));
-
        if (dp->dccps_packet_size >= TFRC_MIN_PACKET_SIZE &&
            dp->dccps_packet_size <= TFRC_MAX_PACKET_SIZE)
                hcrx->ccid3hcrx_s = dp->dccps_packet_size;
@@ -1071,7 +1053,6 @@ static int ccid3_hc_rx_init(struct sock *sk)
 static void ccid3_hc_rx_exit(struct sock *sk)
 {
        struct ccid3_hc_rx_sock *hcrx = ccid3_hc_rx_sk(sk);
-       struct dccp_sock *dp = dccp_sk(sk);
 
        BUG_ON(hcrx == NULL);
 
@@ -1082,9 +1063,6 @@ static void ccid3_hc_rx_exit(struct sock *sk)
 
        /* Empty loss interval history */
        dccp_li_hist_purge(ccid3_li_hist, &hcrx->ccid3hcrx_li_hist);
-
-       kfree(dp->dccps_hc_rx_ccid_private);
-       dp->dccps_hc_rx_ccid_private = NULL;
 }
 
 static void ccid3_hc_rx_get_info(struct sock *sk, struct tcp_info *info)
@@ -1170,10 +1148,11 @@ static int ccid3_hc_tx_getsockopt(struct sock *sk, const int optname, int len,
        return 0;
 }
 
-static struct ccid ccid3 = {
+static struct ccid_operations ccid3 = {
        .ccid_id                   = 3,
        .ccid_name                 = "ccid3",
        .ccid_owner                = THIS_MODULE,
+       .ccid_hc_tx_obj_size       = sizeof(struct ccid3_hc_tx_sock),
        .ccid_hc_tx_init           = ccid3_hc_tx_init,
        .ccid_hc_tx_exit           = ccid3_hc_tx_exit,
        .ccid_hc_tx_send_packet    = ccid3_hc_tx_send_packet,
@@ -1181,6 +1160,7 @@ static struct ccid ccid3 = {
        .ccid_hc_tx_packet_recv    = ccid3_hc_tx_packet_recv,
        .ccid_hc_tx_insert_options = ccid3_hc_tx_insert_options,
        .ccid_hc_tx_parse_options  = ccid3_hc_tx_parse_options,
+       .ccid_hc_rx_obj_size       = sizeof(struct ccid3_hc_rx_sock),
        .ccid_hc_rx_init           = ccid3_hc_rx_init,
        .ccid_hc_rx_exit           = ccid3_hc_rx_exit,
        .ccid_hc_rx_insert_options = ccid3_hc_rx_insert_options,
index 0bde4583d09147f5e95a2ea6993e98da7041619c..f18b96d4e5a25039e3d15c8ae57c54c49b755524 100644 (file)
@@ -41,6 +41,7 @@
 #include <linux/time.h>
 #include <linux/types.h>
 #include <linux/tfrc.h>
+#include "../ccid.h"
 
 #define TFRC_MIN_PACKET_SIZE      16
 #define TFRC_STD_PACKET_SIZE     256
@@ -135,12 +136,12 @@ struct ccid3_hc_rx_sock {
 
 static inline struct ccid3_hc_tx_sock *ccid3_hc_tx_sk(const struct sock *sk)
 {
-    return dccp_sk(sk)->dccps_hc_tx_ccid_private;
+    return ccid_priv(dccp_sk(sk)->dccps_hc_tx_ccid);
 }
 
 static inline struct ccid3_hc_rx_sock *ccid3_hc_rx_sk(const struct sock *sk)
 {
-    return dccp_sk(sk)->dccps_hc_rx_ccid_private;
+    return ccid_priv(dccp_sk(sk)->dccps_hc_rx_ccid);
 }
 
 #endif /* _DCCP_CCID3_H_ */
index 4b6d43d8b9206e13d8e9378e35327e6d36d92acf..67691a0592afa259cc0f57909bfa20ff9dc406da 100644 (file)
@@ -324,14 +324,6 @@ static int dccp_rcv_request_sent_state_process(struct sock *sk,
                dccp_set_seqno(&dp->dccps_swl,
                               max48(dp->dccps_swl, dp->dccps_isr));
 
-               if (ccid_hc_rx_init(dp->dccps_hc_rx_ccid, sk) != 0 ||
-                   ccid_hc_tx_init(dp->dccps_hc_tx_ccid, sk) != 0) {
-                       ccid_hc_rx_exit(dp->dccps_hc_rx_ccid, sk);
-                       ccid_hc_tx_exit(dp->dccps_hc_tx_ccid, sk);
-                       /* FIXME: send appropriate RESET code */
-                       goto out_invalid_packet;
-               }
-
                dccp_sync_mss(sk, icsk->icsk_pmtu_cookie);
 
                /*
index fcfb486f90c2619765b8cf07d67c76ce7b817ed1..aa7708fed32ea7d146e5d597717d152b66527836 100644 (file)
@@ -1058,14 +1058,16 @@ int dccp_v4_init_sock(struct sock *sk)
                        if (dp->dccps_hc_rx_ackvec == NULL)
                                return -ENOMEM;
                }
-               dp->dccps_hc_rx_ccid = ccid_init(dp->dccps_options.dccpo_rx_ccid,
-                                                sk);
-               dp->dccps_hc_tx_ccid = ccid_init(dp->dccps_options.dccpo_tx_ccid,
-                                                sk);
-               if (dp->dccps_hc_rx_ccid == NULL ||
-                   dp->dccps_hc_tx_ccid == NULL) {
-                       ccid_exit(dp->dccps_hc_rx_ccid, sk);
-                       ccid_exit(dp->dccps_hc_tx_ccid, sk);
+               dp->dccps_hc_rx_ccid =
+                               ccid_hc_rx_new(dp->dccps_options.dccpo_rx_ccid,
+                                              sk, GFP_KERNEL);
+               dp->dccps_hc_tx_ccid =
+                               ccid_hc_tx_new(dp->dccps_options.dccpo_tx_ccid,
+                                              sk, GFP_KERNEL);
+               if (unlikely(dp->dccps_hc_rx_ccid == NULL ||
+                            dp->dccps_hc_tx_ccid == NULL)) {
+                       ccid_hc_rx_delete(dp->dccps_hc_rx_ccid, sk);
+                       ccid_hc_tx_delete(dp->dccps_hc_tx_ccid, sk);
                        if (dp->dccps_options.dccpo_send_ack_vector) {
                                dccp_ackvec_free(dp->dccps_hc_rx_ackvec);
                                dp->dccps_hc_rx_ackvec = NULL;
@@ -1120,14 +1122,12 @@ int dccp_v4_destroy_sock(struct sock *sk)
        kfree(dp->dccps_service_list);
        dp->dccps_service_list = NULL;
 
-       ccid_hc_rx_exit(dp->dccps_hc_rx_ccid, sk);
-       ccid_hc_tx_exit(dp->dccps_hc_tx_ccid, sk);
        if (dp->dccps_options.dccpo_send_ack_vector) {
                dccp_ackvec_free(dp->dccps_hc_rx_ackvec);
                dp->dccps_hc_rx_ackvec = NULL;
        }
-       ccid_exit(dp->dccps_hc_rx_ccid, sk);
-       ccid_exit(dp->dccps_hc_tx_ccid, sk);
+       ccid_hc_rx_delete(dp->dccps_hc_rx_ccid, sk);
+       ccid_hc_tx_delete(dp->dccps_hc_tx_ccid, sk);
        dp->dccps_hc_rx_ccid = dp->dccps_hc_tx_ccid = NULL;
 
        /* clean up feature negotiation state */
index 9e1de5919ee5c114e09e83433a656f6a7bbd5fc8..5324fcacb34d5c7b139efcb6a88f57a0c4ba10fa 100644 (file)
@@ -121,23 +121,21 @@ struct sock *dccp_create_openreq_child(struct sock *sk,
                if (newdp->dccps_options.dccpo_send_ack_vector) {
                        newdp->dccps_hc_rx_ackvec =
                                                dccp_ackvec_alloc(GFP_ATOMIC);
-                       /*
-                        * XXX: We're using the same CCIDs set on the parent,
-                        * i.e. sk_clone copied the master sock and left the
-                        * CCID pointers for this child, that is why we do the
-                        * __ccid_get calls.
-                        */
                        if (unlikely(newdp->dccps_hc_rx_ackvec == NULL))
                                goto out_free;
                }
 
-               if (unlikely(ccid_hc_rx_init(newdp->dccps_hc_rx_ccid,
-                                            newsk) != 0 ||
-                            ccid_hc_tx_init(newdp->dccps_hc_tx_ccid,
-                                            newsk) != 0)) {
+               newdp->dccps_hc_rx_ccid =
+                           ccid_hc_rx_new(newdp->dccps_options.dccpo_rx_ccid,
+                                          newsk, GFP_ATOMIC);
+               newdp->dccps_hc_tx_ccid =
+                           ccid_hc_tx_new(newdp->dccps_options.dccpo_tx_ccid,
+                                          newsk, GFP_ATOMIC);
+               if (unlikely(newdp->dccps_hc_rx_ccid == NULL ||
+                            newdp->dccps_hc_tx_ccid == NULL)) {
                        dccp_ackvec_free(newdp->dccps_hc_rx_ackvec);
-                       ccid_hc_rx_exit(newdp->dccps_hc_rx_ccid, newsk);
-                       ccid_hc_tx_exit(newdp->dccps_hc_tx_ccid, newsk);
+                       ccid_hc_rx_delete(newdp->dccps_hc_rx_ccid, newsk);
+                       ccid_hc_tx_delete(newdp->dccps_hc_tx_ccid, newsk);
 out_free:
                        /* It is still raw copy of parent, so invalidate
                         * destructor and make plain sk_free() */
@@ -146,9 +144,6 @@ out_free:
                        return NULL;
                }
 
-               __ccid_get(newdp->dccps_hc_rx_ccid);
-               __ccid_get(newdp->dccps_hc_tx_ccid);
-
                /*
                 * Step 3: Process LISTEN state
                 *