Commit fa5d824c authored by Volodymyr Mytnyk's avatar Volodymyr Mytnyk Committed by David S. Miller
Browse files

net: prestera: acl: add multi-chain support offload 



Add support of rule offloading added to the non-zero index chain,
which was previously forbidden. Also, goto action is offloaded
allowing to jump for processing of desired chain.

Note that only implicit chain 0 is bound to the device port(s) for
processing. The rest of chains have to be jumped by actions.

Signed-off-by: default avatarVolodymyr Mytnyk <vmytnyk@marvell.com>
Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parent e81f1e0d

drivers/net/ethernet/marvell/prestera/prestera_acl.c

+107 −17
Original line number Diff line number Diff line
@@ -22,6 +22,7 @@ struct prestera_acl { 


struct prestera_acl_ruleset_ht_key {

	struct prestera_flow_block *block;

	u32 chain_index;

};



struct prestera_acl_rule_entry {
@@ -33,6 +34,10 @@ struct prestera_acl_rule_entry { 
		struct {

			u8 valid:1;

		} accept, drop, trap;

		struct {

			struct prestera_acl_action_jump i;

			u8 valid:1;

		} jump;

		struct {

			u32 id;

			struct prestera_counter_block *block;
@@ -49,6 +54,7 @@ struct prestera_acl_ruleset { 
	refcount_t refcount;

	void *keymask;

	u32 vtcam_id;

	u32 index;

	u16 pcl_id;

	bool offload;

};
@@ -83,20 +89,45 @@ static const struct rhashtable_params __prestera_acl_rule_entry_ht_params = { 
	.automatic_shrinking = true,

};



int prestera_acl_chain_to_client(u32 chain_index, u32 *client)

{

	u32 client_map[] = {

		PRESTERA_HW_COUNTER_CLIENT_LOOKUP_0,

		PRESTERA_HW_COUNTER_CLIENT_LOOKUP_1,

		PRESTERA_HW_COUNTER_CLIENT_LOOKUP_2

	};



	if (chain_index > ARRAY_SIZE(client_map))

		return -EINVAL;



	*client = client_map[chain_index];

	return 0;

}



static bool prestera_acl_chain_is_supported(u32 chain_index)

{

	return (chain_index & ~PRESTERA_ACL_CHAIN_MASK) == 0;

}



static struct prestera_acl_ruleset *

prestera_acl_ruleset_create(struct prestera_acl *acl,

			    struct prestera_flow_block *block)

			    struct prestera_flow_block *block,

			    u32 chain_index)

{

	struct prestera_acl_ruleset *ruleset;

	u32 uid = 0;

	int err;



	if (!prestera_acl_chain_is_supported(chain_index))

		return ERR_PTR(-EINVAL);



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

	if (!ruleset)

		return ERR_PTR(-ENOMEM);



	ruleset->acl = acl;

	ruleset->ht_key.block = block;

	ruleset->ht_key.chain_index = chain_index;

	refcount_set(&ruleset->refcount, 1);



	err = rhashtable_init(&ruleset->rule_ht, &prestera_acl_rule_ht_params);
@@ -108,7 +139,9 @@ prestera_acl_ruleset_create(struct prestera_acl *acl, 
		goto err_ruleset_create;



	/* make pcl-id based on uid */

	ruleset->pcl_id = (u8)uid;

	ruleset->pcl_id = PRESTERA_ACL_PCL_ID_MAKE((u8)uid, chain_index);

	ruleset->index = uid;



	err = rhashtable_insert_fast(&acl->ruleset_ht, &ruleset->ht_node,

				     prestera_acl_ruleset_ht_params);

	if (err)
@@ -133,35 +166,64 @@ void prestera_acl_ruleset_keymask_set(struct prestera_acl_ruleset *ruleset, 


int prestera_acl_ruleset_offload(struct prestera_acl_ruleset *ruleset)

{

	struct prestera_acl_iface iface;

	u32 vtcam_id;

	int err;



	if (ruleset->offload)

		return -EEXIST;



	err = prestera_acl_vtcam_id_get(ruleset->acl, 0,

	err = prestera_acl_vtcam_id_get(ruleset->acl,

					ruleset->ht_key.chain_index,

					ruleset->keymask, &vtcam_id);

	if (err)

		return err;

		goto err_vtcam_create;



	if (ruleset->ht_key.chain_index) {

		/* for chain > 0, bind iface index to pcl-id to be able

		 * to jump from any other ruleset to this one using the index.

		 */

		iface.index = ruleset->index;

		iface.type = PRESTERA_ACL_IFACE_TYPE_INDEX;

		err = prestera_hw_vtcam_iface_bind(ruleset->acl->sw, &iface,

						   vtcam_id, ruleset->pcl_id);

		if (err)

			goto err_ruleset_bind;

	}



	ruleset->vtcam_id = vtcam_id;

	ruleset->offload = true;

	return 0;



err_ruleset_bind:

	prestera_acl_vtcam_id_put(ruleset->acl, ruleset->vtcam_id);

err_vtcam_create:

	return err;

}



static void prestera_acl_ruleset_destroy(struct prestera_acl_ruleset *ruleset)

{

	struct prestera_acl *acl = ruleset->acl;

	u8 uid = ruleset->pcl_id & PRESTERA_ACL_KEYMASK_PCL_ID_USER;

	int err;



	rhashtable_remove_fast(&acl->ruleset_ht, &ruleset->ht_node,

			       prestera_acl_ruleset_ht_params);



	if (ruleset->offload)

	if (ruleset->offload) {

		if (ruleset->ht_key.chain_index) {

			struct prestera_acl_iface iface = {

				.type = PRESTERA_ACL_IFACE_TYPE_INDEX,

				.index = ruleset->index

			};

			err = prestera_hw_vtcam_iface_unbind(acl->sw, &iface,

							     ruleset->vtcam_id);

			WARN_ON(err);

		}

		WARN_ON(prestera_acl_vtcam_id_put(acl, ruleset->vtcam_id));

	}



	idr_remove(&acl->uid, uid);



	rhashtable_destroy(&ruleset->rule_ht);

	kfree(ruleset->keymask);

	kfree(ruleset);
@@ -169,23 +231,26 @@ static void prestera_acl_ruleset_destroy(struct prestera_acl_ruleset *ruleset) 


static struct prestera_acl_ruleset *

__prestera_acl_ruleset_lookup(struct prestera_acl *acl,

			      struct prestera_flow_block *block)

			      struct prestera_flow_block *block,

			      u32 chain_index)

{

	struct prestera_acl_ruleset_ht_key ht_key;



	memset(&ht_key, 0, sizeof(ht_key));

	ht_key.block = block;

	ht_key.chain_index = chain_index;

	return rhashtable_lookup_fast(&acl->ruleset_ht, &ht_key,

				      prestera_acl_ruleset_ht_params);

}



struct prestera_acl_ruleset *

prestera_acl_ruleset_lookup(struct prestera_acl *acl,

			    struct prestera_flow_block *block)

			    struct prestera_flow_block *block,

			    u32 chain_index)

{

	struct prestera_acl_ruleset *ruleset;



	ruleset = __prestera_acl_ruleset_lookup(acl, block);

	ruleset = __prestera_acl_ruleset_lookup(acl, block, chain_index);

	if (!ruleset)

		return ERR_PTR(-ENOENT);
@@ -195,17 +260,18 @@ prestera_acl_ruleset_lookup(struct prestera_acl *acl, 


struct prestera_acl_ruleset *

prestera_acl_ruleset_get(struct prestera_acl *acl,

			 struct prestera_flow_block *block)

			 struct prestera_flow_block *block,

			 u32 chain_index)

{

	struct prestera_acl_ruleset *ruleset;



	ruleset = __prestera_acl_ruleset_lookup(acl, block);

	ruleset = __prestera_acl_ruleset_lookup(acl, block, chain_index);

	if (ruleset) {

		refcount_inc(&ruleset->refcount);

		return ruleset;

	}



	return prestera_acl_ruleset_create(acl, block);

	return prestera_acl_ruleset_create(acl, block, chain_index);

}



void prestera_acl_ruleset_put(struct prestera_acl_ruleset *ruleset)
@@ -293,6 +359,11 @@ prestera_acl_rule_lookup(struct prestera_acl_ruleset *ruleset, 
				      prestera_acl_rule_ht_params);

}



u32 prestera_acl_ruleset_index_get(const struct prestera_acl_ruleset *ruleset)

{

	return ruleset->index;

}



bool prestera_acl_ruleset_is_offload(struct prestera_acl_ruleset *ruleset)

{

	return ruleset->offload;
@@ -300,7 +371,7 @@ bool prestera_acl_ruleset_is_offload(struct prestera_acl_ruleset *ruleset) 


struct prestera_acl_rule *

prestera_acl_rule_create(struct prestera_acl_ruleset *ruleset,

			 unsigned long cookie)

			 unsigned long cookie, u32 chain_index)

{

	struct prestera_acl_rule *rule;
@@ -310,6 +381,7 @@ prestera_acl_rule_create(struct prestera_acl_ruleset *ruleset, 


	rule->ruleset = ruleset;

	rule->cookie = cookie;

	rule->chain_index = chain_index;



	refcount_inc(&ruleset->refcount);
@@ -324,6 +396,10 @@ void prestera_acl_rule_priority_set(struct prestera_acl_rule *rule, 


void prestera_acl_rule_destroy(struct prestera_acl_rule *rule)

{

	if (rule->jump_ruleset)

		/* release ruleset kept by jump action */

		prestera_acl_ruleset_put(rule->jump_ruleset);



	prestera_acl_ruleset_put(rule->ruleset);

	kfree(rule);

}
@@ -347,7 +423,10 @@ int prestera_acl_rule_add(struct prestera_switch *sw, 


	/* setup counter */

	rule->re_arg.count.valid = true;

	rule->re_arg.count.client = PRESTERA_HW_COUNTER_CLIENT_LOOKUP_0;

	err = prestera_acl_chain_to_client(ruleset->ht_key.chain_index,

					   &rule->re_arg.count.client);

	if (err)

		goto err_rule_add;



	rule->re = prestera_acl_rule_entry_find(sw->acl, &rule->re_key);

	err = WARN_ON(rule->re) ? -EEXIST : 0;
@@ -360,8 +439,10 @@ int prestera_acl_rule_add(struct prestera_switch *sw, 
	if (err)

		goto err_rule_add;



	/* bind the block (all ports) to chain index 0 */

	if (!ruleset->rule_count) {

	/* bind the block (all ports) to chain index 0, rest of

	 * the chains are bound to goto action

	 */

	if (!ruleset->ht_key.chain_index && !ruleset->rule_count) {

		err = prestera_acl_ruleset_block_bind(ruleset, block);

		if (err)

			goto err_acl_block_bind;
@@ -395,7 +476,7 @@ void prestera_acl_rule_del(struct prestera_switch *sw, 
	prestera_acl_rule_entry_destroy(sw->acl, rule->re);



	/* unbind block (all ports) */

	if (!ruleset->rule_count)

	if (!ruleset->ht_key.chain_index && !ruleset->rule_count)

		prestera_acl_ruleset_block_unbind(ruleset, block);

}
@@ -459,6 +540,12 @@ static int __prestera_acl_rule_entry2hw_add(struct prestera_switch *sw, 
		act_hw[act_num].id = PRESTERA_ACL_RULE_ACTION_TRAP;

		act_num++;

	}

	/* jump */

	if (e->jump.valid) {

		act_hw[act_num].id = PRESTERA_ACL_RULE_ACTION_JUMP;

		act_hw[act_num].jump = e->jump.i;

		act_num++;

	}

	/* counter */

	if (e->counter.block) {

		act_hw[act_num].id = PRESTERA_ACL_RULE_ACTION_COUNT;
@@ -505,6 +592,9 @@ __prestera_acl_rule_entry_act_construct(struct prestera_switch *sw, 
	e->drop.valid = arg->drop.valid;

	/* trap */

	e->trap.valid = arg->trap.valid;

	/* jump */

	e->jump.valid = arg->jump.valid;

	e->jump.i = arg->jump.i;

	/* counter */

	if (arg->count.valid) {

		int err;

drivers/net/ethernet/marvell/prestera/prestera_acl.h

+27 −3
Original line number Diff line number Diff line
@@ -10,6 +10,14 @@ 
#define PRESTERA_ACL_KEYMASK_PCL_ID		0x3FF

#define PRESTERA_ACL_KEYMASK_PCL_ID_USER			\

	(PRESTERA_ACL_KEYMASK_PCL_ID & 0x00FF)

#define PRESTERA_ACL_KEYMASK_PCL_ID_CHAIN			\

	(PRESTERA_ACL_KEYMASK_PCL_ID & 0xFF00)

#define PRESTERA_ACL_CHAIN_MASK					\

	(PRESTERA_ACL_KEYMASK_PCL_ID >> 8)



#define PRESTERA_ACL_PCL_ID_MAKE(uid, chain_id)			\

	(((uid) & PRESTERA_ACL_KEYMASK_PCL_ID_USER) |		\

	(((chain_id) << 8) & PRESTERA_ACL_KEYMASK_PCL_ID_CHAIN))



#define rule_match_set_n(match_p, type, val_p, size)		\

	memcpy(&(match_p)[PRESTERA_ACL_RULE_MATCH_TYPE_##type],	\
@@ -46,6 +54,7 @@ enum prestera_acl_rule_action { 
	PRESTERA_ACL_RULE_ACTION_ACCEPT = 0,

	PRESTERA_ACL_RULE_ACTION_DROP = 1,

	PRESTERA_ACL_RULE_ACTION_TRAP = 2,

	PRESTERA_ACL_RULE_ACTION_JUMP = 5,

	PRESTERA_ACL_RULE_ACTION_COUNT = 7,



	PRESTERA_ACL_RULE_ACTION_MAX
@@ -61,6 +70,10 @@ struct prestera_acl_match { 
	__be32 mask[__PRESTERA_ACL_RULE_MATCH_TYPE_MAX];

};



struct prestera_acl_action_jump {

	u32 index;

};



struct prestera_acl_action_count {

	u32 id;

};
@@ -74,6 +87,7 @@ struct prestera_acl_hw_action_info { 
	enum prestera_acl_rule_action id;

	union {

		struct prestera_acl_action_count count;

		struct prestera_acl_action_jump jump;

	};

};
@@ -87,6 +101,10 @@ struct prestera_acl_rule_entry_arg { 
		struct {

			u8 valid:1;

		} accept, drop, trap;

		struct {

			struct prestera_acl_action_jump i;

			u8 valid:1;

		} jump;

		struct {

			u8 valid:1;

			u32 client;
@@ -98,7 +116,9 @@ struct prestera_acl_rule { 
	struct rhash_head ht_node; /* Member of acl HT */

	struct list_head list;

	struct prestera_acl_ruleset *ruleset;

	struct prestera_acl_ruleset *jump_ruleset;

	unsigned long cookie;

	u32 chain_index;

	u32 priority;

	struct prestera_acl_rule_entry_key re_key;

	struct prestera_acl_rule_entry_arg re_arg;
@@ -122,7 +142,7 @@ void prestera_acl_fini(struct prestera_switch *sw); 


struct prestera_acl_rule *

prestera_acl_rule_create(struct prestera_acl_ruleset *ruleset,

			 unsigned long cookie);

			 unsigned long cookie, u32 chain_index);

void prestera_acl_rule_priority_set(struct prestera_acl_rule *rule,

				    u32 priority);

void prestera_acl_rule_destroy(struct prestera_acl_rule *rule);
@@ -147,10 +167,12 @@ prestera_acl_rule_entry_create(struct prestera_acl *acl, 
			       struct prestera_acl_rule_entry_arg *arg);

struct prestera_acl_ruleset *

prestera_acl_ruleset_get(struct prestera_acl *acl,

			 struct prestera_flow_block *block);

			 struct prestera_flow_block *block,

			 u32 chain_index);

struct prestera_acl_ruleset *

prestera_acl_ruleset_lookup(struct prestera_acl *acl,

			    struct prestera_flow_block *block);

			    struct prestera_flow_block *block,

			    u32 chain_index);

void prestera_acl_ruleset_keymask_set(struct prestera_acl_ruleset *ruleset,

				      void *keymask);

bool prestera_acl_ruleset_is_offload(struct prestera_acl_ruleset *ruleset);
@@ -160,6 +182,7 @@ int prestera_acl_ruleset_bind(struct prestera_acl_ruleset *ruleset, 
			      struct prestera_port *port);

int prestera_acl_ruleset_unbind(struct prestera_acl_ruleset *ruleset,

				struct prestera_port *port);

u32 prestera_acl_ruleset_index_get(const struct prestera_acl_ruleset *ruleset);

void

prestera_acl_rule_keymask_pcl_id_set(struct prestera_acl_rule *rule,

				     u16 pcl_id);
@@ -167,5 +190,6 @@ prestera_acl_rule_keymask_pcl_id_set(struct prestera_acl_rule *rule, 
int prestera_acl_vtcam_id_get(struct prestera_acl *acl, u8 lookup,

			      void *keymask, u32 *vtcam_id);

int prestera_acl_vtcam_id_put(struct prestera_acl *acl, u32 vtcam_id);

int prestera_acl_chain_to_client(u32 chain_index, u32 *client);



#endif /* _PRESTERA_ACL_H_ */

drivers/net/ethernet/marvell/prestera/prestera_flow.c

+2 −3
Original line number Diff line number Diff line
@@ -29,9 +29,6 @@ static int prestera_flow_block_mall_cb(struct prestera_flow_block *block, 
static int prestera_flow_block_flower_cb(struct prestera_flow_block *block,

					 struct flow_cls_offload *f)

{

	if (f->common.chain_index != 0)

		return -EOPNOTSUPP;



	switch (f->command) {

	case FLOW_CLS_REPLACE:

		return prestera_flower_replace(block, f);
@@ -71,6 +68,7 @@ static void prestera_flow_block_destroy(void *cb_priv) 


	prestera_flower_template_cleanup(block);



	WARN_ON(!list_empty(&block->template_list));

	WARN_ON(!list_empty(&block->binding_list));



	kfree(block);
@@ -86,6 +84,7 @@ prestera_flow_block_create(struct prestera_switch *sw, struct net *net) 
		return NULL;



	INIT_LIST_HEAD(&block->binding_list);

	INIT_LIST_HEAD(&block->template_list);

	block->net = net;

	block->sw = sw;

drivers/net/ethernet/marvell/prestera/prestera_flow.h

+1 −2
Original line number Diff line number Diff line
@@ -8,7 +8,6 @@ 


struct prestera_port;

struct prestera_switch;

struct prestera_flower_template;



struct prestera_flow_block_binding {

	struct list_head list;
@@ -22,7 +21,7 @@ struct prestera_flow_block { 
	struct net *net;

	struct prestera_acl_ruleset *ruleset_zero;

	struct flow_block_cb *block_cb;

	struct prestera_flower_template *tmplt;

	struct list_head template_list;

	unsigned int rule_count;

};

drivers/net/ethernet/marvell/prestera/prestera_flower.c

+60 −13
Original line number Diff line number Diff line
@@ -8,26 +8,60 @@ 


struct prestera_flower_template {

	struct prestera_acl_ruleset *ruleset;

	struct list_head list;

	u32 chain_index;

};



void prestera_flower_template_cleanup(struct prestera_flow_block *block)

{

	if (block->tmplt) {

		/* put the reference to the ruleset kept in create */

		prestera_acl_ruleset_put(block->tmplt->ruleset);

		kfree(block->tmplt);

		block->tmplt = NULL;

		return;

	struct prestera_flower_template *template;

	struct list_head *pos, *n;



	/* put the reference to all rulesets kept in tmpl create */

	list_for_each_safe(pos, n, &block->template_list) {

		template = list_entry(pos, typeof(*template), list);

		prestera_acl_ruleset_put(template->ruleset);

		list_del(&template->list);

		kfree(template);

	}

}



static int

prestera_flower_parse_goto_action(struct prestera_flow_block *block,

				  struct prestera_acl_rule *rule,

				  u32 chain_index,

				  const struct flow_action_entry *act)

{

	struct prestera_acl_ruleset *ruleset;



	if (act->chain_index <= chain_index)

		/* we can jump only forward */

		return -EINVAL;



	if (rule->re_arg.jump.valid)

		return -EEXIST;



	ruleset = prestera_acl_ruleset_get(block->sw->acl, block,

					   act->chain_index);

	if (IS_ERR(ruleset))

		return PTR_ERR(ruleset);



	rule->re_arg.jump.valid = 1;

	rule->re_arg.jump.i.index = prestera_acl_ruleset_index_get(ruleset);



	rule->jump_ruleset = ruleset;



	return 0;

}



static int prestera_flower_parse_actions(struct prestera_flow_block *block,

					 struct prestera_acl_rule *rule,

					 struct flow_action *flow_action,

					 u32 chain_index,

					 struct netlink_ext_ack *extack)

{

	const struct flow_action_entry *act;

	int i;

	int err, i;



	/* whole struct (rule->re_arg) must be initialized with 0 */

	if (!flow_action_has_entries(flow_action))
@@ -53,6 +87,13 @@ static int prestera_flower_parse_actions(struct prestera_flow_block *block, 


			rule->re_arg.trap.valid = 1;

			break;

		case FLOW_ACTION_GOTO:

			err = prestera_flower_parse_goto_action(block, rule,

								chain_index,

								act);

			if (err)

				return err;

			break;

		default:

			NL_SET_ERR_MSG_MOD(extack, "Unsupported action");

			pr_err("Unsupported action\n");
@@ -259,6 +300,7 @@ static int prestera_flower_parse(struct prestera_flow_block *block, 
	}



	return prestera_flower_parse_actions(block, rule, &f->rule->action,

					     f->common.chain_index,

					     f->common.extack);

}
@@ -270,12 +312,13 @@ int prestera_flower_replace(struct prestera_flow_block *block, 
	struct prestera_acl_rule *rule;

	int err;



	ruleset = prestera_acl_ruleset_get(acl, block);

	ruleset = prestera_acl_ruleset_get(acl, block, f->common.chain_index);

	if (IS_ERR(ruleset))

		return PTR_ERR(ruleset);



	/* increments the ruleset reference */

	rule = prestera_acl_rule_create(ruleset, f->cookie);

	rule = prestera_acl_rule_create(ruleset, f->cookie,

					f->common.chain_index);

	if (IS_ERR(rule)) {

		err = PTR_ERR(rule);

		goto err_rule_create;
@@ -312,7 +355,8 @@ void prestera_flower_destroy(struct prestera_flow_block *block, 
	struct prestera_acl_ruleset *ruleset;

	struct prestera_acl_rule *rule;



	ruleset = prestera_acl_ruleset_lookup(block->sw->acl, block);

	ruleset = prestera_acl_ruleset_lookup(block->sw->acl, block,

					      f->common.chain_index);

	if (IS_ERR(ruleset))

		return;
@@ -345,7 +389,8 @@ int prestera_flower_tmplt_create(struct prestera_flow_block *block, 
	}



	prestera_acl_rule_keymask_pcl_id_set(&rule, 0);

	ruleset = prestera_acl_ruleset_get(block->sw->acl, block);

	ruleset = prestera_acl_ruleset_get(block->sw->acl, block,

					   f->common.chain_index);

	if (IS_ERR_OR_NULL(ruleset)) {

		err = -EINVAL;

		goto err_ruleset_get;
@@ -364,7 +409,8 @@ int prestera_flower_tmplt_create(struct prestera_flow_block *block, 


	/* keep the reference to the ruleset */

	template->ruleset = ruleset;

	block->tmplt = template;

	template->chain_index = f->common.chain_index;

	list_add_rcu(&template->list, &block->template_list);

	return 0;



err_ruleset_get:
@@ -390,7 +436,8 @@ int prestera_flower_stats(struct prestera_flow_block *block, 
	u64 bytes;

	int err;



	ruleset = prestera_acl_ruleset_lookup(block->sw->acl, block);

	ruleset = prestera_acl_ruleset_lookup(block->sw->acl, block,

					      f->common.chain_index);

	if (IS_ERR(ruleset))

		return PTR_ERR(ruleset);