netfilter: conntrack: mark extension structs as const

[mirror_ubuntu-artful-kernel.git] / net / netfilter / nf_conntrack_extend.c

diff --git a/net/netfilter/nf_conntrack_extend.c b/net/netfilter/nf_conntrack_extend.c
index 02bcf00c24920b332401cd7c82ab6ced951659f5..5c66816eb965129cc0bc8dcfe76d5fbc9351142e 100644 (file)
--- a/net/netfilter/nf_conntrack_extend.c
+++ b/net/netfilter/nf_conntrack_extend.c
@@ -18,6 +18,7 @@
 
 static struct nf_ct_ext_type __rcu *nf_ct_ext_types[NF_CT_EXT_NUM];
 static DEFINE_MUTEX(nf_ct_ext_type_mutex);
+#define NF_CT_EXT_PREALLOC     128u /* conntrack events are on by default */
 
 void __nf_ct_ext_destroy(struct nf_conn *ct)
 {
@@ -44,22 +45,24 @@ void __nf_ct_ext_destroy(struct nf_conn *ct)
 EXPORT_SYMBOL(__nf_ct_ext_destroy);
 
 static void *
-nf_ct_ext_create(struct nf_ct_ext **ext, enum nf_ct_ext_id id,
-                size_t var_alloc_len, gfp_t gfp)
+nf_ct_ext_create(struct nf_ct_ext **ext, enum nf_ct_ext_id id, gfp_t gfp)
 {
-       unsigned int off, len;
+       unsigned int off, len, alloc;
        struct nf_ct_ext_type *t;
-       size_t alloc_size;
 
        rcu_read_lock();
        t = rcu_dereference(nf_ct_ext_types[id]);
-       BUG_ON(t == NULL);
+       if (!t) {
+               rcu_read_unlock();
+               return NULL;
+       }
+
        off = ALIGN(sizeof(struct nf_ct_ext), t->align);
-       len = off + t->len + var_alloc_len;
-       alloc_size = t->alloc_size + var_alloc_len;
+       len = off + t->len;
        rcu_read_unlock();
 
-       *ext = kzalloc(alloc_size, gfp);
+       alloc = max(len, NF_CT_EXT_PREALLOC);
+       *ext = kzalloc(alloc, gfp);
        if (!*ext)
                return NULL;
 
@@ -69,8 +72,7 @@ nf_ct_ext_create(struct nf_ct_ext **ext, enum nf_ct_ext_id id,
        return (void *)(*ext) + off;
 }
 
-void *__nf_ct_ext_add_length(struct nf_conn *ct, enum nf_ct_ext_id id,
-                            size_t var_alloc_len, gfp_t gfp)
+void *nf_ct_ext_add(struct nf_conn *ct, enum nf_ct_ext_id id, gfp_t gfp)
 {
        struct nf_ct_ext *old, *new;
        int newlen, newoff;
@@ -81,17 +83,20 @@ void *__nf_ct_ext_add_length(struct nf_conn *ct, enum nf_ct_ext_id id,
 
        old = ct->ext;
        if (!old)
-               return nf_ct_ext_create(&ct->ext, id, var_alloc_len, gfp);
+               return nf_ct_ext_create(&ct->ext, id, gfp);
 
        if (__nf_ct_ext_exist(old, id))
                return NULL;
 
        rcu_read_lock();
        t = rcu_dereference(nf_ct_ext_types[id]);
-       BUG_ON(t == NULL);
+       if (!t) {
+               rcu_read_unlock();
+               return NULL;
+       }
 
        newoff = ALIGN(old->len, t->align);
-       newlen = newoff + t->len + var_alloc_len;
+       newlen = newoff + t->len;
        rcu_read_unlock();
 
        new = __krealloc(old, newlen, gfp);
@@ -108,45 +113,10 @@ void *__nf_ct_ext_add_length(struct nf_conn *ct, enum nf_ct_ext_id id,
        memset((void *)new + newoff, 0, newlen - newoff);
        return (void *)new + newoff;
 }
-EXPORT_SYMBOL(__nf_ct_ext_add_length);
-
-static void update_alloc_size(struct nf_ct_ext_type *type)
-{
-       int i, j;
-       struct nf_ct_ext_type *t1, *t2;
-       enum nf_ct_ext_id min = 0, max = NF_CT_EXT_NUM - 1;
-
-       /* unnecessary to update all types */
-       if ((type->flags & NF_CT_EXT_F_PREALLOC) == 0) {
-               min = type->id;
-               max = type->id;
-       }
-
-       /* This assumes that extended areas in conntrack for the types
-          whose NF_CT_EXT_F_PREALLOC bit set are allocated in order */
-       for (i = min; i <= max; i++) {
-               t1 = rcu_dereference_protected(nf_ct_ext_types[i],
-                               lockdep_is_held(&nf_ct_ext_type_mutex));
-               if (!t1)
-                       continue;
-
-               t1->alloc_size = ALIGN(sizeof(struct nf_ct_ext), t1->align) +
-                                t1->len;
-               for (j = 0; j < NF_CT_EXT_NUM; j++) {
-                       t2 = rcu_dereference_protected(nf_ct_ext_types[j],
-                               lockdep_is_held(&nf_ct_ext_type_mutex));
-                       if (t2 == NULL || t2 == t1 ||
-                           (t2->flags & NF_CT_EXT_F_PREALLOC) == 0)
-                               continue;
-
-                       t1->alloc_size = ALIGN(t1->alloc_size, t2->align)
-                                        + t2->len;
-               }
-       }
-}
+EXPORT_SYMBOL(nf_ct_ext_add);
 
 /* This MUST be called in process context. */
-int nf_ct_extend_register(struct nf_ct_ext_type *type)
+int nf_ct_extend_register(const struct nf_ct_ext_type *type)
 {
        int ret = 0;
 
@@ -156,12 +126,7 @@ int nf_ct_extend_register(struct nf_ct_ext_type *type)
                goto out;
        }
 
-       /* This ensures that nf_ct_ext_create() can allocate enough area
-          before updating alloc_size */
-       type->alloc_size = ALIGN(sizeof(struct nf_ct_ext), type->align)
-                          + type->len;
        rcu_assign_pointer(nf_ct_ext_types[type->id], type);
-       update_alloc_size(type);
 out:
        mutex_unlock(&nf_ct_ext_type_mutex);
        return ret;
@@ -169,12 +134,11 @@ out:
 EXPORT_SYMBOL_GPL(nf_ct_extend_register);
 
 /* This MUST be called in process context. */
-void nf_ct_extend_unregister(struct nf_ct_ext_type *type)
+void nf_ct_extend_unregister(const struct nf_ct_ext_type *type)
 {
        mutex_lock(&nf_ct_ext_type_mutex);
        RCU_INIT_POINTER(nf_ct_ext_types[type->id], NULL);
-       update_alloc_size(type);
        mutex_unlock(&nf_ct_ext_type_mutex);
-       rcu_barrier(); /* Wait for completion of call_rcu()'s */
+       synchronize_rcu();
 }
 EXPORT_SYMBOL_GPL(nf_ct_extend_unregister);