Commit 86df4d2e authored by David S. Miller's avatar David S. Miller
Browse files

Merge branch 'net_sched-clean-up-tc-classes-and-u32-filter' 



Cong Wang says:

====================
net_sched: clean up tc classes and u32 filter

Patch 1 and patch 2 prepare for patch 3. Major changes
are in patch 3 and patch 4, details are there too.

v2: Add patch 1 and 2, group all into a patchset
    Fix a coding style issue in patch 4
====================

Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parents 7d8697af 3cd904ec

include/net/sch_generic.h

+1 −3
Original line number Diff line number Diff line
@@ -75,7 +75,6 @@ struct Qdisc { 
	struct hlist_node       hash;

	u32			handle;

	u32			parent;

	void			*u32_node;



	struct netdev_queue	*dev_queue;
@@ -147,8 +146,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);

net/sched/cls_api.c

+6 −11
Original line number Diff line number Diff line
@@ -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;

}

net/sched/cls_u32.c

+53 −4
Original line number Diff line number Diff line
@@ -40,6 +40,8 @@ 
#include <linux/rtnetlink.h>

#include <linux/skbuff.h>

#include <linux/bitmap.h>

#include <linux/netdevice.h>

#include <linux/hash.h>

#include <net/netlink.h>

#include <net/act_api.h>

#include <net/pkt_cls.h>
@@ -92,6 +94,7 @@ struct tc_u_common { 
	struct Qdisc		*q;

	int			refcnt;

	u32			hgenerator;

	struct hlist_node	hnode;

	struct rcu_head		rcu;

};
@@ -323,12 +326,40 @@ static u32 gen_new_htid(struct tc_u_common *tp_c) 
	return i > 0 ? (tp_c->hgenerator|0x800)<<20 : 0;

}



static struct hlist_head *tc_u_common_hash;



#define U32_HASH_SHIFT 10

#define U32_HASH_SIZE (1 << U32_HASH_SHIFT)



static unsigned int tc_u_hash(const struct tcf_proto *tp)

{

	struct net_device *dev = tp->q->dev_queue->dev;

	u32 qhandle = tp->q->handle;

	int ifindex = dev->ifindex;



	return hash_64((u64)ifindex << 32 | qhandle, U32_HASH_SHIFT);

}



static struct tc_u_common *tc_u_common_find(const struct tcf_proto *tp)

{

	struct tc_u_common *tc;

	unsigned int h;



	h = tc_u_hash(tp);

	hlist_for_each_entry(tc, &tc_u_common_hash[h], hnode) {

		if (tc->q == tp->q)

			return tc;

	}

	return NULL;

}



static int u32_init(struct tcf_proto *tp)

{

	struct tc_u_hnode *root_ht;

	struct tc_u_common *tp_c;

	unsigned int h;



	tp_c = tp->q->u32_node;

	tp_c = tc_u_common_find(tp);



	root_ht = kzalloc(sizeof(*root_ht), GFP_KERNEL);

	if (root_ht == NULL)
@@ -345,7 +376,10 @@ static int u32_init(struct tcf_proto *tp) 
			return -ENOBUFS;

		}

		tp_c->q = tp->q;

		tp->q->u32_node = tp_c;

		INIT_HLIST_NODE(&tp_c->hnode);



		h = tc_u_hash(tp);

		hlist_add_head(&tp_c->hnode, &tc_u_common_hash[h]);

	}



	tp_c->refcnt++;
@@ -585,7 +619,7 @@ static void u32_destroy(struct tcf_proto *tp) 
	if (--tp_c->refcnt == 0) {

		struct tc_u_hnode *ht;



		tp->q->u32_node = NULL;

		hlist_del(&tp_c->hnode);



		for (ht = rtnl_dereference(tp_c->hlist);

		     ht;
@@ -1213,6 +1247,8 @@ static struct tcf_proto_ops cls_u32_ops __read_mostly = { 


static int __init init_u32(void)

{

	int i, ret;



	pr_info("u32 classifier\n");

#ifdef CONFIG_CLS_U32_PERF

	pr_info("    Performance counters on\n");
@@ -1223,12 +1259,25 @@ static int __init init_u32(void) 
#ifdef CONFIG_NET_CLS_ACT

	pr_info("    Actions configured\n");

#endif

	return register_tcf_proto_ops(&cls_u32_ops);

	tc_u_common_hash = kvmalloc_array(U32_HASH_SIZE,

					  sizeof(struct hlist_head),

					  GFP_KERNEL);

	if (!tc_u_common_hash)

		return -ENOMEM;



	for (i = 0; i < U32_HASH_SIZE; i++)

		INIT_HLIST_HEAD(&tc_u_common_hash[i]);



	ret = register_tcf_proto_ops(&cls_u32_ops);

	if (ret)

		kvfree(tc_u_common_hash);

	return ret;

}



static void __exit exit_u32(void)

{

	unregister_tcf_proto_ops(&cls_u32_ops);

	kvfree(tc_u_common_hash);

}



module_init(init_u32)

net/sched/sch_api.c

+210 −198
Original line number Diff line number Diff line
@@ -36,13 +36,6 @@ 
#include <net/netlink.h>

#include <net/pkt_sched.h>



static int qdisc_notify(struct net *net, struct sk_buff *oskb,

			struct nlmsghdr *n, u32 clid,

			struct Qdisc *old, struct Qdisc *new);

static int tclass_notify(struct net *net, struct sk_buff *oskb,

			 struct nlmsghdr *n, struct Qdisc *q,

			 unsigned long cl, int event);



/*



   Short review.
@@ -160,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))
@@ -327,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;

}
@@ -763,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;
@@ -775,6 +766,111 @@ void qdisc_tree_reduce_backlog(struct Qdisc *sch, unsigned int n, 
}

EXPORT_SYMBOL(qdisc_tree_reduce_backlog);



static int tc_fill_qdisc(struct sk_buff *skb, struct Qdisc *q, u32 clid,

			 u32 portid, u32 seq, u16 flags, int event)

{

	struct gnet_stats_basic_cpu __percpu *cpu_bstats = NULL;

	struct gnet_stats_queue __percpu *cpu_qstats = NULL;

	struct tcmsg *tcm;

	struct nlmsghdr  *nlh;

	unsigned char *b = skb_tail_pointer(skb);

	struct gnet_dump d;

	struct qdisc_size_table *stab;

	__u32 qlen;



	cond_resched();

	nlh = nlmsg_put(skb, portid, seq, event, sizeof(*tcm), flags);

	if (!nlh)

		goto out_nlmsg_trim;

	tcm = nlmsg_data(nlh);

	tcm->tcm_family = AF_UNSPEC;

	tcm->tcm__pad1 = 0;

	tcm->tcm__pad2 = 0;

	tcm->tcm_ifindex = qdisc_dev(q)->ifindex;

	tcm->tcm_parent = clid;

	tcm->tcm_handle = q->handle;

	tcm->tcm_info = refcount_read(&q->refcnt);

	if (nla_put_string(skb, TCA_KIND, q->ops->id))

		goto nla_put_failure;

	if (q->ops->dump && q->ops->dump(q, skb) < 0)

		goto nla_put_failure;

	qlen = q->q.qlen;



	stab = rtnl_dereference(q->stab);

	if (stab && qdisc_dump_stab(skb, stab) < 0)

		goto nla_put_failure;



	if (gnet_stats_start_copy_compat(skb, TCA_STATS2, TCA_STATS, TCA_XSTATS,

					 NULL, &d, TCA_PAD) < 0)

		goto nla_put_failure;



	if (q->ops->dump_stats && q->ops->dump_stats(q, &d) < 0)

		goto nla_put_failure;



	if (qdisc_is_percpu_stats(q)) {

		cpu_bstats = q->cpu_bstats;

		cpu_qstats = q->cpu_qstats;

	}



	if (gnet_stats_copy_basic(qdisc_root_sleeping_running(q),

				  &d, cpu_bstats, &q->bstats) < 0 ||

	    gnet_stats_copy_rate_est(&d, &q->rate_est) < 0 ||

	    gnet_stats_copy_queue(&d, cpu_qstats, &q->qstats, qlen) < 0)

		goto nla_put_failure;



	if (gnet_stats_finish_copy(&d) < 0)

		goto nla_put_failure;



	nlh->nlmsg_len = skb_tail_pointer(skb) - b;

	return skb->len;



out_nlmsg_trim:

nla_put_failure:

	nlmsg_trim(skb, b);

	return -1;

}



static bool tc_qdisc_dump_ignore(struct Qdisc *q, bool dump_invisible)

{

	if (q->flags & TCQ_F_BUILTIN)

		return true;

	if ((q->flags & TCQ_F_INVISIBLE) && !dump_invisible)

		return true;



	return false;

}



static int qdisc_notify(struct net *net, struct sk_buff *oskb,

			struct nlmsghdr *n, u32 clid,

			struct Qdisc *old, struct Qdisc *new)

{

	struct sk_buff *skb;

	u32 portid = oskb ? NETLINK_CB(oskb).portid : 0;



	skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);

	if (!skb)

		return -ENOBUFS;



	if (old && !tc_qdisc_dump_ignore(old, false)) {

		if (tc_fill_qdisc(skb, old, clid, portid, n->nlmsg_seq,

				  0, RTM_DELQDISC) < 0)

			goto err_out;

	}

	if (new && !tc_qdisc_dump_ignore(new, false)) {

		if (tc_fill_qdisc(skb, new, clid, portid, n->nlmsg_seq,

				  old ? NLM_F_REPLACE : 0, RTM_NEWQDISC) < 0)

			goto err_out;

	}



	if (skb->len)

		return rtnetlink_send(skb, net, portid, RTNLGRP_TC,

				      n->nlmsg_flags & NLM_F_ECHO);



err_out:

	kfree_skb(skb);

	return -EINVAL;

}



static void notify_and_destroy(struct net *net, struct sk_buff *skb,

			       struct nlmsghdr *n, u32 clid,

			       struct Qdisc *old, struct Qdisc *new)
@@ -857,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)
@@ -1342,111 +1438,6 @@ graft: 
	return 0;

}



static int tc_fill_qdisc(struct sk_buff *skb, struct Qdisc *q, u32 clid,

			 u32 portid, u32 seq, u16 flags, int event)

{

	struct gnet_stats_basic_cpu __percpu *cpu_bstats = NULL;

	struct gnet_stats_queue __percpu *cpu_qstats = NULL;

	struct tcmsg *tcm;

	struct nlmsghdr  *nlh;

	unsigned char *b = skb_tail_pointer(skb);

	struct gnet_dump d;

	struct qdisc_size_table *stab;

	__u32 qlen;



	cond_resched();

	nlh = nlmsg_put(skb, portid, seq, event, sizeof(*tcm), flags);

	if (!nlh)

		goto out_nlmsg_trim;

	tcm = nlmsg_data(nlh);

	tcm->tcm_family = AF_UNSPEC;

	tcm->tcm__pad1 = 0;

	tcm->tcm__pad2 = 0;

	tcm->tcm_ifindex = qdisc_dev(q)->ifindex;

	tcm->tcm_parent = clid;

	tcm->tcm_handle = q->handle;

	tcm->tcm_info = refcount_read(&q->refcnt);

	if (nla_put_string(skb, TCA_KIND, q->ops->id))

		goto nla_put_failure;

	if (q->ops->dump && q->ops->dump(q, skb) < 0)

		goto nla_put_failure;

	qlen = q->q.qlen;



	stab = rtnl_dereference(q->stab);

	if (stab && qdisc_dump_stab(skb, stab) < 0)

		goto nla_put_failure;



	if (gnet_stats_start_copy_compat(skb, TCA_STATS2, TCA_STATS, TCA_XSTATS,

					 NULL, &d, TCA_PAD) < 0)

		goto nla_put_failure;



	if (q->ops->dump_stats && q->ops->dump_stats(q, &d) < 0)

		goto nla_put_failure;



	if (qdisc_is_percpu_stats(q)) {

		cpu_bstats = q->cpu_bstats;

		cpu_qstats = q->cpu_qstats;

	}



	if (gnet_stats_copy_basic(qdisc_root_sleeping_running(q),

				  &d, cpu_bstats, &q->bstats) < 0 ||

	    gnet_stats_copy_rate_est(&d, &q->rate_est) < 0 ||

	    gnet_stats_copy_queue(&d, cpu_qstats, &q->qstats, qlen) < 0)

		goto nla_put_failure;



	if (gnet_stats_finish_copy(&d) < 0)

		goto nla_put_failure;



	nlh->nlmsg_len = skb_tail_pointer(skb) - b;

	return skb->len;



out_nlmsg_trim:

nla_put_failure:

	nlmsg_trim(skb, b);

	return -1;

}



static bool tc_qdisc_dump_ignore(struct Qdisc *q, bool dump_invisible)

{

	if (q->flags & TCQ_F_BUILTIN)

		return true;

	if ((q->flags & TCQ_F_INVISIBLE) && !dump_invisible)

		return true;



	return false;

}



static int qdisc_notify(struct net *net, struct sk_buff *oskb,

			struct nlmsghdr *n, u32 clid,

			struct Qdisc *old, struct Qdisc *new)

{

	struct sk_buff *skb;

	u32 portid = oskb ? NETLINK_CB(oskb).portid : 0;



	skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);

	if (!skb)

		return -ENOBUFS;



	if (old && !tc_qdisc_dump_ignore(old, false)) {

		if (tc_fill_qdisc(skb, old, clid, portid, n->nlmsg_seq,

				  0, RTM_DELQDISC) < 0)

			goto err_out;

	}

	if (new && !tc_qdisc_dump_ignore(new, false)) {

		if (tc_fill_qdisc(skb, new, clid, portid, n->nlmsg_seq,

				  old ? NLM_F_REPLACE : 0, RTM_NEWQDISC) < 0)

			goto err_out;

	}



	if (skb->len)

		return rtnetlink_send(skb, net, portid, RTNLGRP_TC,

				      n->nlmsg_flags & NLM_F_ECHO);



err_out:

	kfree_skb(skb);

	return -EINVAL;

}



static int tc_dump_qdisc_root(struct Qdisc *root, struct sk_buff *skb,

			      struct netlink_callback *cb,

			      int *q_idx_p, int s_q_idx, bool recur,
@@ -1559,7 +1550,103 @@ done: 
 *	Traffic classes manipulation.		*

 ************************************************/



static int tc_fill_tclass(struct sk_buff *skb, struct Qdisc *q,

			  unsigned long cl,

			  u32 portid, u32 seq, u16 flags, int event)

{

	struct tcmsg *tcm;

	struct nlmsghdr  *nlh;

	unsigned char *b = skb_tail_pointer(skb);

	struct gnet_dump d;

	const struct Qdisc_class_ops *cl_ops = q->ops->cl_ops;



	cond_resched();

	nlh = nlmsg_put(skb, portid, seq, event, sizeof(*tcm), flags);

	if (!nlh)

		goto out_nlmsg_trim;

	tcm = nlmsg_data(nlh);

	tcm->tcm_family = AF_UNSPEC;

	tcm->tcm__pad1 = 0;

	tcm->tcm__pad2 = 0;

	tcm->tcm_ifindex = qdisc_dev(q)->ifindex;

	tcm->tcm_parent = q->handle;

	tcm->tcm_handle = q->handle;

	tcm->tcm_info = 0;

	if (nla_put_string(skb, TCA_KIND, q->ops->id))

		goto nla_put_failure;

	if (cl_ops->dump && cl_ops->dump(q, cl, skb, tcm) < 0)

		goto nla_put_failure;



	if (gnet_stats_start_copy_compat(skb, TCA_STATS2, TCA_STATS, TCA_XSTATS,

					 NULL, &d, TCA_PAD) < 0)

		goto nla_put_failure;



	if (cl_ops->dump_stats && cl_ops->dump_stats(q, cl, &d) < 0)

		goto nla_put_failure;



	if (gnet_stats_finish_copy(&d) < 0)

		goto nla_put_failure;



	nlh->nlmsg_len = skb_tail_pointer(skb) - b;

	return skb->len;



out_nlmsg_trim:

nla_put_failure:

	nlmsg_trim(skb, b);

	return -1;

}



static int tclass_notify(struct net *net, struct sk_buff *oskb,

			 struct nlmsghdr *n, struct Qdisc *q,

			 unsigned long cl, int event)

{

	struct sk_buff *skb;

	u32 portid = oskb ? NETLINK_CB(oskb).portid : 0;



	skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);

	if (!skb)

		return -ENOBUFS;



	if (tc_fill_tclass(skb, q, cl, portid, n->nlmsg_seq, 0, event) < 0) {

		kfree_skb(skb);

		return -EINVAL;

	}



	return rtnetlink_send(skb, net, portid, RTNLGRP_TC,

			      n->nlmsg_flags & NLM_F_ECHO);

}



static int tclass_del_notify(struct net *net,

			     const struct Qdisc_class_ops *cops,

			     struct sk_buff *oskb, struct nlmsghdr *n,

			     struct Qdisc *q, unsigned long cl)

{

	u32 portid = oskb ? NETLINK_CB(oskb).portid : 0;

	struct sk_buff *skb;

	int err = 0;



	if (!cops->delete)

		return -EOPNOTSUPP;



	skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);

	if (!skb)

		return -ENOBUFS;



	if (tc_fill_tclass(skb, q, cl, portid, n->nlmsg_seq, 0,

			   RTM_DELTCLASS) < 0) {

		kfree_skb(skb);

		return -EINVAL;

	}



	err = cops->delete(q, cl);

	if (err) {

		kfree_skb(skb);

		return err;

	}



	return rtnetlink_send(skb, net, portid, RTNLGRP_TC,

			      n->nlmsg_flags & NLM_F_ECHO);

}



static int tc_ctl_tclass(struct sk_buff *skb, struct nlmsghdr *n,

			 struct netlink_ext_ack *extack)
@@ -1650,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;
@@ -1665,12 +1752,7 @@ static int tc_ctl_tclass(struct sk_buff *skb, struct nlmsghdr *n, 
				goto out;

			break;

		case RTM_DELTCLASS:

			err = -EOPNOTSUPP;

			if (cops->delete)

				err = cops->delete(q, cl);

			if (err == 0)

				tclass_notify(net, skb, n, q, cl,

					      RTM_DELTCLASS);

			err = tclass_del_notify(net, cops, skb, n, q, cl);

			goto out;

		case RTM_GETTCLASS:

			err = tclass_notify(net, skb, n, q, cl, RTM_NEWTCLASS);
@@ -1689,79 +1771,9 @@ 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;

}





static int tc_fill_tclass(struct sk_buff *skb, struct Qdisc *q,

			  unsigned long cl,

			  u32 portid, u32 seq, u16 flags, int event)

{

	struct tcmsg *tcm;

	struct nlmsghdr  *nlh;

	unsigned char *b = skb_tail_pointer(skb);

	struct gnet_dump d;

	const struct Qdisc_class_ops *cl_ops = q->ops->cl_ops;



	cond_resched();

	nlh = nlmsg_put(skb, portid, seq, event, sizeof(*tcm), flags);

	if (!nlh)

		goto out_nlmsg_trim;

	tcm = nlmsg_data(nlh);

	tcm->tcm_family = AF_UNSPEC;

	tcm->tcm__pad1 = 0;

	tcm->tcm__pad2 = 0;

	tcm->tcm_ifindex = qdisc_dev(q)->ifindex;

	tcm->tcm_parent = q->handle;

	tcm->tcm_handle = q->handle;

	tcm->tcm_info = 0;

	if (nla_put_string(skb, TCA_KIND, q->ops->id))

		goto nla_put_failure;

	if (cl_ops->dump && cl_ops->dump(q, cl, skb, tcm) < 0)

		goto nla_put_failure;



	if (gnet_stats_start_copy_compat(skb, TCA_STATS2, TCA_STATS, TCA_XSTATS,

					 NULL, &d, TCA_PAD) < 0)

		goto nla_put_failure;



	if (cl_ops->dump_stats && cl_ops->dump_stats(q, cl, &d) < 0)

		goto nla_put_failure;



	if (gnet_stats_finish_copy(&d) < 0)

		goto nla_put_failure;



	nlh->nlmsg_len = skb_tail_pointer(skb) - b;

	return skb->len;



out_nlmsg_trim:

nla_put_failure:

	nlmsg_trim(skb, b);

	return -1;

}



static int tclass_notify(struct net *net, struct sk_buff *oskb,

			 struct nlmsghdr *n, struct Qdisc *q,

			 unsigned long cl, int event)

{

	struct sk_buff *skb;

	u32 portid = oskb ? NETLINK_CB(oskb).portid : 0;



	skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL);

	if (!skb)

		return -ENOBUFS;



	if (tc_fill_tclass(skb, q, cl, portid, n->nlmsg_seq, 0, event) < 0) {

		kfree_skb(skb);

		return -EINVAL;

	}



	return rtnetlink_send(skb, net, portid, RTNLGRP_TC,

			      n->nlmsg_flags & NLM_F_ECHO);

}



struct qdisc_dump_args {

	struct qdisc_walker	w;

	struct sk_buff		*skb;

net/sched/sch_atm.c

+16 −14
Original line number Diff line number Diff line
@@ -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,

CRA Git | Maintained and supported by SUSTech CRA and CCSE