net_sched: switch to rcu_work

BugLink: https://bugs.launchpad.net/bugs/1825942
Commit 05f0fe6b74db ("RCU, workqueue: Implement rcu_work") introduces
new API's for dispatching work in a RCU callback. Now we can just
switch to the new API's for tc filters. This could get rid of a lot
of code.

Cc: Tejun Heo <tj@kernel.org>
Cc: "Paul E. McKenney" <paulmck@linux.vnet.ibm.com>
Cc: Jamal Hadi Salim <jhs@mojatatu.com>
Signed-off-by: Cong Wang <xiyou.wangcong@gmail.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
(backported from commit aaa908ffbee18a65529b716efb346a626e81559a)
Signed-off-by: Andrea Righi <andrea.righi@canonical.com>
Acked-by: Connor Kuehl <connor.kuehl@canonical.com>
Acked-by: Thadeu Lima de Souza Cascardo <cascardo@canonical.com>
Signed-off-by: Kleber Sacilotto de Souza <kleber.souza@canonical.com>

diff --git a/include/net/pkt_cls.h b/include/net/pkt_cls.h
index 753ac9361154be4ff9d05f5aa22473f8fb818ea0..9206a1b2d6c3ee8f0b2fc568e69652b030d2a648 100644 (file)
--- a/include/net/pkt_cls.h
+++ b/include/net/pkt_cls.h
@@ -32,7 +32,7 @@ struct tcf_block_ext_info {
 };
 
 struct tcf_block_cb;
-bool tcf_queue_work(struct work_struct *work);
+bool tcf_queue_work(struct rcu_work *rwork, work_func_t func);
 
 #ifdef CONFIG_NET_CLS
 struct tcf_chain *tcf_chain_get(struct tcf_block *block, u32 chain_index,

diff --git a/net/sched/cls_api.c b/net/sched/cls_api.c
index 64d414198286974d5ac7333ce496065346407373..115c89c9734e5e428ba5ee9d40bb71fe4ead26f5 100644 (file)
--- a/net/sched/cls_api.c
+++ b/net/sched/cls_api.c
@@ -102,9 +102,10 @@ int unregister_tcf_proto_ops(struct tcf_proto_ops *ops)
 }
 EXPORT_SYMBOL(unregister_tcf_proto_ops);
 
-bool tcf_queue_work(struct work_struct *work)
+bool tcf_queue_work(struct rcu_work *rwork, work_func_t func)
 {
-       return queue_work(tc_filter_wq, work);
+       INIT_RCU_WORK(rwork, func);
+       return queue_rcu_work(tc_filter_wq, rwork);
 }
 EXPORT_SYMBOL(tcf_queue_work);
 

diff --git a/net/sched/cls_basic.c b/net/sched/cls_basic.c
index 5f169ded347e8714aca536f93e1480d228df72c8..0fb49c30cdbe1904b94361b24b8130f6507ee591 100644 (file)
--- a/net/sched/cls_basic.c
+++ b/net/sched/cls_basic.c
@@ -35,10 +35,7 @@ struct basic_filter {
        struct tcf_result       res;
        struct tcf_proto        *tp;
        struct list_head        link;
-       union {
-               struct work_struct      work;
-               struct rcu_head         rcu;
-       };
+       struct rcu_work         rwork;
 };
 
 static int basic_classify(struct sk_buff *skb, const struct tcf_proto *tp,
@@ -97,21 +94,14 @@ static void __basic_delete_filter(struct basic_filter *f)
 
 static void basic_delete_filter_work(struct work_struct *work)
 {
-       struct basic_filter *f = container_of(work, struct basic_filter, work);
-
+       struct basic_filter *f = container_of(to_rcu_work(work),
+                                             struct basic_filter,
+                                             rwork);
        rtnl_lock();
        __basic_delete_filter(f);
        rtnl_unlock();
 }
 
-static void basic_delete_filter(struct rcu_head *head)
-{
-       struct basic_filter *f = container_of(head, struct basic_filter, rcu);
-
-       INIT_WORK(&f->work, basic_delete_filter_work);
-       tcf_queue_work(&f->work);
-}
-
 static void basic_destroy(struct tcf_proto *tp)
 {
        struct basic_head *head = rtnl_dereference(tp->root);
@@ -122,7 +112,7 @@ static void basic_destroy(struct tcf_proto *tp)
                tcf_unbind_filter(tp, &f->res);
                idr_remove_ext(&head->handle_idr, f->handle);
                if (tcf_exts_get_net(&f->exts))
-                       call_rcu(&f->rcu, basic_delete_filter);
+                       tcf_queue_work(&f->rwork, basic_delete_filter_work);
                else
                        __basic_delete_filter(f);
        }
@@ -139,7 +129,7 @@ static int basic_delete(struct tcf_proto *tp, void *arg, bool *last)
        tcf_unbind_filter(tp, &f->res);
        idr_remove_ext(&head->handle_idr, f->handle);
        tcf_exts_get_net(&f->exts);
-       call_rcu(&f->rcu, basic_delete_filter);
+       tcf_queue_work(&f->rwork, basic_delete_filter_work);
        *last = list_empty(&head->flist);
        return 0;
 }
@@ -235,7 +225,7 @@ static int basic_change(struct net *net, struct sk_buff *in_skb,
                list_replace_rcu(&fold->link, &fnew->link);
                tcf_unbind_filter(tp, &fold->res);
                tcf_exts_get_net(&fold->exts);
-               call_rcu(&fold->rcu, basic_delete_filter);
+               tcf_queue_work(&fold->rwork, basic_delete_filter_work);
        } else {
                list_add_rcu(&fnew->link, &head->flist);
        }

diff --git a/net/sched/cls_bpf.c b/net/sched/cls_bpf.c
index a62586e2dbdb91e4a04226a410035e0cde94b91d..91620bc441fcdea525f2d254cef526b79f45fdb1 100644 (file)
--- a/net/sched/cls_bpf.c
+++ b/net/sched/cls_bpf.c
@@ -49,10 +49,7 @@ struct cls_bpf_prog {
        struct sock_filter *bpf_ops;
        const char *bpf_name;
        struct tcf_proto *tp;
-       union {
-               struct work_struct work;
-               struct rcu_head rcu;
-       };
+       struct rcu_work rwork;
 };
 
 static const struct nla_policy bpf_policy[TCA_BPF_MAX + 1] = {
@@ -270,21 +267,14 @@ static void __cls_bpf_delete_prog(struct cls_bpf_prog *prog)
 
 static void cls_bpf_delete_prog_work(struct work_struct *work)
 {
-       struct cls_bpf_prog *prog = container_of(work, struct cls_bpf_prog, work);
-
+       struct cls_bpf_prog *prog = container_of(to_rcu_work(work),
+                                                struct cls_bpf_prog,
+                                                rwork);
        rtnl_lock();
        __cls_bpf_delete_prog(prog);
        rtnl_unlock();
 }
 
-static void cls_bpf_delete_prog_rcu(struct rcu_head *rcu)
-{
-       struct cls_bpf_prog *prog = container_of(rcu, struct cls_bpf_prog, rcu);
-
-       INIT_WORK(&prog->work, cls_bpf_delete_prog_work);
-       tcf_queue_work(&prog->work);
-}
-
 static void __cls_bpf_delete(struct tcf_proto *tp, struct cls_bpf_prog *prog)
 {
        struct cls_bpf_head *head = rtnl_dereference(tp->root);
@@ -294,7 +284,7 @@ static void __cls_bpf_delete(struct tcf_proto *tp, struct cls_bpf_prog *prog)
        list_del_rcu(&prog->link);
        tcf_unbind_filter(tp, &prog->res);
        if (tcf_exts_get_net(&prog->exts))
-               call_rcu(&prog->rcu, cls_bpf_delete_prog_rcu);
+               tcf_queue_work(&prog->rwork, cls_bpf_delete_prog_work);
        else
                __cls_bpf_delete_prog(prog);
 }
@@ -520,7 +510,7 @@ static int cls_bpf_change(struct net *net, struct sk_buff *in_skb,
                list_replace_rcu(&oldprog->link, &prog->link);
                tcf_unbind_filter(tp, &oldprog->res);
                tcf_exts_get_net(&oldprog->exts);
-               call_rcu(&oldprog->rcu, cls_bpf_delete_prog_rcu);
+               tcf_queue_work(&oldprog->rwork, cls_bpf_delete_prog_work);
        } else {
                list_add_rcu(&prog->link, &head->plist);
        }

diff --git a/net/sched/cls_cgroup.c b/net/sched/cls_cgroup.c
index 309d5899265f8f7dea731a2a8569867fa5077e09..1322fcac12e5704fb93d0809be62562d63db5eab 100644 (file)
--- a/net/sched/cls_cgroup.c
+++ b/net/sched/cls_cgroup.c
@@ -23,10 +23,7 @@ struct cls_cgroup_head {
        struct tcf_exts         exts;
        struct tcf_ematch_tree  ematches;
        struct tcf_proto        *tp;
-       union {
-               struct work_struct      work;
-               struct rcu_head         rcu;
-       };
+       struct rcu_work         rwork;
 };
 
 static int cls_cgroup_classify(struct sk_buff *skb, const struct tcf_proto *tp,
@@ -70,24 +67,14 @@ static void __cls_cgroup_destroy(struct cls_cgroup_head *head)
 
 static void cls_cgroup_destroy_work(struct work_struct *work)
 {
-       struct cls_cgroup_head *head = container_of(work,
+       struct cls_cgroup_head *head = container_of(to_rcu_work(work),
                                                    struct cls_cgroup_head,
-                                                   work);
+                                                   rwork);
        rtnl_lock();
        __cls_cgroup_destroy(head);
        rtnl_unlock();
 }
 
-static void cls_cgroup_destroy_rcu(struct rcu_head *root)
-{
-       struct cls_cgroup_head *head = container_of(root,
-                                                   struct cls_cgroup_head,
-                                                   rcu);
-
-       INIT_WORK(&head->work, cls_cgroup_destroy_work);
-       tcf_queue_work(&head->work);
-}
-
 static int cls_cgroup_change(struct net *net, struct sk_buff *in_skb,
                             struct tcf_proto *tp, unsigned long base,
                             u32 handle, struct nlattr **tca,
@@ -132,7 +119,7 @@ static int cls_cgroup_change(struct net *net, struct sk_buff *in_skb,
        rcu_assign_pointer(tp->root, new);
        if (head) {
                tcf_exts_get_net(&head->exts);
-               call_rcu(&head->rcu, cls_cgroup_destroy_rcu);
+               tcf_queue_work(&head->rwork, cls_cgroup_destroy_work);
        }
        return 0;
 errout:
@@ -148,7 +135,7 @@ static void cls_cgroup_destroy(struct tcf_proto *tp)
        /* Head can still be NULL due to cls_cgroup_init(). */
        if (head) {
                if (tcf_exts_get_net(&head->exts))
-                       call_rcu(&head->rcu, cls_cgroup_destroy_rcu);
+                       tcf_queue_work(&head->rwork, cls_cgroup_destroy_work);
                else
                        __cls_cgroup_destroy(head);
        }

diff --git a/net/sched/cls_flow.c b/net/sched/cls_flow.c
index 25c2a888e1f0ed4296977c2b2a379cc17bcd4b85..d9d3d525e20c1dc3ba545385fe635f9e8812a9b8 100644 (file)
--- a/net/sched/cls_flow.c
+++ b/net/sched/cls_flow.c
@@ -57,10 +57,7 @@ struct flow_filter {
        u32                     divisor;
        u32                     baseclass;
        u32                     hashrnd;
-       union {
-               struct work_struct      work;
-               struct rcu_head         rcu;
-       };
+       struct rcu_work         rwork;
 };
 
 static inline u32 addr_fold(void *addr)
@@ -383,21 +380,14 @@ static void __flow_destroy_filter(struct flow_filter *f)
 
 static void flow_destroy_filter_work(struct work_struct *work)
 {
-       struct flow_filter *f = container_of(work, struct flow_filter, work);
-
+       struct flow_filter *f = container_of(to_rcu_work(work),
+                                            struct flow_filter,
+                                            rwork);
        rtnl_lock();
        __flow_destroy_filter(f);
        rtnl_unlock();
 }
 
-static void flow_destroy_filter(struct rcu_head *head)
-{
-       struct flow_filter *f = container_of(head, struct flow_filter, rcu);
-
-       INIT_WORK(&f->work, flow_destroy_filter_work);
-       tcf_queue_work(&f->work);
-}
-
 static int flow_change(struct net *net, struct sk_buff *in_skb,
                       struct tcf_proto *tp, unsigned long base,
                       u32 handle, struct nlattr **tca,
@@ -562,7 +552,7 @@ static int flow_change(struct net *net, struct sk_buff *in_skb,
 
        if (fold) {
                tcf_exts_get_net(&fold->exts);
-               call_rcu(&fold->rcu, flow_destroy_filter);
+               tcf_queue_work(&fold->rwork, flow_destroy_filter_work);
        }
        return 0;
 
@@ -581,7 +571,7 @@ static int flow_delete(struct tcf_proto *tp, void *arg, bool *last)
 
        list_del_rcu(&f->list);
        tcf_exts_get_net(&f->exts);
-       call_rcu(&f->rcu, flow_destroy_filter);
+       tcf_queue_work(&f->rwork, flow_destroy_filter_work);
        *last = list_empty(&head->filters);
        return 0;
 }
@@ -606,7 +596,7 @@ static void flow_destroy(struct tcf_proto *tp)
        list_for_each_entry_safe(f, next, &head->filters, list) {
                list_del_rcu(&f->list);
                if (tcf_exts_get_net(&f->exts))
-                       call_rcu(&f->rcu, flow_destroy_filter);
+                       tcf_queue_work(&f->rwork, flow_destroy_filter_work);
                else
                        __flow_destroy_filter(f);
        }

diff --git a/net/sched/cls_flower.c b/net/sched/cls_flower.c
index 1a85ce06dd365b31ea20dbd72db11dbce8955e3f..39dbaa41b4584f5cf811ad7ed3340a748d2f3de1 100644 (file)
--- a/net/sched/cls_flower.c
+++ b/net/sched/cls_flower.c
@@ -71,10 +71,7 @@ struct cls_fl_head {
        bool mask_assigned;
        struct list_head filters;
        struct rhashtable_params ht_params;
-       union {
-               struct work_struct work;
-               struct rcu_head rcu;
-       };
+       struct rcu_work rwork;
        struct idr handle_idr;
 };
 
@@ -87,10 +84,7 @@ struct cls_fl_filter {
        struct list_head list;
        u32 handle;
        u32 flags;
-       union {
-               struct work_struct work;
-               struct rcu_head rcu;
-       };
+       struct rcu_work rwork;
        struct net_device *hw_dev;
 };
 
@@ -202,21 +196,14 @@ static void __fl_destroy_filter(struct cls_fl_filter *f)
 
 static void fl_destroy_filter_work(struct work_struct *work)
 {
-       struct cls_fl_filter *f = container_of(work, struct cls_fl_filter, work);
+       struct cls_fl_filter *f = container_of(to_rcu_work(work),
+                                       struct cls_fl_filter, rwork);
 
        rtnl_lock();
        __fl_destroy_filter(f);
        rtnl_unlock();
 }
 
-static void fl_destroy_filter(struct rcu_head *head)
-{
-       struct cls_fl_filter *f = container_of(head, struct cls_fl_filter, rcu);
-
-       INIT_WORK(&f->work, fl_destroy_filter_work);
-       tcf_queue_work(&f->work);
-}
-
 static void fl_hw_destroy_filter(struct tcf_proto *tp, struct cls_fl_filter *f)
 {
        struct tc_cls_flower_offload cls_flower = {};
@@ -289,29 +276,22 @@ static void __fl_delete(struct tcf_proto *tp, struct cls_fl_filter *f)
                fl_hw_destroy_filter(tp, f);
        tcf_unbind_filter(tp, &f->res);
        if (tcf_exts_get_net(&f->exts))
-               call_rcu(&f->rcu, fl_destroy_filter);
+               tcf_queue_work(&f->rwork, fl_destroy_filter_work);
        else
                __fl_destroy_filter(f);
 }
 
 static void fl_destroy_sleepable(struct work_struct *work)
 {
-       struct cls_fl_head *head = container_of(work, struct cls_fl_head,
-                                               work);
+       struct cls_fl_head *head = container_of(to_rcu_work(work),
+                                               struct cls_fl_head,
+                                               rwork);
        if (head->mask_assigned)
                rhashtable_destroy(&head->ht);
        kfree(head);
        module_put(THIS_MODULE);
 }
 
-static void fl_destroy_rcu(struct rcu_head *rcu)
-{
-       struct cls_fl_head *head = container_of(rcu, struct cls_fl_head, rcu);
-
-       INIT_WORK(&head->work, fl_destroy_sleepable);
-       schedule_work(&head->work);
-}
-
 static void fl_destroy(struct tcf_proto *tp)
 {
        struct cls_fl_head *head = rtnl_dereference(tp->root);
@@ -322,7 +302,7 @@ static void fl_destroy(struct tcf_proto *tp)
        idr_destroy(&head->handle_idr);
 
        __module_get(THIS_MODULE);
-       call_rcu(&head->rcu, fl_destroy_rcu);
+       tcf_queue_work(&head->rwork, fl_destroy_sleepable);
 }
 
 static void *fl_get(struct tcf_proto *tp, u32 handle)
@@ -962,7 +942,7 @@ static int fl_change(struct net *net, struct sk_buff *in_skb,
                list_replace_rcu(&fold->list, &fnew->list);
                tcf_unbind_filter(tp, &fold->res);
                tcf_exts_get_net(&fold->exts);
-               call_rcu(&fold->rcu, fl_destroy_filter);
+               tcf_queue_work(&fold->rwork, fl_destroy_filter_work);
        } else {
                list_add_tail_rcu(&fnew->list, &head->filters);
        }

diff --git a/net/sched/cls_fw.c b/net/sched/cls_fw.c
index 20f0de1a960a7b993596355acc35bf15a7dd02bd..964f2e3ed64d443f13de032baf056960e2f378e3 100644 (file)
--- a/net/sched/cls_fw.c
+++ b/net/sched/cls_fw.c
@@ -47,10 +47,7 @@ struct fw_filter {
 #endif /* CONFIG_NET_CLS_IND */
        struct tcf_exts         exts;
        struct tcf_proto        *tp;
-       union {
-               struct work_struct      work;
-               struct rcu_head         rcu;
-       };
+       struct rcu_work         rwork;
 };
 
 static u32 fw_hash(u32 handle)
@@ -134,21 +131,14 @@ static void __fw_delete_filter(struct fw_filter *f)
 
 static void fw_delete_filter_work(struct work_struct *work)
 {
-       struct fw_filter *f = container_of(work, struct fw_filter, work);
-
+       struct fw_filter *f = container_of(to_rcu_work(work),
+                                          struct fw_filter,
+                                          rwork);
        rtnl_lock();
        __fw_delete_filter(f);
        rtnl_unlock();
 }
 
-static void fw_delete_filter(struct rcu_head *head)
-{
-       struct fw_filter *f = container_of(head, struct fw_filter, rcu);
-
-       INIT_WORK(&f->work, fw_delete_filter_work);
-       tcf_queue_work(&f->work);
-}
-
 static void fw_destroy(struct tcf_proto *tp)
 {
        struct fw_head *head = rtnl_dereference(tp->root);
@@ -164,7 +154,7 @@ static void fw_destroy(struct tcf_proto *tp)
                                         rtnl_dereference(f->next));
                        tcf_unbind_filter(tp, &f->res);
                        if (tcf_exts_get_net(&f->exts))
-                               call_rcu(&f->rcu, fw_delete_filter);
+                               tcf_queue_work(&f->rwork, fw_delete_filter_work);
                        else
                                __fw_delete_filter(f);
                }
@@ -192,7 +182,7 @@ static int fw_delete(struct tcf_proto *tp, void *arg, bool *last)
                        RCU_INIT_POINTER(*fp, rtnl_dereference(f->next));
                        tcf_unbind_filter(tp, &f->res);
                        tcf_exts_get_net(&f->exts);
-                       call_rcu(&f->rcu, fw_delete_filter);
+                       tcf_queue_work(&f->rwork, fw_delete_filter_work);
                        ret = 0;
                        break;
                }
@@ -313,7 +303,7 @@ static int fw_change(struct net *net, struct sk_buff *in_skb,
                rcu_assign_pointer(*fp, fnew);
                tcf_unbind_filter(tp, &f->res);
                tcf_exts_get_net(&f->exts);
-               call_rcu(&f->rcu, fw_delete_filter);
+               tcf_queue_work(&f->rwork, fw_delete_filter_work);
 
                *arg = fnew;
                return err;

diff --git a/net/sched/cls_matchall.c b/net/sched/cls_matchall.c
index 66d4e009915831a1c5bb992fe19a4e2c55e1e490..550be06dc625c93b9afbf0ccf2137940598adff4 100644 (file)
--- a/net/sched/cls_matchall.c
+++ b/net/sched/cls_matchall.c
@@ -21,10 +21,7 @@ struct cls_mall_head {
        struct tcf_result res;
        u32 handle;
        u32 flags;
-       union {
-               struct work_struct work;
-               struct rcu_head rcu;
-       };
+       struct rcu_work rwork;
 };
 
 static int mall_classify(struct sk_buff *skb, const struct tcf_proto *tp,
@@ -53,22 +50,14 @@ static void __mall_destroy(struct cls_mall_head *head)
 
 static void mall_destroy_work(struct work_struct *work)
 {
-       struct cls_mall_head *head = container_of(work, struct cls_mall_head,
-                                                 work);
+       struct cls_mall_head *head = container_of(to_rcu_work(work),
+                                                 struct cls_mall_head,
+                                                 rwork);
        rtnl_lock();
        __mall_destroy(head);
        rtnl_unlock();
 }
 
-static void mall_destroy_rcu(struct rcu_head *rcu)
-{
-       struct cls_mall_head *head = container_of(rcu, struct cls_mall_head,
-                                                 rcu);
-
-       INIT_WORK(&head->work, mall_destroy_work);
-       tcf_queue_work(&head->work);
-}
-
 static void mall_destroy_hw_filter(struct tcf_proto *tp,
                                   struct cls_mall_head *head,
                                   unsigned long cookie)
@@ -123,7 +112,7 @@ static void mall_destroy(struct tcf_proto *tp)
                mall_destroy_hw_filter(tp, head, (unsigned long) head);
 
        if (tcf_exts_get_net(&head->exts))
-               call_rcu(&head->rcu, mall_destroy_rcu);
+               tcf_queue_work(&head->rwork, mall_destroy_work);
        else
                __mall_destroy(head);
 }

diff --git a/net/sched/cls_route.c b/net/sched/cls_route.c
index ac9a5b8825b9d572a0e60453fc6c68e82bdab320..b9e3621d0775e8c12e7aead2ade0b77c1932e333 100644 (file)
--- a/net/sched/cls_route.c
+++ b/net/sched/cls_route.c
@@ -57,10 +57,7 @@ struct route4_filter {
        u32                     handle;
        struct route4_bucket    *bkt;
        struct tcf_proto        *tp;
-       union {
-               struct work_struct      work;
-               struct rcu_head         rcu;
-       };
+       struct rcu_work         rwork;
 };
 
 #define ROUTE4_FAILURE ((struct route4_filter *)(-1L))
@@ -266,19 +263,17 @@ static void __route4_delete_filter(struct route4_filter *f)
 
 static void route4_delete_filter_work(struct work_struct *work)
 {
-       struct route4_filter *f = container_of(work, struct route4_filter, work);
-
+       struct route4_filter *f = container_of(to_rcu_work(work),
+                                              struct route4_filter,
+                                              rwork);
        rtnl_lock();
        __route4_delete_filter(f);
        rtnl_unlock();
 }
 
-static void route4_delete_filter(struct rcu_head *head)
+static void route4_queue_work(struct route4_filter *f)
 {
-       struct route4_filter *f = container_of(head, struct route4_filter, rcu);
-
-       INIT_WORK(&f->work, route4_delete_filter_work);
-       tcf_queue_work(&f->work);
+       tcf_queue_work(&f->rwork, route4_delete_filter_work);
 }
 
 static void route4_destroy(struct tcf_proto *tp)
@@ -304,7 +299,7 @@ static void route4_destroy(struct tcf_proto *tp)
                                        RCU_INIT_POINTER(b->ht[h2], next);
                                        tcf_unbind_filter(tp, &f->res);
                                        if (tcf_exts_get_net(&f->exts))
-                                               call_rcu(&f->rcu, route4_delete_filter);
+                                               route4_queue_work(f);
                                        else
                                                __route4_delete_filter(f);
                                }
@@ -348,7 +343,7 @@ static int route4_delete(struct tcf_proto *tp, void *arg, bool *last)
                        /* Delete it */
                        tcf_unbind_filter(tp, &f->res);
                        tcf_exts_get_net(&f->exts);
-                       call_rcu(&f->rcu, route4_delete_filter);
+                       tcf_queue_work(&f->rwork, route4_delete_filter_work);
 
                        /* Strip RTNL protected tree */
                        for (i = 0; i <= 32; i++) {
@@ -552,7 +547,7 @@ static int route4_change(struct net *net, struct sk_buff *in_skb,
        if (fold) {
                tcf_unbind_filter(tp, &fold->res);
                tcf_exts_get_net(&fold->exts);
-               call_rcu(&fold->rcu, route4_delete_filter);
+               tcf_queue_work(&fold->rwork, route4_delete_filter_work);
        }
        return 0;
 

diff --git a/net/sched/cls_rsvp.h b/net/sched/cls_rsvp.h
index cf325625c99da83df0503a7a324d1b962540a34a..4e1807b41028598f864d92dd045fce54cfd45036 100644 (file)
--- a/net/sched/cls_rsvp.h
+++ b/net/sched/cls_rsvp.h
@@ -97,10 +97,7 @@ struct rsvp_filter {
 
        u32                             handle;
        struct rsvp_session             *sess;
-       union {
-               struct work_struct              work;
-               struct rcu_head                 rcu;
-       };
+       struct rcu_work                 rwork;
 };
 
 static inline unsigned int hash_dst(__be32 *dst, u8 protocol, u8 tunnelid)
@@ -294,21 +291,14 @@ static void __rsvp_delete_filter(struct rsvp_filter *f)
 
 static void rsvp_delete_filter_work(struct work_struct *work)
 {
-       struct rsvp_filter *f = container_of(work, struct rsvp_filter, work);
-
+       struct rsvp_filter *f = container_of(to_rcu_work(work),
+                                            struct rsvp_filter,
+                                            rwork);
        rtnl_lock();
        __rsvp_delete_filter(f);
        rtnl_unlock();
 }
 
-static void rsvp_delete_filter_rcu(struct rcu_head *head)
-{
-       struct rsvp_filter *f = container_of(head, struct rsvp_filter, rcu);
-
-       INIT_WORK(&f->work, rsvp_delete_filter_work);
-       tcf_queue_work(&f->work);
-}
-
 static void rsvp_delete_filter(struct tcf_proto *tp, struct rsvp_filter *f)
 {
        tcf_unbind_filter(tp, &f->res);
@@ -317,7 +307,7 @@ static void rsvp_delete_filter(struct tcf_proto *tp, struct rsvp_filter *f)
         * in cleanup() callback
         */
        if (tcf_exts_get_net(&f->exts))
-               call_rcu(&f->rcu, rsvp_delete_filter_rcu);
+               tcf_queue_work(&f->rwork, rsvp_delete_filter_work);
        else
                __rsvp_delete_filter(f);
 }

diff --git a/net/sched/cls_tcindex.c b/net/sched/cls_tcindex.c
index 72608baaef02c25d863b6320d2939db285ff2daf..752ac4bd9028f1bfecb32d983f7c72a4c0312eb8 100644 (file)
--- a/net/sched/cls_tcindex.c
+++ b/net/sched/cls_tcindex.c
@@ -28,20 +28,14 @@
 struct tcindex_filter_result {
        struct tcf_exts         exts;
        struct tcf_result       res;
-       union {
-               struct work_struct      work;
-               struct rcu_head         rcu;
-       };
+       struct rcu_work         rwork;
 };
 
 struct tcindex_filter {
        u16 key;
        struct tcindex_filter_result result;
        struct tcindex_filter __rcu *next;
-       union {
-               struct work_struct work;
-               struct rcu_head rcu;
-       };
+       struct rcu_work rwork;
 };
 
 
@@ -152,21 +146,14 @@ static void tcindex_destroy_rexts_work(struct work_struct *work)
 {
        struct tcindex_filter_result *r;
 
-       r = container_of(work, struct tcindex_filter_result, work);
+       r = container_of(to_rcu_work(work),
+                        struct tcindex_filter_result,
+                        rwork);
        rtnl_lock();
        __tcindex_destroy_rexts(r);
        rtnl_unlock();
 }
 
-static void tcindex_destroy_rexts(struct rcu_head *head)
-{
-       struct tcindex_filter_result *r;
-
-       r = container_of(head, struct tcindex_filter_result, rcu);
-       INIT_WORK(&r->work, tcindex_destroy_rexts_work);
-       tcf_queue_work(&r->work);
-}
-
 static void __tcindex_destroy_fexts(struct tcindex_filter *f)
 {
        tcf_exts_destroy(&f->result.exts);
@@ -176,23 +163,15 @@ static void __tcindex_destroy_fexts(struct tcindex_filter *f)
 
 static void tcindex_destroy_fexts_work(struct work_struct *work)
 {
-       struct tcindex_filter *f = container_of(work, struct tcindex_filter,
-                                               work);
+       struct tcindex_filter *f = container_of(to_rcu_work(work),
+                                               struct tcindex_filter,
+                                               rwork);
 
        rtnl_lock();
        __tcindex_destroy_fexts(f);
        rtnl_unlock();
 }
 
-static void tcindex_destroy_fexts(struct rcu_head *head)
-{
-       struct tcindex_filter *f = container_of(head, struct tcindex_filter,
-                                               rcu);
-
-       INIT_WORK(&f->work, tcindex_destroy_fexts_work);
-       tcf_queue_work(&f->work);
-}
-
 static int tcindex_delete(struct tcf_proto *tp, void *arg, bool *last)
 {
        struct tcindex_data *p = rtnl_dereference(tp->root);
@@ -227,12 +206,12 @@ found:
         */
        if (f) {
                if (tcf_exts_get_net(&f->result.exts))
-                       call_rcu(&f->rcu, tcindex_destroy_fexts);
+                       tcf_queue_work(&f->rwork, tcindex_destroy_fexts_work);
                else
                        __tcindex_destroy_fexts(f);
        } else {
                if (tcf_exts_get_net(&r->exts))
-                       call_rcu(&r->rcu, tcindex_destroy_rexts);
+                       tcf_queue_work(&r->rwork, tcindex_destroy_rexts_work);
                else
                        __tcindex_destroy_rexts(r);
        }

diff --git a/net/sched/cls_u32.c b/net/sched/cls_u32.c
index 8d25f38cc1ad4f39efba88c1f848ca0af523844f..413a59a78d2ac576711af2edc50344fa58e76083 100644 (file)
--- a/net/sched/cls_u32.c
+++ b/net/sched/cls_u32.c
@@ -68,10 +68,7 @@ struct tc_u_knode {
        u32 __percpu            *pcpu_success;
 #endif
        struct tcf_proto        *tp;
-       union {
-               struct work_struct      work;
-               struct rcu_head         rcu;
-       };
+       struct rcu_work         rwork;
        /* The 'sel' field MUST be the last field in structure to allow for
         * tc_u32_keys allocated at end of structure.
         */
@@ -425,21 +422,14 @@ static int u32_destroy_key(struct tcf_proto *tp, struct tc_u_knode *n,
  */
 static void u32_delete_key_work(struct work_struct *work)
 {
-       struct tc_u_knode *key = container_of(work, struct tc_u_knode, work);
-
+       struct tc_u_knode *key = container_of(to_rcu_work(work),
+                                             struct tc_u_knode,
+                                             rwork);
        rtnl_lock();
        u32_destroy_key(key->tp, key, false);
        rtnl_unlock();
 }
 
-static void u32_delete_key_rcu(struct rcu_head *rcu)
-{
-       struct tc_u_knode *key = container_of(rcu, struct tc_u_knode, rcu);
-
-       INIT_WORK(&key->work, u32_delete_key_work);
-       tcf_queue_work(&key->work);
-}
-
 /* u32_delete_key_freepf_rcu is the rcu callback variant
  * that free's the entire structure including the statistics
  * percpu variables. Only use this if the key is not a copy
@@ -449,21 +439,14 @@ static void u32_delete_key_rcu(struct rcu_head *rcu)
  */
 static void u32_delete_key_freepf_work(struct work_struct *work)
 {
-       struct tc_u_knode *key = container_of(work, struct tc_u_knode, work);
-
+       struct tc_u_knode *key = container_of(to_rcu_work(work),
+                                             struct tc_u_knode,
+                                             rwork);
        rtnl_lock();
        u32_destroy_key(key->tp, key, true);
        rtnl_unlock();
 }
 
-static void u32_delete_key_freepf_rcu(struct rcu_head *rcu)
-{
-       struct tc_u_knode *key = container_of(rcu, struct tc_u_knode, rcu);
-
-       INIT_WORK(&key->work, u32_delete_key_freepf_work);
-       tcf_queue_work(&key->work);
-}
-
 static int u32_delete_key(struct tcf_proto *tp, struct tc_u_knode *key)
 {
        struct tc_u_knode __rcu **kp;
@@ -480,7 +463,7 @@ static int u32_delete_key(struct tcf_proto *tp, struct tc_u_knode *key)
                                tcf_unbind_filter(tp, &key->res);
                                idr_remove(&ht->handle_idr, key->handle);
                                tcf_exts_get_net(&key->exts);
-                               call_rcu(&key->rcu, u32_delete_key_freepf_rcu);
+                               tcf_queue_work(&key->rwork, u32_delete_key_freepf_work);
                                return 0;
                        }
                }
@@ -596,7 +579,7 @@ static void u32_clear_hnode(struct tcf_proto *tp, struct tc_u_hnode *ht)
                        u32_remove_hw_knode(tp, n->handle);
                        idr_remove_ext(&ht->handle_idr, n->handle);
                        if (tcf_exts_get_net(&n->exts))
-                               call_rcu(&n->rcu, u32_delete_key_freepf_rcu);
+                               tcf_queue_work(&n->rwork, u32_delete_key_freepf_work);
                        else
                                u32_destroy_key(n->tp, n, true);
                }
@@ -959,7 +942,7 @@ static int u32_change(struct net *net, struct sk_buff *in_skb,
                u32_replace_knode(tp, tp_c, new);
                tcf_unbind_filter(tp, &n->res);
                tcf_exts_get_net(&n->exts);
-               call_rcu(&n->rcu, u32_delete_key_rcu);
+               tcf_queue_work(&n->rwork, u32_delete_key_work);
                return 0;
        }