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

net: prestera: acl: migrate to new vTCAM api 



- Add new vTCAM HW API to configure HW ACLs.
- Migrate acl to use new vTCAM HW API.
- No counter support in this patch-set.

Co-developed-by: default avatarYevhen Orlov <yevhen.orlov@plvision.eu>
Signed-off-by: default avatarYevhen Orlov <yevhen.orlov@plvision.eu>
Signed-off-by: default avatarVolodymyr Mytnyk <vmytnyk@marvell.com>
Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parent 4c897cfc

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

+457 −183
Original line number Diff line number Diff line 
// SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0

/* Copyright (c) 2020 Marvell International Ltd. All rights reserved */

/* Copyright (c) 2020-2021 Marvell International Ltd. All rights reserved */



#include <linux/rhashtable.h>



#include "prestera.h"

#include "prestera_hw.h"

#include "prestera_acl.h"

#include "prestera_span.h"

#include "prestera_flow.h"

#include "prestera_hw.h"

#include "prestera.h"



#define ACL_KEYMASK_SIZE	\

	(sizeof(__be32) * __PRESTERA_ACL_RULE_MATCH_TYPE_MAX)



struct prestera_acl {

	struct prestera_switch *sw;

	struct list_head vtcam_list;

	struct list_head rules;

	struct rhashtable ruleset_ht;

	struct rhashtable acl_rule_entry_ht;

	struct idr uid;

};



struct prestera_acl_ruleset_ht_key {

	struct prestera_flow_block *block;

};



struct prestera_acl_rule_entry {

	struct rhash_head ht_node;

	struct prestera_acl_rule_entry_key key;

	u32 hw_id;

	u32 vtcam_id;

	struct {

		struct {

			u8 valid:1;

		} accept, drop, trap;

	};

};



struct prestera_acl_ruleset {

	struct rhash_head ht_node; /* Member of acl HT */

	struct prestera_acl_ruleset_ht_key ht_key;

	struct rhashtable rule_ht;

	struct prestera_switch *sw;

	u16 id;

	struct prestera_acl *acl;

	unsigned long rule_count;

	refcount_t refcount;

	void *keymask;

	u32 vtcam_id;

	u16 pcl_id;

	bool offload;

};



struct prestera_acl_rule {

	struct rhash_head ht_node;

struct prestera_acl_vtcam {

	struct list_head list;

	struct list_head match_list;

	struct list_head action_list;

	struct prestera_flow_block *block;

	unsigned long cookie;

	u32 priority;

	u8 n_actions;

	u8 n_matches;

	__be32 keymask[__PRESTERA_ACL_RULE_MATCH_TYPE_MAX];

	refcount_t refcount;

	u32 id;

	bool is_keymask_set;

	u8 lookup;

};



static const struct rhashtable_params prestera_acl_ruleset_ht_params = {

	.key_len = sizeof(struct prestera_acl_ruleset_ht_key),

	.key_offset = offsetof(struct prestera_acl_ruleset, ht_key),

	.head_offset = offsetof(struct prestera_acl_ruleset, ht_node),

	.automatic_shrinking = true,

};



static const struct rhashtable_params prestera_acl_rule_ht_params = {
@@ -39,28 +72,48 @@ static const struct rhashtable_params prestera_acl_rule_ht_params = { 
	.automatic_shrinking = true,

};



static const struct rhashtable_params __prestera_acl_rule_entry_ht_params = {

	.key_offset  = offsetof(struct prestera_acl_rule_entry, key),

	.head_offset = offsetof(struct prestera_acl_rule_entry, ht_node),

	.key_len     = sizeof(struct prestera_acl_rule_entry_key),

	.automatic_shrinking = true,

};



static struct prestera_acl_ruleset *

prestera_acl_ruleset_create(struct prestera_switch *sw)

prestera_acl_ruleset_create(struct prestera_acl *acl,

			    struct prestera_flow_block *block)

{

	struct prestera_acl_ruleset *ruleset;

	int err;

	u32 uid;



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

	if (!ruleset)

		return ERR_PTR(-ENOMEM);



	ruleset->acl = acl;

	ruleset->ht_key.block = block;

	refcount_set(&ruleset->refcount, 1);



	err = rhashtable_init(&ruleset->rule_ht, &prestera_acl_rule_ht_params);

	if (err)

		goto err_rhashtable_init;



	err = prestera_hw_acl_ruleset_create(sw, &ruleset->id);

	err = idr_alloc_u32(&acl->uid, NULL, &uid, U8_MAX, GFP_KERNEL);

	if (err)

		goto err_ruleset_create;



	ruleset->sw = sw;

	/* make pcl-id based on uid */

	ruleset->pcl_id = (u8)uid;

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

				     prestera_acl_ruleset_ht_params);

	if (err)

		goto err_ruleset_ht_insert;



	return ruleset;



err_ruleset_ht_insert:

	idr_remove(&acl->uid, uid);

err_ruleset_create:

	rhashtable_destroy(&ruleset->rule_ht);

err_rhashtable_init:
@@ -68,117 +121,158 @@ prestera_acl_ruleset_create(struct prestera_switch *sw) 
	return ERR_PTR(err);

}



static void prestera_acl_ruleset_destroy(struct prestera_acl_ruleset *ruleset)

int prestera_acl_ruleset_offload(struct prestera_acl_ruleset *ruleset)

{

	prestera_hw_acl_ruleset_del(ruleset->sw, ruleset->id);

	rhashtable_destroy(&ruleset->rule_ht);

	kfree(ruleset);

	u32 vtcam_id;

	int err;



	if (ruleset->offload)

		return -EEXIST;



	err = prestera_acl_vtcam_id_get(ruleset->acl, 0,

					ruleset->keymask, &vtcam_id);

	if (err)

		return err;



	ruleset->vtcam_id = vtcam_id;

	ruleset->offload = true;

	return 0;

}



struct prestera_flow_block *

prestera_acl_block_create(struct prestera_switch *sw, struct net *net)

static void prestera_acl_ruleset_destroy(struct prestera_acl_ruleset *ruleset)

{

	struct prestera_flow_block *block;

	struct prestera_acl *acl = ruleset->acl;

	u8 uid = ruleset->pcl_id & PRESTERA_ACL_KEYMASK_PCL_ID_USER;



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

	if (!block)

		return NULL;

	INIT_LIST_HEAD(&block->binding_list);

	block->net = net;

	block->sw = sw;

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

			       prestera_acl_ruleset_ht_params);



	block->ruleset = prestera_acl_ruleset_create(sw);

	if (IS_ERR(block->ruleset)) {

		kfree(block);

		return NULL;

	}

	if (ruleset->offload)

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



	return block;

	idr_remove(&acl->uid, uid);



	rhashtable_destroy(&ruleset->rule_ht);

	kfree(ruleset->keymask);

	kfree(ruleset);

}



void prestera_acl_block_destroy(struct prestera_flow_block *block)

static struct prestera_acl_ruleset *

__prestera_acl_ruleset_lookup(struct prestera_acl *acl,

			      struct prestera_flow_block *block)

{

	prestera_acl_ruleset_destroy(block->ruleset);

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

	kfree(block);

	struct prestera_acl_ruleset_ht_key ht_key;



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

	ht_key.block = block;

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

				      prestera_acl_ruleset_ht_params);

}



static struct prestera_flow_block_binding *

prestera_acl_block_lookup(struct prestera_flow_block *block,

			  struct prestera_port *port)

struct prestera_acl_ruleset *

prestera_acl_ruleset_lookup(struct prestera_acl *acl,

			    struct prestera_flow_block *block)

{

	struct prestera_flow_block_binding *binding;

	struct prestera_acl_ruleset *ruleset;



	list_for_each_entry(binding, &block->binding_list, list)

		if (binding->port == port)

			return binding;

	ruleset = __prestera_acl_ruleset_lookup(acl, block);

	if (!ruleset)

		return ERR_PTR(-ENOENT);



	return NULL;

	refcount_inc(&ruleset->refcount);

	return ruleset;

}



int prestera_acl_block_bind(struct prestera_flow_block *block,

			    struct prestera_port *port)

struct prestera_acl_ruleset *

prestera_acl_ruleset_get(struct prestera_acl *acl,

			 struct prestera_flow_block *block)

{

	struct prestera_flow_block_binding *binding;

	int err;



	if (WARN_ON(prestera_acl_block_lookup(block, port)))

		return -EEXIST;

	struct prestera_acl_ruleset *ruleset;



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

	if (!binding)

		return -ENOMEM;

	binding->span_id = PRESTERA_SPAN_INVALID_ID;

	binding->port = port;

	ruleset = __prestera_acl_ruleset_lookup(acl, block);

	if (ruleset) {

		refcount_inc(&ruleset->refcount);

		return ruleset;

	}



	err = prestera_hw_acl_port_bind(port, block->ruleset->id);

	if (err)

		goto err_rules_bind;

	return prestera_acl_ruleset_create(acl, block);

}



	list_add(&binding->list, &block->binding_list);

	return 0;

void prestera_acl_ruleset_put(struct prestera_acl_ruleset *ruleset)

{

	if (!refcount_dec_and_test(&ruleset->refcount))

		return;



err_rules_bind:

	kfree(binding);

	return err;

	prestera_acl_ruleset_destroy(ruleset);

}



int prestera_acl_block_unbind(struct prestera_flow_block *block,

int prestera_acl_ruleset_bind(struct prestera_acl_ruleset *ruleset,

			      struct prestera_port *port)

{

	struct prestera_flow_block_binding *binding;



	binding = prestera_acl_block_lookup(block, port);

	if (!binding)

		return -ENOENT;

	struct prestera_acl_iface iface = {

		.type = PRESTERA_ACL_IFACE_TYPE_PORT,

		.port = port

	};



	list_del(&binding->list);

	return prestera_hw_vtcam_iface_bind(port->sw, &iface, ruleset->vtcam_id,

					    ruleset->pcl_id);

}



	prestera_hw_acl_port_unbind(port, block->ruleset->id);

int prestera_acl_ruleset_unbind(struct prestera_acl_ruleset *ruleset,

				struct prestera_port *port)

{

	struct prestera_acl_iface iface = {

		.type = PRESTERA_ACL_IFACE_TYPE_PORT,

		.port = port

	};



	kfree(binding);

	return 0;

	return prestera_hw_vtcam_iface_unbind(port->sw, &iface,

					      ruleset->vtcam_id);

}



struct prestera_acl_ruleset *

prestera_acl_block_ruleset_get(struct prestera_flow_block *block)

static int prestera_acl_ruleset_block_bind(struct prestera_acl_ruleset *ruleset,

					   struct prestera_flow_block *block)

{

	return block->ruleset;

	struct prestera_flow_block_binding *binding;

	int err;



	block->ruleset_zero = ruleset;

	list_for_each_entry(binding, &block->binding_list, list) {

		err = prestera_acl_ruleset_bind(ruleset, binding->port);

		if (err)

			goto rollback;

	}

	return 0;



u16 prestera_acl_rule_ruleset_id_get(const struct prestera_acl_rule *rule)

{

	return rule->block->ruleset->id;

rollback:

	list_for_each_entry_continue_reverse(binding, &block->binding_list,

					     list)

		err = prestera_acl_ruleset_unbind(ruleset, binding->port);

	block->ruleset_zero = NULL;



	return err;

}



struct net *prestera_acl_block_net(struct prestera_flow_block *block)

static void

prestera_acl_ruleset_block_unbind(struct prestera_acl_ruleset *ruleset,

				  struct prestera_flow_block *block)

{

	return block->net;

	struct prestera_flow_block_binding *binding;



	list_for_each_entry(binding, &block->binding_list, list)

		prestera_acl_ruleset_unbind(ruleset, binding->port);

	block->ruleset_zero = NULL;

}



struct prestera_switch *prestera_acl_block_sw(struct prestera_flow_block *block)

void

prestera_acl_rule_keymask_pcl_id_set(struct prestera_acl_rule *rule, u16 pcl_id)

{

	return block->sw;

	struct prestera_acl_match *r_match = &rule->re_key.match;

	__be16 pcl_id_mask = htons(PRESTERA_ACL_KEYMASK_PCL_ID);

	__be16 pcl_id_key = htons(pcl_id);



	rule_match_set(r_match->key, PCL_ID, pcl_id_key);

	rule_match_set(r_match->mask, PCL_ID, pcl_id_mask);

}



struct prestera_acl_rule *
@@ -189,8 +283,13 @@ prestera_acl_rule_lookup(struct prestera_acl_ruleset *ruleset, 
				      prestera_acl_rule_ht_params);

}



bool prestera_acl_ruleset_is_offload(struct prestera_acl_ruleset *ruleset)

{

	return ruleset->offload;

}



struct prestera_acl_rule *

prestera_acl_rule_create(struct prestera_flow_block *block,

prestera_acl_rule_create(struct prestera_acl_ruleset *ruleset,

			 unsigned long cookie)

{

	struct prestera_acl_rule *rule;
@@ -199,178 +298,353 @@ prestera_acl_rule_create(struct prestera_flow_block *block, 
	if (!rule)

		return ERR_PTR(-ENOMEM);



	INIT_LIST_HEAD(&rule->match_list);

	INIT_LIST_HEAD(&rule->action_list);

	rule->ruleset = ruleset;

	rule->cookie = cookie;

	rule->block = block;



	refcount_inc(&ruleset->refcount);



	return rule;

}



struct list_head *

prestera_acl_rule_match_list_get(struct prestera_acl_rule *rule)

void prestera_acl_rule_priority_set(struct prestera_acl_rule *rule,

				    u32 priority)

{

	return &rule->match_list;

	rule->priority = priority;

}



struct list_head *

prestera_acl_rule_action_list_get(struct prestera_acl_rule *rule)

void prestera_acl_rule_destroy(struct prestera_acl_rule *rule)

{

	return &rule->action_list;

	prestera_acl_ruleset_put(rule->ruleset);

	kfree(rule);

}



int prestera_acl_rule_action_add(struct prestera_acl_rule *rule,

				 struct prestera_acl_rule_action_entry *entry)

int prestera_acl_rule_add(struct prestera_switch *sw,

			  struct prestera_acl_rule *rule)

{

	struct prestera_acl_rule_action_entry *a_entry;

	int err;

	struct prestera_acl_ruleset *ruleset = rule->ruleset;

	struct prestera_flow_block *block = ruleset->ht_key.block;



	a_entry = kmalloc(sizeof(*a_entry), GFP_KERNEL);

	if (!a_entry)

		return -ENOMEM;

	/* try to add rule to hash table first */

	err = rhashtable_insert_fast(&ruleset->rule_ht, &rule->ht_node,

				     prestera_acl_rule_ht_params);

	if (err)

		goto err_ht_insert;



	prestera_acl_rule_keymask_pcl_id_set(rule, ruleset->pcl_id);

	rule->re_arg.vtcam_id = ruleset->vtcam_id;

	rule->re_key.prio = rule->priority;



	memcpy(a_entry, entry, sizeof(*entry));

	list_add(&a_entry->list, &rule->action_list);

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

	err = WARN_ON(rule->re) ? -EEXIST : 0;

	if (err)

		goto err_rule_add;



	rule->re = prestera_acl_rule_entry_create(sw->acl, &rule->re_key,

						  &rule->re_arg);

	err = !rule->re ? -EINVAL : 0;

	if (err)

		goto err_rule_add;



	rule->n_actions++;

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

	if (!ruleset->rule_count) {

		err = prestera_acl_ruleset_block_bind(ruleset, block);

		if (err)

			goto err_acl_block_bind;

	}



	list_add_tail(&rule->list, &sw->acl->rules);

	ruleset->rule_count++;

	return 0;



err_acl_block_bind:

	prestera_acl_rule_entry_destroy(sw->acl, rule->re);

err_rule_add:

	rule->re = NULL;

	rhashtable_remove_fast(&ruleset->rule_ht, &rule->ht_node,

			       prestera_acl_rule_ht_params);

err_ht_insert:

	return err;

}



u8 prestera_acl_rule_action_len(struct prestera_acl_rule *rule)

void prestera_acl_rule_del(struct prestera_switch *sw,

			   struct prestera_acl_rule *rule)

{

	struct prestera_acl_ruleset *ruleset = rule->ruleset;

	struct prestera_flow_block *block = ruleset->ht_key.block;



	rhashtable_remove_fast(&ruleset->rule_ht, &rule->ht_node,

			       prestera_acl_rule_ht_params);

	ruleset->rule_count--;

	list_del(&rule->list);



	prestera_acl_rule_entry_destroy(sw->acl, rule->re);



	/* unbind block (all ports) */

	if (!ruleset->rule_count)

		prestera_acl_ruleset_block_unbind(ruleset, block);

}



int prestera_acl_rule_get_stats(struct prestera_acl *acl,

				struct prestera_acl_rule *rule,

				u64 *packets, u64 *bytes, u64 *last_use)

{

	return rule->n_actions;

	*last_use = jiffies;

	*packets = 0;

	*bytes = 0;



	return 0;

}



u32 prestera_acl_rule_priority_get(struct prestera_acl_rule *rule)

struct prestera_acl_rule_entry *

prestera_acl_rule_entry_find(struct prestera_acl *acl,

			     struct prestera_acl_rule_entry_key *key)

{

	return rule->priority;

	struct prestera_acl_rule_entry *e;



	e = rhashtable_lookup_fast(&acl->acl_rule_entry_ht, key,

				   __prestera_acl_rule_entry_ht_params);

	return IS_ERR(e) ? NULL : e;

}



void prestera_acl_rule_priority_set(struct prestera_acl_rule *rule,

				    u32 priority)

static int __prestera_acl_rule_entry2hw_del(struct prestera_switch *sw,

					    struct prestera_acl_rule_entry *e)

{

	rule->priority = priority;

	return prestera_hw_vtcam_rule_del(sw, e->vtcam_id, e->hw_id);

}



int prestera_acl_rule_match_add(struct prestera_acl_rule *rule,

				struct prestera_acl_rule_match_entry *entry)

static int __prestera_acl_rule_entry2hw_add(struct prestera_switch *sw,

					    struct prestera_acl_rule_entry *e)

{

	struct prestera_acl_rule_match_entry *m_entry;

	struct prestera_acl_hw_action_info act_hw[PRESTERA_ACL_RULE_ACTION_MAX];

	int act_num;



	m_entry = kmalloc(sizeof(*m_entry), GFP_KERNEL);

	if (!m_entry)

		return -ENOMEM;

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

	act_num = 0;



	memcpy(m_entry, entry, sizeof(*entry));

	list_add(&m_entry->list, &rule->match_list);

	/* accept */

	if (e->accept.valid) {

		act_hw[act_num].id = PRESTERA_ACL_RULE_ACTION_ACCEPT;

		act_num++;

	}

	/* drop */

	if (e->drop.valid) {

		act_hw[act_num].id = PRESTERA_ACL_RULE_ACTION_DROP;

		act_num++;

	}

	/* trap */

	if (e->trap.valid) {

		act_hw[act_num].id = PRESTERA_ACL_RULE_ACTION_TRAP;

		act_num++;

	}



	rule->n_matches++;

	return 0;

	return prestera_hw_vtcam_rule_add(sw, e->vtcam_id, e->key.prio,

					  e->key.match.key, e->key.match.mask,

					  act_hw, act_num, &e->hw_id);

}



u8 prestera_acl_rule_match_len(struct prestera_acl_rule *rule)

static void

__prestera_acl_rule_entry_act_destruct(struct prestera_switch *sw,

				       struct prestera_acl_rule_entry *e)

{

	return rule->n_matches;

	/* destroy action entry */

}



void prestera_acl_rule_destroy(struct prestera_acl_rule *rule)

void prestera_acl_rule_entry_destroy(struct prestera_acl *acl,

				     struct prestera_acl_rule_entry *e)

{

	struct prestera_acl_rule_action_entry *a_entry;

	struct prestera_acl_rule_match_entry *m_entry;

	struct list_head *pos, *n;

	int ret;



	list_for_each_safe(pos, n, &rule->match_list) {

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

		list_del(pos);

		kfree(m_entry);

	}

	rhashtable_remove_fast(&acl->acl_rule_entry_ht, &e->ht_node,

			       __prestera_acl_rule_entry_ht_params);



	list_for_each_safe(pos, n, &rule->action_list) {

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

		list_del(pos);

		kfree(a_entry);

	ret = __prestera_acl_rule_entry2hw_del(acl->sw, e);

	WARN_ON(ret && ret != -ENODEV);



	__prestera_acl_rule_entry_act_destruct(acl->sw, e);

	kfree(e);

}



	kfree(rule);

static int

__prestera_acl_rule_entry_act_construct(struct prestera_switch *sw,

					struct prestera_acl_rule_entry *e,

					struct prestera_acl_rule_entry_arg *arg)

{

	/* accept */

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

	/* drop */

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

	/* trap */

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



	return 0;

}



int prestera_acl_rule_add(struct prestera_switch *sw,

			  struct prestera_acl_rule *rule)

struct prestera_acl_rule_entry *

prestera_acl_rule_entry_create(struct prestera_acl *acl,

			       struct prestera_acl_rule_entry_key *key,

			       struct prestera_acl_rule_entry_arg *arg)

{

	u32 rule_id;

	struct prestera_acl_rule_entry *e;

	int err;



	/* try to add rule to hash table first */

	err = rhashtable_insert_fast(&rule->block->ruleset->rule_ht,

				     &rule->ht_node,

				     prestera_acl_rule_ht_params);

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

	if (!e)

		goto err_kzalloc;



	memcpy(&e->key, key, sizeof(*key));

	e->vtcam_id = arg->vtcam_id;

	err = __prestera_acl_rule_entry_act_construct(acl->sw, e, arg);

	if (err)

		return err;

		goto err_act_construct;



	/* add rule to hw */

	err = prestera_hw_acl_rule_add(sw, rule, &rule_id);

	err = __prestera_acl_rule_entry2hw_add(acl->sw, e);

	if (err)

		goto err_rule_add;

		goto err_hw_add;



	rule->id = rule_id;

	err = rhashtable_insert_fast(&acl->acl_rule_entry_ht, &e->ht_node,

				     __prestera_acl_rule_entry_ht_params);

	if (err)

		goto err_ht_insert;



	list_add_tail(&rule->list, &sw->acl->rules);

	return e;



	return 0;

err_ht_insert:

	WARN_ON(__prestera_acl_rule_entry2hw_del(acl->sw, e));

err_hw_add:

	__prestera_acl_rule_entry_act_destruct(acl->sw, e);

err_act_construct:

	kfree(e);

err_kzalloc:

	return NULL;

}



err_rule_add:

	rhashtable_remove_fast(&rule->block->ruleset->rule_ht, &rule->ht_node,

			       prestera_acl_rule_ht_params);

int prestera_acl_vtcam_id_get(struct prestera_acl *acl, u8 lookup,

			      void *keymask, u32 *vtcam_id)

{

	struct prestera_acl_vtcam *vtcam;

	u32 new_vtcam_id;

	int err;



	/* find the vtcam that suits keymask. We do not expect to have

	 * a big number of vtcams, so, the list type for vtcam list is

	 * fine for now

	 */

	list_for_each_entry(vtcam, &acl->vtcam_list, list) {

		if (lookup != vtcam->lookup)

			continue;



		if (!keymask && !vtcam->is_keymask_set) {

			refcount_inc(&vtcam->refcount);

			goto vtcam_found;

		}



		if (keymask && vtcam->is_keymask_set &&

		    !memcmp(keymask, vtcam->keymask, sizeof(vtcam->keymask))) {

			refcount_inc(&vtcam->refcount);

			goto vtcam_found;

		}

	}



	/* vtcam not found, try to create new one */

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

	if (!vtcam)

		return -ENOMEM;



	err = prestera_hw_vtcam_create(acl->sw, lookup, keymask, &new_vtcam_id,

				       PRESTERA_HW_VTCAM_DIR_INGRESS);

	if (err) {

		kfree(vtcam);

		return err;

	}



void prestera_acl_rule_del(struct prestera_switch *sw,

			   struct prestera_acl_rule *rule)

{

	rhashtable_remove_fast(&rule->block->ruleset->rule_ht, &rule->ht_node,

			       prestera_acl_rule_ht_params);

	list_del(&rule->list);

	prestera_hw_acl_rule_del(sw, rule->id);

	vtcam->id = new_vtcam_id;

	vtcam->lookup = lookup;

	if (keymask) {

		memcpy(vtcam->keymask, keymask, sizeof(vtcam->keymask));

		vtcam->is_keymask_set = true;

	}

	refcount_set(&vtcam->refcount, 1);

	list_add_rcu(&vtcam->list, &acl->vtcam_list);



int prestera_acl_rule_get_stats(struct prestera_switch *sw,

				struct prestera_acl_rule *rule,

				u64 *packets, u64 *bytes, u64 *last_use)

vtcam_found:

	*vtcam_id = vtcam->id;

	return 0;

}



int prestera_acl_vtcam_id_put(struct prestera_acl *acl, u32 vtcam_id)

{

	u64 current_packets;

	u64 current_bytes;

	struct prestera_acl_vtcam *vtcam;

	int err;



	err = prestera_hw_acl_rule_stats_get(sw, rule->id, &current_packets,

					     &current_bytes);

	if (err)

		return err;

	list_for_each_entry(vtcam, &acl->vtcam_list, list) {

		if (vtcam_id != vtcam->id)

			continue;



	*packets = current_packets;

	*bytes = current_bytes;

	*last_use = jiffies;

		if (!refcount_dec_and_test(&vtcam->refcount))

			return 0;



		err = prestera_hw_vtcam_destroy(acl->sw, vtcam->id);

		if (err && err != -ENODEV) {

			refcount_set(&vtcam->refcount, 1);

			return err;

		}



		list_del(&vtcam->list);

		kfree(vtcam);

		return 0;

	}



	return -ENOENT;

}



int prestera_acl_init(struct prestera_switch *sw)

{

	struct prestera_acl *acl;

	int err;



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

	if (!acl)

		return -ENOMEM;



	acl->sw = sw;

	INIT_LIST_HEAD(&acl->rules);

	INIT_LIST_HEAD(&acl->vtcam_list);

	idr_init(&acl->uid);



	err = rhashtable_init(&acl->acl_rule_entry_ht,

			      &__prestera_acl_rule_entry_ht_params);

	if (err)

		goto err_acl_rule_entry_ht_init;



	err = rhashtable_init(&acl->ruleset_ht,

			      &prestera_acl_ruleset_ht_params);

	if (err)

		goto err_ruleset_ht_init;



	sw->acl = acl;

	acl->sw = sw;



	return 0;



err_ruleset_ht_init:

	rhashtable_destroy(&acl->acl_rule_entry_ht);

err_acl_rule_entry_ht_init:

	kfree(acl);

	return err;

}



void prestera_acl_fini(struct prestera_switch *sw)

{

	struct prestera_acl *acl = sw->acl;



	WARN_ON(!idr_is_empty(&acl->uid));

	idr_destroy(&acl->uid);



	WARN_ON(!list_empty(&acl->vtcam_list));

	WARN_ON(!list_empty(&acl->rules));



	rhashtable_destroy(&acl->ruleset_ht);

	rhashtable_destroy(&acl->acl_rule_entry_ht);



	kfree(acl);

}

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

+117 −84

File changed.

Preview size limit exceeded, changes collapsed.

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

+95 −6
Original line number Diff line number Diff line
@@ -60,11 +60,100 @@ static int prestera_flow_block_cb(enum tc_setup_type type, 
	}

}



static void prestera_flow_block_destroy(void *cb_priv)

{

	struct prestera_flow_block *block = cb_priv;



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



	kfree(block);

}



static struct prestera_flow_block *

prestera_flow_block_create(struct prestera_switch *sw, struct net *net)

{

	struct prestera_flow_block *block;



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

	if (!block)

		return NULL;



	INIT_LIST_HEAD(&block->binding_list);

	block->net = net;

	block->sw = sw;



	return block;

}



static void prestera_flow_block_release(void *cb_priv)

{

	struct prestera_flow_block *block = cb_priv;



	prestera_acl_block_destroy(block);

	prestera_flow_block_destroy(block);

}



static bool

prestera_flow_block_is_bound(const struct prestera_flow_block *block)

{

	return block->ruleset_zero;

}



static struct prestera_flow_block_binding *

prestera_flow_block_lookup(struct prestera_flow_block *block,

			   struct prestera_port *port)

{

	struct prestera_flow_block_binding *binding;



	list_for_each_entry(binding, &block->binding_list, list)

		if (binding->port == port)

			return binding;



	return NULL;

}



static int prestera_flow_block_bind(struct prestera_flow_block *block,

				    struct prestera_port *port)

{

	struct prestera_flow_block_binding *binding;

	int err;



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

	if (!binding)

		return -ENOMEM;



	binding->span_id = PRESTERA_SPAN_INVALID_ID;

	binding->port = port;



	if (prestera_flow_block_is_bound(block)) {

		err = prestera_acl_ruleset_bind(block->ruleset_zero, port);

		if (err)

			goto err_ruleset_bind;

	}



	list_add(&binding->list, &block->binding_list);

	return 0;



err_ruleset_bind:

	kfree(binding);

	return err;

}



static int prestera_flow_block_unbind(struct prestera_flow_block *block,

				      struct prestera_port *port)

{

	struct prestera_flow_block_binding *binding;



	binding = prestera_flow_block_lookup(block, port);

	if (!binding)

		return -ENOENT;



	list_del(&binding->list);



	if (prestera_flow_block_is_bound(block))

		prestera_acl_ruleset_unbind(block->ruleset_zero, port);



	kfree(binding);

	return 0;

}



static struct prestera_flow_block *
@@ -78,7 +167,7 @@ prestera_flow_block_get(struct prestera_switch *sw, 
	block_cb = flow_block_cb_lookup(f->block,

					prestera_flow_block_cb, sw);

	if (!block_cb) {

		block = prestera_acl_block_create(sw, f->net);

		block = prestera_flow_block_create(sw, f->net);

		if (!block)

			return ERR_PTR(-ENOMEM);
@@ -86,7 +175,7 @@ prestera_flow_block_get(struct prestera_switch *sw, 
					       sw, block,

					       prestera_flow_block_release);

		if (IS_ERR(block_cb)) {

			prestera_acl_block_destroy(block);

			prestera_flow_block_destroy(block);

			return ERR_CAST(block_cb);

		}
@@ -110,7 +199,7 @@ static void prestera_flow_block_put(struct prestera_flow_block *block) 
		return;



	flow_block_cb_free(block_cb);

	prestera_acl_block_destroy(block);

	prestera_flow_block_destroy(block);

}



static int prestera_setup_flow_block_bind(struct prestera_port *port,
@@ -128,7 +217,7 @@ static int prestera_setup_flow_block_bind(struct prestera_port *port, 


	block_cb = block->block_cb;



	err = prestera_acl_block_bind(block, port);

	err = prestera_flow_block_bind(block, port);

	if (err)

		goto err_block_bind;
@@ -162,7 +251,7 @@ static void prestera_setup_flow_block_unbind(struct prestera_port *port, 


	prestera_span_destroy(block);



	err = prestera_acl_block_unbind(block, port);

	err = prestera_flow_block_unbind(block, port);

	if (err)

		goto error;

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

+16 −0

File changed.

Preview size limit exceeded, changes collapsed.

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

+134 −149

File changed.

Preview size limit exceeded, changes collapsed.