net_sched: remove tc class reference counting

For TC classes, their ->get() and ->put() are always paired, and the
reference counting is completely useless, because:

1) For class modification and dumping paths, we already hold RTNL lock,
   so all of these ->get(),->change(),->put() are atomic.

2) For filter bindiing/unbinding, we use other reference counter than
   this one, and they should have RTNL lock too.

3) For ->qlen_notify(), it is special because it is called on ->enqueue()
   path, but we already hold qdisc tree lock there, and we hold this
   tree lock when graft or delete the class too, so it should not be gone
   or changed until we release the tree lock.

Therefore, this patch removes ->get() and ->put(), but:

1) Adds a new ->find() to find the pointer to a class by classid, no
   refcnt.

2) Move the original class destroy upon the last refcnt into ->delete(),
   right after releasing tree lock. This is fine because the class is
   already removed from hash when holding the lock.

For those who also use ->put() as ->unbind(), just rename them to reflect
this change.

Cc: Jamal Hadi Salim <jhs@mojatatu.com>
Signed-off-by: Cong Wang <xiyou.wangcong@gmail.com>
Acked-by: Jiri Pirko <jiri@mellanox.com>
Acked-by: Jamal Hadi Salim <jhs@mojatatu.com>
Signed-off-by: David S. Miller <davem@davemloft.net>

diff --git a/include/net/sch_generic.h b/include/net/sch_generic.h
index 1688f0f6c7ba9b4905682bbeb2417be8a79a98aa..d817585aa5df19d77377f2076deb419ff901b58e 100644 (file)
--- a/include/net/sch_generic.h
+++ b/include/net/sch_generic.h
@@ -147,8 +147,7 @@ struct Qdisc_class_ops {
        void                    (*qlen_notify)(struct Qdisc *, unsigned long);
 
        /* Class manipulation routines */
-       unsigned long           (*get)(struct Qdisc *, u32 classid);
-       void                    (*put)(struct Qdisc *, unsigned long);
+       unsigned long           (*find)(struct Qdisc *, u32 classid);
        int                     (*change)(struct Qdisc *, u32, u32,
                                        struct nlattr **, unsigned long *);
        int                     (*delete)(struct Qdisc *, unsigned long);

diff --git a/net/sched/cls_api.c b/net/sched/cls_api.c
index eef6b077f30ed69d2dc04bea61a851dc449cafee..d470a4e2de58f16afc534945a00a2c6c3284f300 100644 (file)
--- a/net/sched/cls_api.c
+++ b/net/sched/cls_api.c
@@ -586,7 +586,7 @@ replay:
 
        /* Do we search for filter, attached to class? */
        if (TC_H_MIN(parent)) {
-               cl = cops->get(q, parent);
+               cl = cops->find(q, parent);
                if (cl == 0)
                        return -ENOENT;
        }
@@ -716,8 +716,6 @@ replay:
 errout:
        if (chain)
                tcf_chain_put(chain);
-       if (cl)
-               cops->put(q, cl);
        if (err == -EAGAIN)
                /* Replay the request. */
                goto replay;
@@ -822,17 +820,17 @@ static int tc_dump_tfilter(struct sk_buff *skb, struct netlink_callback *cb)
                goto out;
        cops = q->ops->cl_ops;
        if (!cops)
-               goto errout;
+               goto out;
        if (!cops->tcf_block)
-               goto errout;
+               goto out;
        if (TC_H_MIN(tcm->tcm_parent)) {
-               cl = cops->get(q, tcm->tcm_parent);
+               cl = cops->find(q, tcm->tcm_parent);
                if (cl == 0)
-                       goto errout;
+                       goto out;
        }
        block = cops->tcf_block(q, cl);
        if (!block)
-               goto errout;
+               goto out;
 
        index_start = cb->args[0];
        index = 0;
@@ -847,9 +845,6 @@ static int tc_dump_tfilter(struct sk_buff *skb, struct netlink_callback *cb)
 
        cb->args[0] = index;
 
-errout:
-       if (cl)
-               cops->put(q, cl);
 out:
        return skb->len;
 }

diff --git a/net/sched/sch_api.c b/net/sched/sch_api.c
index 3ef4eb5787391629829c46207f01560b642e344c..e7f8e4bfd4ec35ca25acef2d927dc787615d081c 100644 (file)
--- a/net/sched/sch_api.c
+++ b/net/sched/sch_api.c
@@ -153,7 +153,7 @@ int register_qdisc(struct Qdisc_ops *qops)
        if (qops->cl_ops) {
                const struct Qdisc_class_ops *cops = qops->cl_ops;
 
-               if (!(cops->get && cops->put && cops->walk && cops->leaf))
+               if (!(cops->find && cops->walk && cops->leaf))
                        goto out_einval;
 
                if (cops->tcf_block && !(cops->bind_tcf && cops->unbind_tcf))
@@ -320,12 +320,11 @@ static struct Qdisc *qdisc_leaf(struct Qdisc *p, u32 classid)
 
        if (cops == NULL)
                return NULL;
-       cl = cops->get(p, classid);
+       cl = cops->find(p, classid);
 
        if (cl == 0)
                return NULL;
        leaf = cops->leaf(p, cl);
-       cops->put(p, cl);
        return leaf;
 }
 
@@ -756,9 +755,8 @@ void qdisc_tree_reduce_backlog(struct Qdisc *sch, unsigned int n,
                }
                cops = sch->ops->cl_ops;
                if (notify && cops->qlen_notify) {
-                       cl = cops->get(sch, parentid);
+                       cl = cops->find(sch, parentid);
                        cops->qlen_notify(sch, cl);
-                       cops->put(sch, cl);
                }
                sch->q.qlen -= n;
                sch->qstats.backlog -= len;
@@ -955,11 +953,11 @@ skip:
 
                err = -EOPNOTSUPP;
                if (cops && cops->graft) {
-                       unsigned long cl = cops->get(parent, classid);
-                       if (cl) {
+                       unsigned long cl = cops->find(parent, classid);
+
+                       if (cl)
                                err = cops->graft(parent, cl, new, &old);
-                               cops->put(parent, cl);
-                       } else
+                       else
                                err = -ENOENT;
                }
                if (!err)
@@ -1739,7 +1737,7 @@ static int tc_ctl_tclass(struct sk_buff *skb, struct nlmsghdr *n,
                clid = TC_H_MAKE(qid, clid);
 
        if (clid)
-               cl = cops->get(q, clid);
+               cl = cops->find(q, clid);
 
        if (cl == 0) {
                err = -ENOENT;
@@ -1773,9 +1771,6 @@ static int tc_ctl_tclass(struct sk_buff *skb, struct nlmsghdr *n,
                tclass_notify(net, skb, n, q, new_cl, RTM_NEWTCLASS);
 
 out:
-       if (cl)
-               cops->put(q, cl);
-
        return err;
 }
 

diff --git a/net/sched/sch_atm.c b/net/sched/sch_atm.c
index 2732950766a9e9daa6e00286f98ed814b78014ca..c5fcdf1a58a08824aef5b48c790a019e17134967 100644 (file)
--- a/net/sched/sch_atm.c
+++ b/net/sched/sch_atm.c
@@ -108,23 +108,29 @@ static struct Qdisc *atm_tc_leaf(struct Qdisc *sch, unsigned long cl)
        return flow ? flow->q : NULL;
 }
 
-static unsigned long atm_tc_get(struct Qdisc *sch, u32 classid)
+static unsigned long atm_tc_find(struct Qdisc *sch, u32 classid)
 {
        struct atm_qdisc_data *p __maybe_unused = qdisc_priv(sch);
        struct atm_flow_data *flow;
 
-       pr_debug("atm_tc_get(sch %p,[qdisc %p],classid %x)\n", sch, p, classid);
+       pr_debug("%s(sch %p,[qdisc %p],classid %x)\n", __func__, sch, p, classid);
        flow = lookup_flow(sch, classid);
-       if (flow)
-               flow->ref++;
-       pr_debug("atm_tc_get: flow %p\n", flow);
+       pr_debug("%s: flow %p\n", __func__, flow);
        return (unsigned long)flow;
 }
 
 static unsigned long atm_tc_bind_filter(struct Qdisc *sch,
                                        unsigned long parent, u32 classid)
 {
-       return atm_tc_get(sch, classid);
+       struct atm_qdisc_data *p __maybe_unused = qdisc_priv(sch);
+       struct atm_flow_data *flow;
+
+       pr_debug("%s(sch %p,[qdisc %p],classid %x)\n", __func__, sch, p, classid);
+       flow = lookup_flow(sch, classid);
+       if (flow)
+               flow->ref++;
+       pr_debug("%s: flow %p\n", __func__, flow);
+       return (unsigned long)flow;
 }
 
 /*
@@ -234,7 +240,7 @@ static int atm_tc_change(struct Qdisc *sch, u32 classid, u32 parent,
                excess = NULL;
        else {
                excess = (struct atm_flow_data *)
-                       atm_tc_get(sch, nla_get_u32(tb[TCA_ATM_EXCESS]));
+                       atm_tc_find(sch, nla_get_u32(tb[TCA_ATM_EXCESS]));
                if (!excess)
                        return -ENOENT;
        }
@@ -262,10 +268,9 @@ static int atm_tc_change(struct Qdisc *sch, u32 classid, u32 parent,
 
                for (i = 1; i < 0x8000; i++) {
                        classid = TC_H_MAKE(sch->handle, 0x8000 | i);
-                       cl = atm_tc_get(sch, classid);
+                       cl = atm_tc_find(sch, classid);
                        if (!cl)
                                break;
-                       atm_tc_put(sch, cl);
                }
        }
        pr_debug("atm_tc_change: new id %x\n", classid);
@@ -305,8 +310,6 @@ static int atm_tc_change(struct Qdisc *sch, u32 classid, u32 parent,
        *arg = (unsigned long)flow;
        return 0;
 err_out:
-       if (excess)
-               atm_tc_put(sch, (unsigned long)excess);
        sockfd_put(sock);
        return error;
 }
@@ -377,7 +380,7 @@ static int atm_tc_enqueue(struct sk_buff *skb, struct Qdisc *sch,
        result = TC_ACT_OK;     /* be nice to gcc */
        flow = NULL;
        if (TC_H_MAJ(skb->priority) != sch->handle ||
-           !(flow = (struct atm_flow_data *)atm_tc_get(sch, skb->priority))) {
+           !(flow = (struct atm_flow_data *)atm_tc_find(sch, skb->priority))) {
                struct tcf_proto *fl;
 
                list_for_each_entry(flow, &p->flows, list) {
@@ -655,8 +658,7 @@ static int atm_tc_dump(struct Qdisc *sch, struct sk_buff *skb)
 static const struct Qdisc_class_ops atm_class_ops = {
        .graft          = atm_tc_graft,
        .leaf           = atm_tc_leaf,
-       .get            = atm_tc_get,
-       .put            = atm_tc_put,
+       .find           = atm_tc_find,
        .change         = atm_tc_change,
        .delete         = atm_tc_delete,
        .walk           = atm_tc_walk,

diff --git a/net/sched/sch_cbq.c b/net/sched/sch_cbq.c
index 1bdb0106f34228553bc0a60a5a7e4c98af7579c1..3ec8bec109bbee2014c8b2204906bd123c12fd58 100644 (file)
--- a/net/sched/sch_cbq.c
+++ b/net/sched/sch_cbq.c
@@ -129,7 +129,6 @@ struct cbq_class {
        struct tcf_proto __rcu  *filter_list;
        struct tcf_block        *block;
 
-       int                     refcnt;
        int                     filters;
 
        struct cbq_class        *defaults[TC_PRIO_MAX + 1];
@@ -1155,7 +1154,6 @@ static int cbq_init(struct Qdisc *sch, struct nlattr *opt)
        if (err < 0)
                goto put_rtab;
 
-       q->link.refcnt = 1;
        q->link.sibling = &q->link;
        q->link.common.classid = sch->handle;
        q->link.qdisc = sch;
@@ -1388,16 +1386,11 @@ static void cbq_qlen_notify(struct Qdisc *sch, unsigned long arg)
        cbq_deactivate_class(cl);
 }
 
-static unsigned long cbq_get(struct Qdisc *sch, u32 classid)
+static unsigned long cbq_find(struct Qdisc *sch, u32 classid)
 {
        struct cbq_sched_data *q = qdisc_priv(sch);
-       struct cbq_class *cl = cbq_class_lookup(q, classid);
 
-       if (cl) {
-               cl->refcnt++;
-               return (unsigned long)cl;
-       }
-       return 0;
+       return (unsigned long)cbq_class_lookup(q, classid);
 }
 
 static void cbq_destroy_class(struct Qdisc *sch, struct cbq_class *cl)
@@ -1443,25 +1436,6 @@ static void cbq_destroy(struct Qdisc *sch)
        qdisc_class_hash_destroy(&q->clhash);
 }
 
-static void cbq_put(struct Qdisc *sch, unsigned long arg)
-{
-       struct cbq_class *cl = (struct cbq_class *)arg;
-
-       if (--cl->refcnt == 0) {
-#ifdef CONFIG_NET_CLS_ACT
-               spinlock_t *root_lock = qdisc_root_sleeping_lock(sch);
-               struct cbq_sched_data *q = qdisc_priv(sch);
-
-               spin_lock_bh(root_lock);
-               if (q->rx_class == cl)
-                       q->rx_class = NULL;
-               spin_unlock_bh(root_lock);
-#endif
-
-               cbq_destroy_class(sch, cl);
-       }
-}
-
 static int
 cbq_change_class(struct Qdisc *sch, u32 classid, u32 parentid, struct nlattr **tca,
                 unsigned long *arg)
@@ -1608,7 +1582,6 @@ cbq_change_class(struct Qdisc *sch, u32 classid, u32 parentid, struct nlattr **t
 
        cl->R_tab = rtab;
        rtab = NULL;
-       cl->refcnt = 1;
        cl->q = qdisc_create_dflt(sch->dev_queue, &pfifo_qdisc_ops, classid);
        if (!cl->q)
                cl->q = &noop_qdisc;
@@ -1689,12 +1662,7 @@ static int cbq_delete(struct Qdisc *sch, unsigned long arg)
        cbq_rmprio(q, cl);
        sch_tree_unlock(sch);
 
-       BUG_ON(--cl->refcnt == 0);
-       /*
-        * This shouldn't happen: we "hold" one cops->get() when called
-        * from tc_ctl_tclass; the destroy method is done from cops->put().
-        */
-
+       cbq_destroy_class(sch, cl);
        return 0;
 }
 
@@ -1760,8 +1728,7 @@ static const struct Qdisc_class_ops cbq_class_ops = {
        .graft          =       cbq_graft,
        .leaf           =       cbq_leaf,
        .qlen_notify    =       cbq_qlen_notify,
-       .get            =       cbq_get,
-       .put            =       cbq_put,
+       .find           =       cbq_find,
        .change         =       cbq_change_class,
        .delete         =       cbq_delete,
        .walk           =       cbq_walk,

diff --git a/net/sched/sch_drr.c b/net/sched/sch_drr.c
index 1d2f6235dfcf5a342aea1e006c870bd68ac90538..2d0e8d4bdc29b00d8d681e3cdeceac13420bf8bd 100644 (file)
--- a/net/sched/sch_drr.c
+++ b/net/sched/sch_drr.c
@@ -20,7 +20,6 @@
 
 struct drr_class {
        struct Qdisc_class_common       common;
-       unsigned int                    refcnt;
        unsigned int                    filter_cnt;
 
        struct gnet_stats_basic_packed          bstats;
@@ -111,7 +110,6 @@ static int drr_change_class(struct Qdisc *sch, u32 classid, u32 parentid,
        if (cl == NULL)
                return -ENOBUFS;
 
-       cl->refcnt         = 1;
        cl->common.classid = classid;
        cl->quantum        = quantum;
        cl->qdisc          = qdisc_create_dflt(sch->dev_queue,
@@ -163,32 +161,15 @@ static int drr_delete_class(struct Qdisc *sch, unsigned long arg)
        drr_purge_queue(cl);
        qdisc_class_hash_remove(&q->clhash, &cl->common);
 
-       BUG_ON(--cl->refcnt == 0);
-       /*
-        * This shouldn't happen: we "hold" one cops->get() when called
-        * from tc_ctl_tclass; the destroy method is done from cops->put().
-        */
-
        sch_tree_unlock(sch);
-       return 0;
-}
-
-static unsigned long drr_get_class(struct Qdisc *sch, u32 classid)
-{
-       struct drr_class *cl = drr_find_class(sch, classid);
 
-       if (cl != NULL)
-               cl->refcnt++;
-
-       return (unsigned long)cl;
+       drr_destroy_class(sch, cl);
+       return 0;
 }
 
-static void drr_put_class(struct Qdisc *sch, unsigned long arg)
+static unsigned long drr_search_class(struct Qdisc *sch, u32 classid)
 {
-       struct drr_class *cl = (struct drr_class *)arg;
-
-       if (--cl->refcnt == 0)
-               drr_destroy_class(sch, cl);
+       return (unsigned long)drr_find_class(sch, classid);
 }
 
 static struct tcf_block *drr_tcf_block(struct Qdisc *sch, unsigned long cl)
@@ -478,8 +459,7 @@ static void drr_destroy_qdisc(struct Qdisc *sch)
 static const struct Qdisc_class_ops drr_class_ops = {
        .change         = drr_change_class,
        .delete         = drr_delete_class,
-       .get            = drr_get_class,
-       .put            = drr_put_class,
+       .find           = drr_search_class,
        .tcf_block      = drr_tcf_block,
        .bind_tcf       = drr_bind_tcf,
        .unbind_tcf     = drr_unbind_tcf,

diff --git a/net/sched/sch_dsmark.c b/net/sched/sch_dsmark.c
index 6d94fcc3592a95b14d8758731f98641af64f64f0..2836c80c7aa517f0da3c5771a68fa58b625c936b 100644 (file)
--- a/net/sched/sch_dsmark.c
+++ b/net/sched/sch_dsmark.c
@@ -85,21 +85,21 @@ static struct Qdisc *dsmark_leaf(struct Qdisc *sch, unsigned long arg)
        return p->q;
 }
 
-static unsigned long dsmark_get(struct Qdisc *sch, u32 classid)
+static unsigned long dsmark_find(struct Qdisc *sch, u32 classid)
 {
-       pr_debug("%s(sch %p,[qdisc %p],classid %x)\n",
-                __func__, sch, qdisc_priv(sch), classid);
-
        return TC_H_MIN(classid) + 1;
 }
 
 static unsigned long dsmark_bind_filter(struct Qdisc *sch,
                                        unsigned long parent, u32 classid)
 {
-       return dsmark_get(sch, classid);
+       pr_debug("%s(sch %p,[qdisc %p],classid %x)\n",
+                __func__, sch, qdisc_priv(sch), classid);
+
+       return dsmark_find(sch, classid);
 }
 
-static void dsmark_put(struct Qdisc *sch, unsigned long cl)
+static void dsmark_unbind_filter(struct Qdisc *sch, unsigned long cl)
 {
 }
 
@@ -469,14 +469,13 @@ nla_put_failure:
 static const struct Qdisc_class_ops dsmark_class_ops = {
        .graft          =       dsmark_graft,
        .leaf           =       dsmark_leaf,
-       .get            =       dsmark_get,
-       .put            =       dsmark_put,
+       .find           =       dsmark_find,
        .change         =       dsmark_change,
        .delete         =       dsmark_delete,
        .walk           =       dsmark_walk,
        .tcf_block      =       dsmark_tcf_block,
        .bind_tcf       =       dsmark_bind_filter,
-       .unbind_tcf     =       dsmark_put,
+       .unbind_tcf     =       dsmark_unbind_filter,
        .dump           =       dsmark_dump_class,
 };
 

diff --git a/net/sched/sch_fq_codel.c b/net/sched/sch_fq_codel.c
index 337f2d6d81e42e278b63443d904955e2c6692f03..7699b50688cd6f2eec4d86d15f3559876e522f49 100644 (file)
--- a/net/sched/sch_fq_codel.c
+++ b/net/sched/sch_fq_codel.c
@@ -579,7 +579,7 @@ static struct Qdisc *fq_codel_leaf(struct Qdisc *sch, unsigned long arg)
        return NULL;
 }
 
-static unsigned long fq_codel_get(struct Qdisc *sch, u32 classid)
+static unsigned long fq_codel_find(struct Qdisc *sch, u32 classid)
 {
        return 0;
 }
@@ -592,7 +592,7 @@ static unsigned long fq_codel_bind(struct Qdisc *sch, unsigned long parent,
        return 0;
 }
 
-static void fq_codel_put(struct Qdisc *q, unsigned long cl)
+static void fq_codel_unbind(struct Qdisc *q, unsigned long cl)
 {
 }
 
@@ -683,11 +683,10 @@ static void fq_codel_walk(struct Qdisc *sch, struct qdisc_walker *arg)
 
 static const struct Qdisc_class_ops fq_codel_class_ops = {
        .leaf           =       fq_codel_leaf,
-       .get            =       fq_codel_get,
-       .put            =       fq_codel_put,
+       .find           =       fq_codel_find,
        .tcf_block      =       fq_codel_tcf_block,
        .bind_tcf       =       fq_codel_bind,
-       .unbind_tcf     =       fq_codel_put,
+       .unbind_tcf     =       fq_codel_unbind,
        .dump           =       fq_codel_dump_class,
        .dump_stats     =       fq_codel_dump_class_stats,
        .walk           =       fq_codel_walk,

diff --git a/net/sched/sch_hfsc.c b/net/sched/sch_hfsc.c
index 15f09cb9f1ffccc2dca8fb6b12f21a3ac5bd6f24..7c7820d0fdc7afbf5e38c6845b09de88515d7551 100644 (file)
--- a/net/sched/sch_hfsc.c
+++ b/net/sched/sch_hfsc.c
@@ -110,7 +110,6 @@ enum hfsc_class_flags {
 
 struct hfsc_class {
        struct Qdisc_class_common cl_common;
-       unsigned int    refcnt;         /* usage count */
 
        struct gnet_stats_basic_packed bstats;
        struct gnet_stats_queue qstats;
@@ -1045,7 +1044,6 @@ hfsc_change_class(struct Qdisc *sch, u32 classid, u32 parentid,
                hfsc_change_usc(cl, usc, 0);
 
        cl->cl_common.classid = classid;
-       cl->refcnt    = 1;
        cl->sched     = q;
        cl->cl_parent = parent;
        cl->qdisc = qdisc_create_dflt(sch->dev_queue,
@@ -1101,13 +1099,9 @@ hfsc_delete_class(struct Qdisc *sch, unsigned long arg)
        hfsc_purge_queue(sch, cl);
        qdisc_class_hash_remove(&q->clhash, &cl->cl_common);
 
-       BUG_ON(--cl->refcnt == 0);
-       /*
-        * This shouldn't happen: we "hold" one cops->get() when called
-        * from tc_ctl_tclass; the destroy method is done from cops->put().
-        */
-
        sch_tree_unlock(sch);
+
+       hfsc_destroy_class(sch, cl);
        return 0;
 }
 
@@ -1208,23 +1202,9 @@ hfsc_qlen_notify(struct Qdisc *sch, unsigned long arg)
 }
 
 static unsigned long
-hfsc_get_class(struct Qdisc *sch, u32 classid)
-{
-       struct hfsc_class *cl = hfsc_find_class(classid, sch);
-
-       if (cl != NULL)
-               cl->refcnt++;
-
-       return (unsigned long)cl;
-}
-
-static void
-hfsc_put_class(struct Qdisc *sch, unsigned long arg)
+hfsc_search_class(struct Qdisc *sch, u32 classid)
 {
-       struct hfsc_class *cl = (struct hfsc_class *)arg;
-
-       if (--cl->refcnt == 0)
-               hfsc_destroy_class(sch, cl);
+       return (unsigned long)hfsc_find_class(classid, sch);
 }
 
 static unsigned long
@@ -1413,7 +1393,6 @@ hfsc_init_qdisc(struct Qdisc *sch, struct nlattr *opt)
                goto err_tcf;
 
        q->root.cl_common.classid = sch->handle;
-       q->root.refcnt  = 1;
        q->root.sched   = q;
        q->root.qdisc = qdisc_create_dflt(sch->dev_queue, &pfifo_qdisc_ops,
                                          sch->handle);
@@ -1661,8 +1640,7 @@ static const struct Qdisc_class_ops hfsc_class_ops = {
        .graft          = hfsc_graft_class,
        .leaf           = hfsc_class_leaf,
        .qlen_notify    = hfsc_qlen_notify,
-       .get            = hfsc_get_class,
-       .put            = hfsc_put_class,
+       .find           = hfsc_search_class,
        .bind_tcf       = hfsc_bind_tcf,
        .unbind_tcf     = hfsc_unbind_tcf,
        .tcf_block      = hfsc_tcf_block,

diff --git a/net/sched/sch_htb.c b/net/sched/sch_htb.c
index dcf3c85e1f4fad55b945e98089cc68bad17f0fa8..f955b59d3c7c4b3a1a765e0c1f2ec669c0bca247 100644 (file)
--- a/net/sched/sch_htb.c
+++ b/net/sched/sch_htb.c
@@ -107,7 +107,6 @@ struct htb_class {
        struct tcf_proto __rcu  *filter_list;   /* class attached filters */
        struct tcf_block        *block;
        int                     filter_cnt;
-       int                     refcnt;         /* usage count of this class */
 
        int                     level;          /* our level (see above) */
        unsigned int            children;
@@ -193,6 +192,10 @@ static inline struct htb_class *htb_find(u32 handle, struct Qdisc *sch)
        return container_of(clc, struct htb_class, common);
 }
 
+static unsigned long htb_search(struct Qdisc *sch, u32 handle)
+{
+       return (unsigned long)htb_find(handle, sch);
+}
 /**
  * htb_classify - classify a packet into class
  *
@@ -1189,14 +1192,6 @@ static void htb_qlen_notify(struct Qdisc *sch, unsigned long arg)
        htb_deactivate(qdisc_priv(sch), cl);
 }
 
-static unsigned long htb_get(struct Qdisc *sch, u32 classid)
-{
-       struct htb_class *cl = htb_find(classid, sch);
-       if (cl)
-               cl->refcnt++;
-       return (unsigned long)cl;
-}
-
 static inline int htb_parent_last_child(struct htb_class *cl)
 {
        if (!cl->parent)
@@ -1316,22 +1311,10 @@ static int htb_delete(struct Qdisc *sch, unsigned long arg)
        if (last_child)
                htb_parent_to_leaf(q, cl, new_q);
 
-       BUG_ON(--cl->refcnt == 0);
-       /*
-        * This shouldn't happen: we "hold" one cops->get() when called
-        * from tc_ctl_tclass; the destroy method is done from cops->put().
-        */
-
        sch_tree_unlock(sch);
-       return 0;
-}
 
-static void htb_put(struct Qdisc *sch, unsigned long arg)
-{
-       struct htb_class *cl = (struct htb_class *)arg;
-
-       if (--cl->refcnt == 0)
-               htb_destroy_class(sch, cl);
+       htb_destroy_class(sch, cl);
+       return 0;
 }
 
 static int htb_change_class(struct Qdisc *sch, u32 classid,
@@ -1422,7 +1405,6 @@ static int htb_change_class(struct Qdisc *sch, u32 classid,
                        }
                }
 
-               cl->refcnt = 1;
                cl->children = 0;
                INIT_LIST_HEAD(&cl->un.leaf.drop_list);
                RB_CLEAR_NODE(&cl->pq_node);
@@ -1598,8 +1580,7 @@ static const struct Qdisc_class_ops htb_class_ops = {
        .graft          =       htb_graft,
        .leaf           =       htb_leaf,
        .qlen_notify    =       htb_qlen_notify,
-       .get            =       htb_get,
-       .put            =       htb_put,
+       .find           =       htb_search,
        .change         =       htb_change_class,
        .delete         =       htb_delete,
        .walk           =       htb_walk,

diff --git a/net/sched/sch_ingress.c b/net/sched/sch_ingress.c
index a15c543c35697c0717f95358a280c7178003fae0..44de4ee51ce9fe963cc722cbad25d7b9af21a5ee 100644 (file)
--- a/net/sched/sch_ingress.c
+++ b/net/sched/sch_ingress.c
@@ -27,7 +27,7 @@ static struct Qdisc *ingress_leaf(struct Qdisc *sch, unsigned long arg)
        return NULL;
 }
 
-static unsigned long ingress_get(struct Qdisc *sch, u32 classid)
+static unsigned long ingress_find(struct Qdisc *sch, u32 classid)
 {
        return TC_H_MIN(classid) + 1;
 }
@@ -35,10 +35,10 @@ static unsigned long ingress_get(struct Qdisc *sch, u32 classid)
 static unsigned long ingress_bind_filter(struct Qdisc *sch,
                                         unsigned long parent, u32 classid)
 {
-       return ingress_get(sch, classid);
+       return ingress_find(sch, classid);
 }
 
-static void ingress_put(struct Qdisc *sch, unsigned long cl)
+static void ingress_unbind_filter(struct Qdisc *sch, unsigned long cl)
 {
 }
 
@@ -94,12 +94,11 @@ nla_put_failure:
 
 static const struct Qdisc_class_ops ingress_class_ops = {
        .leaf           =       ingress_leaf,
-       .get            =       ingress_get,
-       .put            =       ingress_put,
+       .find           =       ingress_find,
        .walk           =       ingress_walk,
        .tcf_block      =       ingress_tcf_block,
        .bind_tcf       =       ingress_bind_filter,
-       .unbind_tcf     =       ingress_put,
+       .unbind_tcf     =       ingress_unbind_filter,
 };
 
 static struct Qdisc_ops ingress_qdisc_ops __read_mostly = {
@@ -117,7 +116,7 @@ struct clsact_sched_data {
        struct tcf_block *egress_block;
 };
 
-static unsigned long clsact_get(struct Qdisc *sch, u32 classid)
+static unsigned long clsact_find(struct Qdisc *sch, u32 classid)
 {
        switch (TC_H_MIN(classid)) {
        case TC_H_MIN(TC_H_MIN_INGRESS):
@@ -131,7 +130,7 @@ static unsigned long clsact_get(struct Qdisc *sch, u32 classid)
 static unsigned long clsact_bind_filter(struct Qdisc *sch,
                                        unsigned long parent, u32 classid)
 {
-       return clsact_get(sch, classid);
+       return clsact_find(sch, classid);
 }
 
 static struct tcf_block *clsact_tcf_block(struct Qdisc *sch, unsigned long cl)
@@ -183,12 +182,11 @@ static void clsact_destroy(struct Qdisc *sch)
 
 static const struct Qdisc_class_ops clsact_class_ops = {
        .leaf           =       ingress_leaf,
-       .get            =       clsact_get,
-       .put            =       ingress_put,
+       .find           =       clsact_find,
        .walk           =       ingress_walk,
        .tcf_block      =       clsact_tcf_block,
        .bind_tcf       =       clsact_bind_filter,
-       .unbind_tcf     =       ingress_put,
+       .unbind_tcf     =       ingress_unbind_filter,
 };
 
 static struct Qdisc_ops clsact_qdisc_ops __read_mostly = {

diff --git a/net/sched/sch_mq.c b/net/sched/sch_mq.c
index cadfdd4f1e521b3d68b8fa62d5797f3ff604651d..f3a3e507422bff4eabda205b9d2f8deea82b1b8e 100644 (file)
--- a/net/sched/sch_mq.c
+++ b/net/sched/sch_mq.c
@@ -165,7 +165,7 @@ static struct Qdisc *mq_leaf(struct Qdisc *sch, unsigned long cl)
        return dev_queue->qdisc_sleeping;
 }
 
-static unsigned long mq_get(struct Qdisc *sch, u32 classid)
+static unsigned long mq_find(struct Qdisc *sch, u32 classid)
 {
        unsigned int ntx = TC_H_MIN(classid);
 
@@ -174,10 +174,6 @@ static unsigned long mq_get(struct Qdisc *sch, u32 classid)
        return ntx;
 }
 
-static void mq_put(struct Qdisc *sch, unsigned long cl)
-{
-}
-
 static int mq_dump_class(struct Qdisc *sch, unsigned long cl,
                         struct sk_buff *skb, struct tcmsg *tcm)
 {
@@ -223,8 +219,7 @@ static const struct Qdisc_class_ops mq_class_ops = {
        .select_queue   = mq_select_queue,
        .graft          = mq_graft,
        .leaf           = mq_leaf,
-       .get            = mq_get,
-       .put            = mq_put,
+       .find           = mq_find,
        .walk           = mq_walk,
        .dump           = mq_dump_class,
        .dump_stats     = mq_dump_class_stats,

diff --git a/net/sched/sch_mqprio.c b/net/sched/sch_mqprio.c
index 2165a05994b7b5496b3ce2de045d6e5a128ead58..6bcdfe6e7b63a39e1c697043375fc3c4995a4a50 100644 (file)
--- a/net/sched/sch_mqprio.c
+++ b/net/sched/sch_mqprio.c
@@ -277,7 +277,7 @@ static struct Qdisc *mqprio_leaf(struct Qdisc *sch, unsigned long cl)
        return dev_queue->qdisc_sleeping;
 }
 
-static unsigned long mqprio_get(struct Qdisc *sch, u32 classid)
+static unsigned long mqprio_find(struct Qdisc *sch, u32 classid)
 {
        struct net_device *dev = qdisc_dev(sch);
        unsigned int ntx = TC_H_MIN(classid);
@@ -287,10 +287,6 @@ static unsigned long mqprio_get(struct Qdisc *sch, u32 classid)
        return ntx;
 }
 
-static void mqprio_put(struct Qdisc *sch, unsigned long cl)
-{
-}
-
 static int mqprio_dump_class(struct Qdisc *sch, unsigned long cl,
                         struct sk_buff *skb, struct tcmsg *tcm)
 {
@@ -403,8 +399,7 @@ static void mqprio_walk(struct Qdisc *sch, struct qdisc_walker *arg)
 static const struct Qdisc_class_ops mqprio_class_ops = {
        .graft          = mqprio_graft,
        .leaf           = mqprio_leaf,
-       .get            = mqprio_get,
-       .put            = mqprio_put,
+       .find           = mqprio_find,
        .walk           = mqprio_walk,
        .dump           = mqprio_dump_class,
        .dump_stats     = mqprio_dump_class_stats,

diff --git a/net/sched/sch_multiq.c b/net/sched/sch_multiq.c
index f143b7bbaa0d5b00d01d36e9f6eefb54bf677e8f..a5df979b624811e78ce07f228832face6f2c13b8 100644 (file)
--- a/net/sched/sch_multiq.c
+++ b/net/sched/sch_multiq.c
@@ -306,7 +306,7 @@ multiq_leaf(struct Qdisc *sch, unsigned long arg)
        return q->queues[band];
 }
 
-static unsigned long multiq_get(struct Qdisc *sch, u32 classid)
+static unsigned long multiq_find(struct Qdisc *sch, u32 classid)
 {
        struct multiq_sched_data *q = qdisc_priv(sch);
        unsigned long band = TC_H_MIN(classid);
@@ -319,11 +319,11 @@ static unsigned long multiq_get(struct Qdisc *sch, u32 classid)
 static unsigned long multiq_bind(struct Qdisc *sch, unsigned long parent,
                                 u32 classid)
 {
-       return multiq_get(sch, classid);
+       return multiq_find(sch, classid);
 }
 
 
-static void multiq_put(struct Qdisc *q, unsigned long cl)
+static void multiq_unbind(struct Qdisc *q, unsigned long cl)
 {
 }
 
@@ -385,12 +385,11 @@ static struct tcf_block *multiq_tcf_block(struct Qdisc *sch, unsigned long cl)
 static const struct Qdisc_class_ops multiq_class_ops = {
        .graft          =       multiq_graft,
        .leaf           =       multiq_leaf,
-       .get            =       multiq_get,
-       .put            =       multiq_put,
+       .find           =       multiq_find,
        .walk           =       multiq_walk,
        .tcf_block      =       multiq_tcf_block,
        .bind_tcf       =       multiq_bind,
-       .unbind_tcf     =       multiq_put,
+       .unbind_tcf     =       multiq_unbind,
        .dump           =       multiq_dump_class,
        .dump_stats     =       multiq_dump_class_stats,
 };

diff --git a/net/sched/sch_netem.c b/net/sched/sch_netem.c
index 1b3dd6190e9386c6f8104153eb9fdc0255e03ac5..cf5aad0aabfcc5ed7ea28402e25b3ee1a5c027b5 100644 (file)
--- a/net/sched/sch_netem.c
+++ b/net/sched/sch_netem.c
@@ -1096,15 +1096,11 @@ static struct Qdisc *netem_leaf(struct Qdisc *sch, unsigned long arg)
        return q->qdisc;
 }
 
-static unsigned long netem_get(struct Qdisc *sch, u32 classid)
+static unsigned long netem_find(struct Qdisc *sch, u32 classid)
 {
        return 1;
 }
 
-static void netem_put(struct Qdisc *sch, unsigned long arg)
-{
-}
-
 static void netem_walk(struct Qdisc *sch, struct qdisc_walker *walker)
 {
        if (!walker->stop) {
@@ -1120,8 +1116,7 @@ static void netem_walk(struct Qdisc *sch, struct qdisc_walker *walker)
 static const struct Qdisc_class_ops netem_class_ops = {
        .graft          =       netem_graft,
        .leaf           =       netem_leaf,
-       .get            =       netem_get,
-       .put            =       netem_put,
+       .find           =       netem_find,
        .walk           =       netem_walk,
        .dump           =       netem_dump_class,
 };

diff --git a/net/sched/sch_prio.c b/net/sched/sch_prio.c
index e3e364cc9a70400be95439ca9c808acc410595af..f31b28f788c008c570a194501227f628bc15643d 100644 (file)
--- a/net/sched/sch_prio.c
+++ b/net/sched/sch_prio.c
@@ -260,7 +260,7 @@ prio_leaf(struct Qdisc *sch, unsigned long arg)
        return q->queues[band];
 }
 
-static unsigned long prio_get(struct Qdisc *sch, u32 classid)
+static unsigned long prio_find(struct Qdisc *sch, u32 classid)
 {
        struct prio_sched_data *q = qdisc_priv(sch);
        unsigned long band = TC_H_MIN(classid);
@@ -272,11 +272,11 @@ static unsigned long prio_get(struct Qdisc *sch, u32 classid)
 
 static unsigned long prio_bind(struct Qdisc *sch, unsigned long parent, u32 classid)
 {
-       return prio_get(sch, classid);
+       return prio_find(sch, classid);
 }
 
 
-static void prio_put(struct Qdisc *q, unsigned long cl)
+static void prio_unbind(struct Qdisc *q, unsigned long cl)
 {
 }
 
@@ -338,12 +338,11 @@ static struct tcf_block *prio_tcf_block(struct Qdisc *sch, unsigned long cl)
 static const struct Qdisc_class_ops prio_class_ops = {
        .graft          =       prio_graft,
        .leaf           =       prio_leaf,
-       .get            =       prio_get,
-       .put            =       prio_put,
+       .find           =       prio_find,
        .walk           =       prio_walk,
        .tcf_block      =       prio_tcf_block,
        .bind_tcf       =       prio_bind,
-       .unbind_tcf     =       prio_put,
+       .unbind_tcf     =       prio_unbind,
        .dump           =       prio_dump_class,
        .dump_stats     =       prio_dump_class_stats,
 };

diff --git a/net/sched/sch_qfq.c b/net/sched/sch_qfq.c
index 9caa959f91e1d7dffd64927cd60ca96bd03705e0..cd661a7f81e6db4252f1b3a9b4da4adae2728248 100644 (file)
--- a/net/sched/sch_qfq.c
+++ b/net/sched/sch_qfq.c
@@ -132,7 +132,6 @@ struct qfq_aggregate;
 struct qfq_class {
        struct Qdisc_class_common common;
 
-       unsigned int refcnt;
        unsigned int filter_cnt;
 
        struct gnet_stats_basic_packed bstats;
@@ -477,7 +476,6 @@ static int qfq_change_class(struct Qdisc *sch, u32 classid, u32 parentid,
        if (cl == NULL)
                return -ENOBUFS;
 
-       cl->refcnt = 1;
        cl->common.classid = classid;
        cl->deficit = lmax;
 
@@ -555,32 +553,15 @@ static int qfq_delete_class(struct Qdisc *sch, unsigned long arg)
        qfq_purge_queue(cl);
        qdisc_class_hash_remove(&q->clhash, &cl->common);
 
-       BUG_ON(--cl->refcnt == 0);
-       /*
-        * This shouldn't happen: we "hold" one cops->get() when called
-        * from tc_ctl_tclass; the destroy method is done from cops->put().
-        */
-
        sch_tree_unlock(sch);
-       return 0;
-}
-
-static unsigned long qfq_get_class(struct Qdisc *sch, u32 classid)
-{
-       struct qfq_class *cl = qfq_find_class(sch, classid);
-
-       if (cl != NULL)
-               cl->refcnt++;
 
-       return (unsigned long)cl;
+       qfq_destroy_class(sch, cl);
+       return 0;
 }
 
-static void qfq_put_class(struct Qdisc *sch, unsigned long arg)
+static unsigned long qfq_search_class(struct Qdisc *sch, u32 classid)
 {
-       struct qfq_class *cl = (struct qfq_class *)arg;
-
-       if (--cl->refcnt == 0)
-               qfq_destroy_class(sch, cl);
+       return (unsigned long)qfq_find_class(sch, classid);
 }
 
 static struct tcf_block *qfq_tcf_block(struct Qdisc *sch, unsigned long cl)
@@ -1510,8 +1491,7 @@ static void qfq_destroy_qdisc(struct Qdisc *sch)
 static const struct Qdisc_class_ops qfq_class_ops = {
        .change         = qfq_change_class,
        .delete         = qfq_delete_class,
-       .get            = qfq_get_class,
-       .put            = qfq_put_class,
+       .find           = qfq_search_class,
        .tcf_block      = qfq_tcf_block,
        .bind_tcf       = qfq_bind_tcf,
        .unbind_tcf     = qfq_unbind_tcf,

diff --git a/net/sched/sch_red.c b/net/sched/sch_red.c
index 11292adce4121022a86aff0aed537be3d9319490..93b9d70a9b28f8ae423f63a57b345ab5da047b6a 100644 (file)
--- a/net/sched/sch_red.c
+++ b/net/sched/sch_red.c
@@ -311,15 +311,11 @@ static struct Qdisc *red_leaf(struct Qdisc *sch, unsigned long arg)
        return q->qdisc;
 }
 
-static unsigned long red_get(struct Qdisc *sch, u32 classid)
+static unsigned long red_find(struct Qdisc *sch, u32 classid)
 {
        return 1;
 }
 
-static void red_put(struct Qdisc *sch, unsigned long arg)
-{
-}
-
 static void red_walk(struct Qdisc *sch, struct qdisc_walker *walker)
 {
        if (!walker->stop) {
@@ -335,8 +331,7 @@ static void red_walk(struct Qdisc *sch, struct qdisc_walker *walker)
 static const struct Qdisc_class_ops red_class_ops = {
        .graft          =       red_graft,
        .leaf           =       red_leaf,
-       .get            =       red_get,
-       .put            =       red_put,
+       .find           =       red_find,
        .walk           =       red_walk,
        .dump           =       red_dump_class,
 };

diff --git a/net/sched/sch_sfb.c b/net/sched/sch_sfb.c
index 11fb6ec878d6c1179afb0b4e9fa6adaecd0bdf30..cc39e170b4aa2593177cd9364465a5bffa49839d 100644 (file)
--- a/net/sched/sch_sfb.c
+++ b/net/sched/sch_sfb.c
@@ -632,12 +632,12 @@ static struct Qdisc *sfb_leaf(struct Qdisc *sch, unsigned long arg)
        return q->qdisc;
 }
 
-static unsigned long sfb_get(struct Qdisc *sch, u32 classid)
+static unsigned long sfb_find(struct Qdisc *sch, u32 classid)
 {
        return 1;
 }
 
-static void sfb_put(struct Qdisc *sch, unsigned long arg)
+static void sfb_unbind(struct Qdisc *sch, unsigned long arg)
 {
 }
 
@@ -683,14 +683,13 @@ static unsigned long sfb_bind(struct Qdisc *sch, unsigned long parent,
 static const struct Qdisc_class_ops sfb_class_ops = {
        .graft          =       sfb_graft,
        .leaf           =       sfb_leaf,
-       .get            =       sfb_get,
-       .put            =       sfb_put,
+       .find           =       sfb_find,
        .change         =       sfb_change_class,
        .delete         =       sfb_delete,
        .walk           =       sfb_walk,
        .tcf_block      =       sfb_tcf_block,
        .bind_tcf       =       sfb_bind,
-       .unbind_tcf     =       sfb_put,
+       .unbind_tcf     =       sfb_unbind,
        .dump           =       sfb_dump_class,
 };
 

diff --git a/net/sched/sch_sfq.c b/net/sched/sch_sfq.c
index 82469ef9655eb65431477215bb2df0fb2737f905..b46e0121dd1ac7cda3d330f997efdda3793be82e 100644 (file)
--- a/net/sched/sch_sfq.c
+++ b/net/sched/sch_sfq.c
@@ -808,7 +808,7 @@ static struct Qdisc *sfq_leaf(struct Qdisc *sch, unsigned long arg)
        return NULL;
 }
 
-static unsigned long sfq_get(struct Qdisc *sch, u32 classid)
+static unsigned long sfq_find(struct Qdisc *sch, u32 classid)
 {
        return 0;
 }
@@ -821,7 +821,7 @@ static unsigned long sfq_bind(struct Qdisc *sch, unsigned long parent,
        return 0;
 }
 
-static void sfq_put(struct Qdisc *q, unsigned long cl)
+static void sfq_unbind(struct Qdisc *q, unsigned long cl)
 {
 }
 
@@ -885,11 +885,10 @@ static void sfq_walk(struct Qdisc *sch, struct qdisc_walker *arg)
 
 static const struct Qdisc_class_ops sfq_class_ops = {
        .leaf           =       sfq_leaf,
-       .get            =       sfq_get,
-       .put            =       sfq_put,
+       .find           =       sfq_find,
        .tcf_block      =       sfq_tcf_block,
        .bind_tcf       =       sfq_bind,
-       .unbind_tcf     =       sfq_put,
+       .unbind_tcf     =       sfq_unbind,
        .dump           =       sfq_dump_class,
        .dump_stats     =       sfq_dump_class_stats,
        .walk           =       sfq_walk,

diff --git a/net/sched/sch_tbf.c b/net/sched/sch_tbf.c
index b2e4b6ad241a8e538c654ef4e8417ab756740a45..d5dba972ab06842da7a72cf0359dbed5af4dc3ab 100644 (file)
--- a/net/sched/sch_tbf.c
+++ b/net/sched/sch_tbf.c
@@ -510,15 +510,11 @@ static struct Qdisc *tbf_leaf(struct Qdisc *sch, unsigned long arg)
        return q->qdisc;
 }
 
-static unsigned long tbf_get(struct Qdisc *sch, u32 classid)
+static unsigned long tbf_find(struct Qdisc *sch, u32 classid)
 {
        return 1;
 }
 
-static void tbf_put(struct Qdisc *sch, unsigned long arg)
-{
-}
-
 static void tbf_walk(struct Qdisc *sch, struct qdisc_walker *walker)
 {
        if (!walker->stop) {
@@ -534,8 +530,7 @@ static void tbf_walk(struct Qdisc *sch, struct qdisc_walker *walker)
 static const struct Qdisc_class_ops tbf_class_ops = {
        .graft          =       tbf_graft,
        .leaf           =       tbf_leaf,
-       .get            =       tbf_get,
-       .put            =       tbf_put,
+       .find           =       tbf_find,
        .walk           =       tbf_walk,
        .dump           =       tbf_dump_class,
 };