Commit 06177558 authored by Vlad Buslov's avatar Vlad Buslov Committed by David S. Miller
Browse files

net: sched: flower: introduce reference counting for filters 



Extend flower filters with reference counting in order to remove dependency
on rtnl lock in flower ops and allow to modify filters concurrently.
Reference to flower filter can be taken/released concurrently as soon as it
is marked as 'unlocked' by last patch in this series. Use atomic reference
counter type to make concurrent modifications safe.

Always take reference to flower filter while working with it:
- Modify fl_get() to take reference to filter.
- Implement tp->put() callback as fl_put() function to allow cls API to
release reference taken by fl_get().
- Modify fl_change() to assume that caller holds reference to fold and take
reference to fnew.
- Take reference to filter while using it in fl_walk().

Implement helper functions to get/put filter reference counter.

Signed-off-by: default avatarVlad Buslov <vladbu@mellanox.com>
Reviewed-by: default avatarStefano Brivio <sbrivio@redhat.com>
Acked-by: default avatarJiri Pirko <jiri@mellanox.com>
Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parent 620da486

net/sched/cls_flower.c

+82 −14
Original line number Original line Diff line number Diff line
@@ -14,6 +14,7 @@ 
#include <linux/module.h>

#include <linux/module.h>

#include <linux/rhashtable.h>

#include <linux/rhashtable.h>

#include <linux/workqueue.h>

#include <linux/workqueue.h>

#include <linux/refcount.h>





#include <linux/if_ether.h>

#include <linux/if_ether.h>

#include <linux/in6.h>

#include <linux/in6.h>
@@ -104,6 +105,11 @@ struct cls_fl_filter { 
	u32 in_hw_count;

	u32 in_hw_count;

	struct rcu_work rwork;

	struct rcu_work rwork;

	struct net_device *hw_dev;

	struct net_device *hw_dev;

	/* Flower classifier is unlocked, which means that its reference counter

	 * can be changed concurrently without any kind of external

	 * synchronization. Use atomic reference counter to be concurrency-safe.

	 */

	refcount_t refcnt;

};

};





static const struct rhashtable_params mask_ht_params = {

static const struct rhashtable_params mask_ht_params = {
@@ -447,6 +453,48 @@ static struct cls_fl_head *fl_head_dereference(struct tcf_proto *tp) 
	return rcu_dereference_raw(tp->root);

	return rcu_dereference_raw(tp->root);

}

}





static void __fl_put(struct cls_fl_filter *f)

{

	if (!refcount_dec_and_test(&f->refcnt))

		return;



	if (tcf_exts_get_net(&f->exts))

		tcf_queue_work(&f->rwork, fl_destroy_filter_work);

	else

		__fl_destroy_filter(f);

}



static struct cls_fl_filter *__fl_get(struct cls_fl_head *head, u32 handle)

{

	struct cls_fl_filter *f;



	rcu_read_lock();

	f = idr_find(&head->handle_idr, handle);

	if (f && !refcount_inc_not_zero(&f->refcnt))

		f = NULL;

	rcu_read_unlock();



	return f;

}



static struct cls_fl_filter *fl_get_next_filter(struct tcf_proto *tp,

						unsigned long *handle)

{

	struct cls_fl_head *head = fl_head_dereference(tp);

	struct cls_fl_filter *f;



	rcu_read_lock();

	while ((f = idr_get_next_ul(&head->handle_idr, handle))) {

		/* don't return filters that are being deleted */

		if (refcount_inc_not_zero(&f->refcnt))

			break;

		++(*handle);

	}

	rcu_read_unlock();



	return f;

}



static bool __fl_delete(struct tcf_proto *tp, struct cls_fl_filter *f,

static bool __fl_delete(struct tcf_proto *tp, struct cls_fl_filter *f,

			struct netlink_ext_ack *extack)

			struct netlink_ext_ack *extack)

{

{
@@ -460,10 +508,7 @@ static bool __fl_delete(struct tcf_proto *tp, struct cls_fl_filter *f, 
	if (!tc_skip_hw(f->flags))

	if (!tc_skip_hw(f->flags))

		fl_hw_destroy_filter(tp, f, extack);

		fl_hw_destroy_filter(tp, f, extack);

	tcf_unbind_filter(tp, &f->res);

	tcf_unbind_filter(tp, &f->res);

	if (async)

	__fl_put(f);

		tcf_queue_work(&f->rwork, fl_destroy_filter_work);

	else

		__fl_destroy_filter(f);





	return last;

	return last;

}

}
@@ -498,11 +543,18 @@ static void fl_destroy(struct tcf_proto *tp, bool rtnl_held, 
	tcf_queue_work(&head->rwork, fl_destroy_sleepable);

	tcf_queue_work(&head->rwork, fl_destroy_sleepable);

}

}





static void fl_put(struct tcf_proto *tp, void *arg)

{

	struct cls_fl_filter *f = arg;



	__fl_put(f);

}



static void *fl_get(struct tcf_proto *tp, u32 handle)

static void *fl_get(struct tcf_proto *tp, u32 handle)

{

{

	struct cls_fl_head *head = fl_head_dereference(tp);

	struct cls_fl_head *head = fl_head_dereference(tp);





	return idr_find(&head->handle_idr, handle);

	return __fl_get(head, handle);

}

}





static const struct nla_policy fl_policy[TCA_FLOWER_MAX + 1] = {

static const struct nla_policy fl_policy[TCA_FLOWER_MAX + 1] = {
@@ -1325,12 +1377,16 @@ static int fl_change(struct net *net, struct sk_buff *in_skb, 
	struct nlattr **tb;

	struct nlattr **tb;

	int err;

	int err;





	if (!tca[TCA_OPTIONS])

	if (!tca[TCA_OPTIONS]) {

		return -EINVAL;

		err = -EINVAL;

		goto errout_fold;

	}





	mask = kzalloc(sizeof(struct fl_flow_mask), GFP_KERNEL);

	mask = kzalloc(sizeof(struct fl_flow_mask), GFP_KERNEL);

	if (!mask)

	if (!mask) {

		return -ENOBUFS;

		err = -ENOBUFS;

		goto errout_fold;

	}





	tb = kcalloc(TCA_FLOWER_MAX + 1, sizeof(struct nlattr *), GFP_KERNEL);

	tb = kcalloc(TCA_FLOWER_MAX + 1, sizeof(struct nlattr *), GFP_KERNEL);

	if (!tb) {

	if (!tb) {
@@ -1353,6 +1409,7 @@ static int fl_change(struct net *net, struct sk_buff *in_skb, 
		err = -ENOBUFS;

		err = -ENOBUFS;

		goto errout_tb;

		goto errout_tb;

	}

	}

	refcount_set(&fnew->refcnt, 1);





	err = tcf_exts_init(&fnew->exts, net, TCA_FLOWER_ACT, 0);

	err = tcf_exts_init(&fnew->exts, net, TCA_FLOWER_ACT, 0);

	if (err < 0)

	if (err < 0)
@@ -1385,6 +1442,7 @@ static int fl_change(struct net *net, struct sk_buff *in_skb, 
	if (!tc_in_hw(fnew->flags))

	if (!tc_in_hw(fnew->flags))

		fnew->flags |= TCA_CLS_FLAGS_NOT_IN_HW;

		fnew->flags |= TCA_CLS_FLAGS_NOT_IN_HW;





	refcount_inc(&fnew->refcnt);

	if (fold) {

	if (fold) {

		fnew->handle = handle;

		fnew->handle = handle;
@@ -1403,7 +1461,11 @@ static int fl_change(struct net *net, struct sk_buff *in_skb, 
			fl_hw_destroy_filter(tp, fold, NULL);

			fl_hw_destroy_filter(tp, fold, NULL);

		tcf_unbind_filter(tp, &fold->res);

		tcf_unbind_filter(tp, &fold->res);

		tcf_exts_get_net(&fold->exts);

		tcf_exts_get_net(&fold->exts);

		tcf_queue_work(&fold->rwork, fl_destroy_filter_work);

		/* Caller holds reference to fold, so refcnt is always > 0

		 * after this.

		 */

		refcount_dec(&fold->refcnt);

		__fl_put(fold);

	} else {

	} else {

		if (__fl_lookup(fnew->mask, &fnew->mkey)) {

		if (__fl_lookup(fnew->mask, &fnew->mkey)) {

			err = -EEXIST;

			err = -EEXIST;
@@ -1452,6 +1514,9 @@ errout_tb: 
	kfree(tb);

	kfree(tb);

errout_mask_alloc:

errout_mask_alloc:

	kfree(mask);

	kfree(mask);

errout_fold:

	if (fold)

		__fl_put(fold);

	return err;

	return err;

}

}
@@ -1465,24 +1530,26 @@ static int fl_delete(struct tcf_proto *tp, void *arg, bool *last, 
			       f->mask->filter_ht_params);

			       f->mask->filter_ht_params);

	__fl_delete(tp, f, extack);

	__fl_delete(tp, f, extack);

	*last = list_empty(&head->masks);

	*last = list_empty(&head->masks);

	__fl_put(f);



	return 0;

	return 0;

}

}





static void fl_walk(struct tcf_proto *tp, struct tcf_walker *arg,

static void fl_walk(struct tcf_proto *tp, struct tcf_walker *arg,

		    bool rtnl_held)

		    bool rtnl_held)

{

{

	struct cls_fl_head *head = fl_head_dereference(tp);

	struct cls_fl_filter *f;

	struct cls_fl_filter *f;





	arg->count = arg->skip;

	arg->count = arg->skip;





	while ((f = idr_get_next_ul(&head->handle_idr,

	while ((f = fl_get_next_filter(tp, &arg->cookie)) != NULL) {

				    &arg->cookie)) != NULL) {

		if (arg->fn(tp, f, arg) < 0) {

		if (arg->fn(tp, f, arg) < 0) {

			__fl_put(f);

			arg->stop = 1;

			arg->stop = 1;

			break;

			break;

		}

		}

		arg->cookie = f->handle + 1;

		__fl_put(f);

		arg->cookie++;

		arg->count++;

		arg->count++;

	}

	}

}

}
@@ -2156,6 +2223,7 @@ static struct tcf_proto_ops cls_fl_ops __read_mostly = { 
	.init		= fl_init,

	.init		= fl_init,

	.destroy	= fl_destroy,

	.destroy	= fl_destroy,

	.get		= fl_get,

	.get		= fl_get,

	.put		= fl_put,

	.change		= fl_change,

	.change		= fl_change,

	.delete		= fl_delete,

	.delete		= fl_delete,

	.walk		= fl_walk,

	.walk		= fl_walk,

CRA Git | Maintained and supported by SUSTech CRA and CCSE