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

Merge branch 'mlxsw-spectrum_cnt-Expose-counter-resources' 



Ido Schimmel says:

====================
mlxsw: spectrum_cnt: Expose counter resources

Jiri says:

Capacity and utilization of existing flow and RIF counters are currently
unavailable to be seen by the user. Use the existing devlink resources
API to expose the information:

$ sudo devlink resource show pci/0000:00:10.0 -v
pci/0000:00:10.0:
  name kvd resource_path /kvd size 524288 unit entry dpipe_tables none
  name span_agents resource_path /span_agents size 8 occ 0 unit entry dpipe_tables none
  name counters resource_path /counters size 79872 occ 44 unit entry dpipe_tables none
    resources:
      name flow resource_path /counters/flow size 61440 occ 4 unit entry dpipe_tables none
      name rif resource_path /counters/rif size 18432 occ 40 unit entry dpipe_tables none
====================

Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parents 8d174351 ee4848ac

drivers/net/ethernet/mellanox/mlxsw/resources.h

+2 −0
Original line number Diff line number Diff line
@@ -18,6 +18,7 @@ enum mlxsw_res_id { 
	MLXSW_RES_ID_CQE_V1,

	MLXSW_RES_ID_CQE_V2,

	MLXSW_RES_ID_COUNTER_POOL_SIZE,

	MLXSW_RES_ID_COUNTER_BANK_SIZE,

	MLXSW_RES_ID_MAX_SPAN,

	MLXSW_RES_ID_COUNTER_SIZE_PACKETS_BYTES,

	MLXSW_RES_ID_COUNTER_SIZE_ROUTER_BASIC,
@@ -75,6 +76,7 @@ static u16 mlxsw_res_ids[] = { 
	[MLXSW_RES_ID_CQE_V1] = 0x2211,

	[MLXSW_RES_ID_CQE_V2] = 0x2212,

	[MLXSW_RES_ID_COUNTER_POOL_SIZE] = 0x2410,

	[MLXSW_RES_ID_COUNTER_BANK_SIZE] = 0x2411,

	[MLXSW_RES_ID_MAX_SPAN] = 0x2420,

	[MLXSW_RES_ID_COUNTER_SIZE_PACKETS_BYTES] = 0x2443,

	[MLXSW_RES_ID_COUNTER_SIZE_ROUTER_BASIC] = 0x2449,

drivers/net/ethernet/mellanox/mlxsw/spectrum.c

+10 −0
Original line number Diff line number Diff line
@@ -5421,8 +5421,13 @@ static int mlxsw_sp1_resources_register(struct mlxsw_core *mlxsw_core) 
	if (err)

		goto err_resources_span_register;



	err = mlxsw_sp_counter_resources_register(mlxsw_core);

	if (err)

		goto err_resources_counter_register;



	return 0;



err_resources_counter_register:

err_resources_span_register:

	devlink_resources_unregister(priv_to_devlink(mlxsw_core), NULL);

	return err;
@@ -5440,8 +5445,13 @@ static int mlxsw_sp2_resources_register(struct mlxsw_core *mlxsw_core) 
	if (err)

		goto err_resources_span_register;



	err = mlxsw_sp_counter_resources_register(mlxsw_core);

	if (err)

		goto err_resources_counter_register;



	return 0;



err_resources_counter_register:

err_resources_span_register:

	devlink_resources_unregister(priv_to_devlink(mlxsw_core), NULL);

	return err;

drivers/net/ethernet/mellanox/mlxsw/spectrum.h

+7 −0
Original line number Diff line number Diff line
@@ -46,6 +46,10 @@ 


#define MLXSW_SP_RESOURCE_NAME_SPAN "span_agents"



#define MLXSW_SP_RESOURCE_NAME_COUNTERS "counters"

#define MLXSW_SP_RESOURCE_NAME_COUNTERS_FLOW "flow"

#define MLXSW_SP_RESOURCE_NAME_COUNTERS_RIF "rif"



enum mlxsw_sp_resource_id {

	MLXSW_SP_RESOURCE_KVD = 1,

	MLXSW_SP_RESOURCE_KVD_LINEAR,
@@ -55,6 +59,9 @@ enum mlxsw_sp_resource_id { 
	MLXSW_SP_RESOURCE_KVD_LINEAR_CHUNKS,

	MLXSW_SP_RESOURCE_KVD_LINEAR_LARGE_CHUNKS,

	MLXSW_SP_RESOURCE_SPAN,

	MLXSW_SP_RESOURCE_COUNTERS,

	MLXSW_SP_RESOURCE_COUNTERS_FLOW,

	MLXSW_SP_RESOURCE_COUNTERS_RIF,

};



struct mlxsw_sp_port;

drivers/net/ethernet/mellanox/mlxsw/spectrum_cnt.c

+181 −62
Original line number Diff line number Diff line
@@ -7,91 +7,143 @@ 


#include "spectrum_cnt.h"



#define MLXSW_SP_COUNTER_POOL_BANK_SIZE 4096



struct mlxsw_sp_counter_sub_pool {

	u64 size;

	unsigned int base_index;

	unsigned int size;

	enum mlxsw_res_id entry_size_res_id;

	const char *resource_name; /* devlink resource name */

	u64 resource_id; /* devlink resource id */

	unsigned int entry_size;

	unsigned int bank_count;

	atomic_t active_entries_count;

};



struct mlxsw_sp_counter_pool {

	unsigned int pool_size;

	u64 pool_size;

	unsigned long *usage; /* Usage bitmap */

	spinlock_t counter_pool_lock; /* Protects counter pool allocations */

	struct mlxsw_sp_counter_sub_pool *sub_pools;

	atomic_t active_entries_count;

	unsigned int sub_pools_count;

	struct mlxsw_sp_counter_sub_pool sub_pools[];

};



static struct mlxsw_sp_counter_sub_pool mlxsw_sp_counter_sub_pools[] = {

static const struct mlxsw_sp_counter_sub_pool mlxsw_sp_counter_sub_pools[] = {

	[MLXSW_SP_COUNTER_SUB_POOL_FLOW] = {

		.entry_size_res_id = MLXSW_RES_ID_COUNTER_SIZE_PACKETS_BYTES,

		.resource_name = MLXSW_SP_RESOURCE_NAME_COUNTERS_FLOW,

		.resource_id = MLXSW_SP_RESOURCE_COUNTERS_FLOW,

		.bank_count = 6,

	},

	[MLXSW_SP_COUNTER_SUB_POOL_RIF] = {

		.entry_size_res_id = MLXSW_RES_ID_COUNTER_SIZE_ROUTER_BASIC,

		.resource_name = MLXSW_SP_RESOURCE_NAME_COUNTERS_RIF,

		.resource_id = MLXSW_SP_RESOURCE_COUNTERS_RIF,

		.bank_count = 2,

	}

};



static int mlxsw_sp_counter_pool_validate(struct mlxsw_sp *mlxsw_sp)

static u64 mlxsw_sp_counter_sub_pool_occ_get(void *priv)

{

	unsigned int total_bank_config = 0;

	unsigned int pool_size;

	int i;

	const struct mlxsw_sp_counter_sub_pool *sub_pool = priv;



	pool_size = MLXSW_CORE_RES_GET(mlxsw_sp->core, COUNTER_POOL_SIZE);

	/* Check config is valid, no bank over subscription */

	for (i = 0; i < ARRAY_SIZE(mlxsw_sp_counter_sub_pools); i++)

		total_bank_config += mlxsw_sp_counter_sub_pools[i].bank_count;

	if (total_bank_config > pool_size / MLXSW_SP_COUNTER_POOL_BANK_SIZE + 1)

		return -EINVAL;

	return 0;

	return atomic_read(&sub_pool->active_entries_count);

}



static int mlxsw_sp_counter_sub_pools_prepare(struct mlxsw_sp *mlxsw_sp)

static int mlxsw_sp_counter_sub_pools_init(struct mlxsw_sp *mlxsw_sp)

{

	struct mlxsw_sp_counter_pool *pool = mlxsw_sp->counter_pool;

	struct devlink *devlink = priv_to_devlink(mlxsw_sp->core);

	struct mlxsw_sp_counter_sub_pool *sub_pool;

	unsigned int base_index = 0;

	enum mlxsw_res_id res_id;

	int err;

	int i;



	/* Prepare generic flow pool*/

	sub_pool = &mlxsw_sp_counter_sub_pools[MLXSW_SP_COUNTER_SUB_POOL_FLOW];

	if (!MLXSW_CORE_RES_VALID(mlxsw_sp->core, COUNTER_SIZE_PACKETS_BYTES))

		return -EIO;

	sub_pool->entry_size = MLXSW_CORE_RES_GET(mlxsw_sp->core,

						  COUNTER_SIZE_PACKETS_BYTES);

	/* Prepare erif pool*/

	sub_pool = &mlxsw_sp_counter_sub_pools[MLXSW_SP_COUNTER_SUB_POOL_RIF];

	if (!MLXSW_CORE_RES_VALID(mlxsw_sp->core, COUNTER_SIZE_ROUTER_BASIC))

	for (i = 0; i < pool->sub_pools_count; i++) {

		sub_pool = &pool->sub_pools[i];

		res_id = sub_pool->entry_size_res_id;



		if (!mlxsw_core_res_valid(mlxsw_sp->core, res_id))

			return -EIO;

	sub_pool->entry_size = MLXSW_CORE_RES_GET(mlxsw_sp->core,

						  COUNTER_SIZE_ROUTER_BASIC);

		sub_pool->entry_size = mlxsw_core_res_get(mlxsw_sp->core,

							  res_id);

		err = devlink_resource_size_get(devlink,

						sub_pool->resource_id,

						&sub_pool->size);

		if (err)

			goto err_resource_size_get;



		devlink_resource_occ_get_register(devlink,

						  sub_pool->resource_id,

						  mlxsw_sp_counter_sub_pool_occ_get,

						  sub_pool);



		sub_pool->base_index = base_index;

		base_index += sub_pool->size;

		atomic_set(&sub_pool->active_entries_count, 0);

	}

	return 0;



err_resource_size_get:

	for (i--; i >= 0; i--) {

		sub_pool = &pool->sub_pools[i];



		devlink_resource_occ_get_unregister(devlink,

						    sub_pool->resource_id);

	}

	return err;

}



int mlxsw_sp_counter_pool_init(struct mlxsw_sp *mlxsw_sp)

static void mlxsw_sp_counter_sub_pools_fini(struct mlxsw_sp *mlxsw_sp)

{

	struct mlxsw_sp_counter_pool *pool = mlxsw_sp->counter_pool;

	struct devlink *devlink = priv_to_devlink(mlxsw_sp->core);

	struct mlxsw_sp_counter_sub_pool *sub_pool;

	struct mlxsw_sp_counter_pool *pool;

	unsigned int base_index;

	unsigned int map_size;

	int i;

	int err;



	if (!MLXSW_CORE_RES_VALID(mlxsw_sp->core, COUNTER_POOL_SIZE))

		return -EIO;

	for (i = 0; i < pool->sub_pools_count; i++) {

		sub_pool = &pool->sub_pools[i];



	err = mlxsw_sp_counter_pool_validate(mlxsw_sp);

	if (err)

		return err;

		WARN_ON(atomic_read(&sub_pool->active_entries_count));

		devlink_resource_occ_get_unregister(devlink,

						    sub_pool->resource_id);

	}

}



	err = mlxsw_sp_counter_sub_pools_prepare(mlxsw_sp);

	if (err)

		return err;

static u64 mlxsw_sp_counter_pool_occ_get(void *priv)

{

	const struct mlxsw_sp_counter_pool *pool = priv;



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

	return atomic_read(&pool->active_entries_count);

}



int mlxsw_sp_counter_pool_init(struct mlxsw_sp *mlxsw_sp)

{

	unsigned int sub_pools_count = ARRAY_SIZE(mlxsw_sp_counter_sub_pools);

	struct devlink *devlink = priv_to_devlink(mlxsw_sp->core);

	struct mlxsw_sp_counter_sub_pool *sub_pool;

	struct mlxsw_sp_counter_pool *pool;

	unsigned int map_size;

	int err;



	pool = kzalloc(struct_size(pool, sub_pools, sub_pools_count),

		       GFP_KERNEL);

	if (!pool)

		return -ENOMEM;

	mlxsw_sp->counter_pool = pool;

	memcpy(pool->sub_pools, mlxsw_sp_counter_sub_pools,

	       sub_pools_count * sizeof(*sub_pool));

	pool->sub_pools_count = sub_pools_count;

	spin_lock_init(&pool->counter_pool_lock);

	atomic_set(&pool->active_entries_count, 0);



	err = devlink_resource_size_get(devlink, MLXSW_SP_RESOURCE_COUNTERS,

					&pool->pool_size);

	if (err)

		goto err_pool_resource_size_get;

	devlink_resource_occ_get_register(devlink, MLXSW_SP_RESOURCE_COUNTERS,

					  mlxsw_sp_counter_pool_occ_get, pool);



	pool->pool_size = MLXSW_CORE_RES_GET(mlxsw_sp->core, COUNTER_POOL_SIZE);

	map_size = BITS_TO_LONGS(pool->pool_size) * sizeof(unsigned long);



	pool->usage = kzalloc(map_size, GFP_KERNEL);
@@ -100,26 +152,18 @@ int mlxsw_sp_counter_pool_init(struct mlxsw_sp *mlxsw_sp) 
		goto err_usage_alloc;

	}



	pool->sub_pools = mlxsw_sp_counter_sub_pools;

	/* Allocation is based on bank count which should be

	 * specified for each sub pool statically.

	 */

	base_index = 0;

	for (i = 0; i < ARRAY_SIZE(mlxsw_sp_counter_sub_pools); i++) {

		sub_pool = &pool->sub_pools[i];

		sub_pool->size = sub_pool->bank_count *

				 MLXSW_SP_COUNTER_POOL_BANK_SIZE;

		sub_pool->base_index = base_index;

		base_index += sub_pool->size;

		/* The last bank can't be fully used */

		if (sub_pool->base_index + sub_pool->size > pool->pool_size)

			sub_pool->size = pool->pool_size - sub_pool->base_index;

	}

	err = mlxsw_sp_counter_sub_pools_init(mlxsw_sp);

	if (err)

		goto err_sub_pools_init;



	mlxsw_sp->counter_pool = pool;

	return 0;



err_sub_pools_init:

	kfree(pool->usage);

err_usage_alloc:

	devlink_resource_occ_get_unregister(devlink,

					    MLXSW_SP_RESOURCE_COUNTERS);

err_pool_resource_size_get:

	kfree(pool);

	return err;

}
@@ -127,10 +171,15 @@ err_usage_alloc: 
void mlxsw_sp_counter_pool_fini(struct mlxsw_sp *mlxsw_sp)

{

	struct mlxsw_sp_counter_pool *pool = mlxsw_sp->counter_pool;

	struct devlink *devlink = priv_to_devlink(mlxsw_sp->core);



	mlxsw_sp_counter_sub_pools_fini(mlxsw_sp);

	WARN_ON(find_first_bit(pool->usage, pool->pool_size) !=

			       pool->pool_size);

	WARN_ON(atomic_read(&pool->active_entries_count));

	kfree(pool->usage);

	devlink_resource_occ_get_unregister(devlink,

					    MLXSW_SP_RESOURCE_COUNTERS);

	kfree(pool);

}
@@ -144,7 +193,7 @@ int mlxsw_sp_counter_alloc(struct mlxsw_sp *mlxsw_sp, 
	unsigned int stop_index;

	int i, err;



	sub_pool = &mlxsw_sp_counter_sub_pools[sub_pool_id];

	sub_pool = &pool->sub_pools[sub_pool_id];

	stop_index = sub_pool->base_index + sub_pool->size;

	entry_index = sub_pool->base_index;
@@ -166,6 +215,8 @@ int mlxsw_sp_counter_alloc(struct mlxsw_sp *mlxsw_sp, 
	spin_unlock(&pool->counter_pool_lock);



	*p_counter_index = entry_index;

	atomic_add(sub_pool->entry_size, &sub_pool->active_entries_count);

	atomic_add(sub_pool->entry_size, &pool->active_entries_count);

	return 0;



err_alloc:
@@ -183,9 +234,77 @@ void mlxsw_sp_counter_free(struct mlxsw_sp *mlxsw_sp, 


	if (WARN_ON(counter_index >= pool->pool_size))

		return;

	sub_pool = &mlxsw_sp_counter_sub_pools[sub_pool_id];

	sub_pool = &pool->sub_pools[sub_pool_id];

	spin_lock(&pool->counter_pool_lock);

	for (i = 0; i < sub_pool->entry_size; i++)

		__clear_bit(counter_index + i, pool->usage);

	spin_unlock(&pool->counter_pool_lock);

	atomic_sub(sub_pool->entry_size, &sub_pool->active_entries_count);

	atomic_sub(sub_pool->entry_size, &pool->active_entries_count);

}



int mlxsw_sp_counter_resources_register(struct mlxsw_core *mlxsw_core)

{

	static struct devlink_resource_size_params size_params;

	struct devlink *devlink = priv_to_devlink(mlxsw_core);

	const struct mlxsw_sp_counter_sub_pool *sub_pool;

	unsigned int total_bank_config;

	u64 sub_pool_size;

	u64 base_index;

	u64 pool_size;

	u64 bank_size;

	int err;

	int i;



	if (!MLXSW_CORE_RES_VALID(mlxsw_core, COUNTER_POOL_SIZE) ||

	    !MLXSW_CORE_RES_VALID(mlxsw_core, COUNTER_BANK_SIZE))

		return -EIO;



	pool_size = MLXSW_CORE_RES_GET(mlxsw_core, COUNTER_POOL_SIZE);

	bank_size = MLXSW_CORE_RES_GET(mlxsw_core, COUNTER_BANK_SIZE);



	devlink_resource_size_params_init(&size_params, pool_size,

					  pool_size, bank_size,

					  DEVLINK_RESOURCE_UNIT_ENTRY);

	err = devlink_resource_register(devlink,

					MLXSW_SP_RESOURCE_NAME_COUNTERS,

					pool_size,

					MLXSW_SP_RESOURCE_COUNTERS,

					DEVLINK_RESOURCE_ID_PARENT_TOP,

					&size_params);

	if (err)

		return err;



	/* Allocation is based on bank count which should be

	 * specified for each sub pool statically.

	 */

	total_bank_config = 0;

	base_index = 0;

	for (i = 0; i < ARRAY_SIZE(mlxsw_sp_counter_sub_pools); i++) {

		sub_pool = &mlxsw_sp_counter_sub_pools[i];

		sub_pool_size = sub_pool->bank_count * bank_size;

		/* The last bank can't be fully used */

		if (base_index + sub_pool_size > pool_size)

			sub_pool_size = pool_size - base_index;

		base_index += sub_pool_size;



		devlink_resource_size_params_init(&size_params, sub_pool_size,

						  sub_pool_size, bank_size,

						  DEVLINK_RESOURCE_UNIT_ENTRY);

		err = devlink_resource_register(devlink,

						sub_pool->resource_name,

						sub_pool_size,

						sub_pool->resource_id,

						MLXSW_SP_RESOURCE_COUNTERS,

						&size_params);

		if (err)

			return err;

		total_bank_config += sub_pool->bank_count;

	}



	/* Check config is valid, no bank over subscription */

	if (WARN_ON(total_bank_config > pool_size / bank_size + 1))

		return -EINVAL;



	return 0;

}

drivers/net/ethernet/mellanox/mlxsw/spectrum_cnt.h

+2 −0
Original line number Diff line number Diff line
@@ -4,6 +4,7 @@ 
#ifndef _MLXSW_SPECTRUM_CNT_H

#define _MLXSW_SPECTRUM_CNT_H



#include "core.h"

#include "spectrum.h"



enum mlxsw_sp_counter_sub_pool_id {
@@ -19,5 +20,6 @@ void mlxsw_sp_counter_free(struct mlxsw_sp *mlxsw_sp, 
			   unsigned int counter_index);

int mlxsw_sp_counter_pool_init(struct mlxsw_sp *mlxsw_sp);

void mlxsw_sp_counter_pool_fini(struct mlxsw_sp *mlxsw_sp);

int mlxsw_sp_counter_resources_register(struct mlxsw_core *mlxsw_core);



#endif

CRA Git | Maintained and supported by SUSTech CRA and CCSE