netns xfrm: per-netns state GC work

[deliverable/linux.git] / net / xfrm / xfrm_state.c

diff --git a/net/xfrm/xfrm_state.c b/net/xfrm/xfrm_state.c
index 7ecf6eeff84a3229b25a0cf56140d9398784c7f8..69c0b06bf7567401784aa1cbeb15c2adb961ac8c 100644 (file)
--- a/net/xfrm/xfrm_state.c
+++ b/net/xfrm/xfrm_state.c
@@ -109,16 +109,16 @@ static void xfrm_hash_transfer(struct hlist_head *list,
        }
 }
 
-static unsigned long xfrm_hash_new_size(void)
+static unsigned long xfrm_hash_new_size(unsigned int state_hmask)
 {
-       return ((init_net.xfrm.state_hmask + 1) << 1) *
-               sizeof(struct hlist_head);
+       return ((state_hmask + 1) << 1) * sizeof(struct hlist_head);
 }
 
 static DEFINE_MUTEX(hash_resize_mutex);
 
-static void xfrm_hash_resize(struct work_struct *__unused)
+static void xfrm_hash_resize(struct work_struct *work)
 {
+       struct net *net = container_of(work, struct net, xfrm.state_hash_work);
        struct hlist_head *ndst, *nsrc, *nspi, *odst, *osrc, *ospi;
        unsigned long nsize, osize;
        unsigned int nhashmask, ohashmask;
@@ -126,7 +126,7 @@ static void xfrm_hash_resize(struct work_struct *__unused)
 
        mutex_lock(&hash_resize_mutex);
 
-       nsize = xfrm_hash_new_size();
+       nsize = xfrm_hash_new_size(net->xfrm.state_hmask);
        ndst = xfrm_hash_alloc(nsize);
        if (!ndst)
                goto out_unlock;
@@ -145,19 +145,19 @@ static void xfrm_hash_resize(struct work_struct *__unused)
        spin_lock_bh(&xfrm_state_lock);
 
        nhashmask = (nsize / sizeof(struct hlist_head)) - 1U;
-       for (i = init_net.xfrm.state_hmask; i >= 0; i--)
-               xfrm_hash_transfer(init_net.xfrm.state_bydst+i, ndst, nsrc, nspi,
+       for (i = net->xfrm.state_hmask; i >= 0; i--)
+               xfrm_hash_transfer(net->xfrm.state_bydst+i, ndst, nsrc, nspi,
                                   nhashmask);
 
-       odst = init_net.xfrm.state_bydst;
-       osrc = init_net.xfrm.state_bysrc;
-       ospi = init_net.xfrm.state_byspi;
-       ohashmask = init_net.xfrm.state_hmask;
+       odst = net->xfrm.state_bydst;
+       osrc = net->xfrm.state_bysrc;
+       ospi = net->xfrm.state_byspi;
+       ohashmask = net->xfrm.state_hmask;
 
-       init_net.xfrm.state_bydst = ndst;
-       init_net.xfrm.state_bysrc = nsrc;
-       init_net.xfrm.state_byspi = nspi;
-       init_net.xfrm.state_hmask = nhashmask;
+       net->xfrm.state_bydst = ndst;
+       net->xfrm.state_bysrc = nsrc;
+       net->xfrm.state_byspi = nspi;
+       net->xfrm.state_hmask = nhashmask;
 
        spin_unlock_bh(&xfrm_state_lock);
 
@@ -170,16 +170,12 @@ out_unlock:
        mutex_unlock(&hash_resize_mutex);
 }
 
-static DECLARE_WORK(xfrm_hash_work, xfrm_hash_resize);
-
 DECLARE_WAIT_QUEUE_HEAD(km_waitq);
 EXPORT_SYMBOL(km_waitq);
 
 static DEFINE_RWLOCK(xfrm_state_afinfo_lock);
 static struct xfrm_state_afinfo *xfrm_state_afinfo[NPROTO];
 
-static struct work_struct xfrm_state_gc_work;
-static HLIST_HEAD(xfrm_state_gc_list);
 static DEFINE_SPINLOCK(xfrm_state_gc_lock);
 
 int __xfrm_state_delete(struct xfrm_state *x);
@@ -389,14 +385,15 @@ static void xfrm_state_gc_destroy(struct xfrm_state *x)
        kfree(x);
 }
 
-static void xfrm_state_gc_task(struct work_struct *data)
+static void xfrm_state_gc_task(struct work_struct *work)
 {
+       struct net *net = container_of(work, struct net, xfrm.state_gc_work);
        struct xfrm_state *x;
        struct hlist_node *entry, *tmp;
        struct hlist_head gc_list;
 
        spin_lock_bh(&xfrm_state_gc_lock);
-       hlist_move_list(&xfrm_state_gc_list, &gc_list);
+       hlist_move_list(&net->xfrm.state_gc_list, &gc_list);
        spin_unlock_bh(&xfrm_state_gc_lock);
 
        hlist_for_each_entry_safe(x, entry, tmp, &gc_list, gclist)
@@ -529,9 +526,9 @@ void __xfrm_state_destroy(struct xfrm_state *x)
        WARN_ON(x->km.state != XFRM_STATE_DEAD);
 
        spin_lock_bh(&xfrm_state_gc_lock);
-       hlist_add_head(&x->gclist, &xfrm_state_gc_list);
+       hlist_add_head(&x->gclist, &init_net.xfrm.state_gc_list);
        spin_unlock_bh(&xfrm_state_gc_lock);
-       schedule_work(&xfrm_state_gc_work);
+       schedule_work(&init_net.xfrm.state_gc_work);
 }
 EXPORT_SYMBOL(__xfrm_state_destroy);
 
@@ -754,7 +751,7 @@ static void xfrm_hash_grow_check(int have_hash_collision)
        if (have_hash_collision &&
            (init_net.xfrm.state_hmask + 1) < xfrm_state_hashmax &&
            init_net.xfrm.state_num > init_net.xfrm.state_hmask)
-               schedule_work(&xfrm_hash_work);
+               schedule_work(&init_net.xfrm.state_hash_work);
 }
 
 struct xfrm_state *
@@ -2089,7 +2086,9 @@ int __net_init xfrm_state_init(struct net *net)
        net->xfrm.state_hmask = ((sz / sizeof(struct hlist_head)) - 1);
 
        net->xfrm.state_num = 0;
-       INIT_WORK(&xfrm_state_gc_work, xfrm_state_gc_task);
+       INIT_WORK(&net->xfrm.state_hash_work, xfrm_hash_resize);
+       INIT_HLIST_HEAD(&net->xfrm.state_gc_list);
+       INIT_WORK(&net->xfrm.state_gc_work, xfrm_state_gc_task);
        return 0;
 
 out_byspi: