Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 4f8768be authored by Jiri Pirko's avatar Jiri Pirko Committed by David S. Miller
Browse files

mlxsw: spectrum: Change KVD linear parts from list to array 



The parts info is array. The parts copy this info array, yet they are a
list. So make the indexing according to the id and change the list of
parts into array of parts. This helps to eliminate lookups and
constructs like mlxsw_sp_kvdl_part_update() (took me some non-trivial
time to figure out what is going on there).
Alongside with that, introduce a helper macro to define the parts infos.

Signed-off-by: default avatarJiri Pirko <jiri@mellanox.com>
Signed-off-by: default avatarIdo Schimmel <idosch@mellanox.com>
Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parent f9b91201

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

+92 −143
Original line number Diff line number Diff line
@@ -55,24 +55,47 @@ 
#define MLXSW_SP_KVDL_LARGE_CHUNKS_END \

	(MLXSW_SP_KVDL_LARGE_CHUNKS_SIZE + MLXSW_SP_KVDL_LARGE_CHUNKS_BASE - 1)



#define MLXSW_SP_CHUNK_MAX 32

#define MLXSW_SP_LARGE_CHUNK_MAX 512

#define MLXSW_SP_KVDL_SINGLE_ALLOC_SIZE 1

#define MLXSW_SP_KVDL_CHUNKS_ALLOC_SIZE 32

#define MLXSW_SP_KVDL_LARGE_CHUNKS_ALLOC_SIZE 512



struct mlxsw_sp_kvdl_part_info {

	unsigned int part_index;

	unsigned int start_index;

	unsigned int end_index;

	unsigned int alloc_size;

	enum mlxsw_sp_resource_id resource_id;

};



enum mlxsw_sp_kvdl_part_id {

	MLXSW_SP_KVDL_PART_ID_SINGLE,

	MLXSW_SP_KVDL_PART_ID_CHUNKS,

	MLXSW_SP_KVDL_PART_ID_LARGE_CHUNKS,

};



#define MLXSW_SP_KVDL_PART_INFO(id)				\

[MLXSW_SP_KVDL_PART_ID_##id] = {				\

	.start_index = MLXSW_SP_KVDL_##id##_BASE,		\

	.end_index = MLXSW_SP_KVDL_##id##_END,			\

	.alloc_size = MLXSW_SP_KVDL_##id##_ALLOC_SIZE,		\

	.resource_id = MLXSW_SP_RESOURCE_KVD_LINEAR_##id,	\

}



static const struct mlxsw_sp_kvdl_part_info mlxsw_sp_kvdl_parts_info[] = {

	MLXSW_SP_KVDL_PART_INFO(SINGLE),

	MLXSW_SP_KVDL_PART_INFO(CHUNKS),

	MLXSW_SP_KVDL_PART_INFO(LARGE_CHUNKS),

};



#define MLXSW_SP_KVDL_PARTS_INFO_LEN ARRAY_SIZE(mlxsw_sp_kvdl_parts_info)



struct mlxsw_sp_kvdl_part {

	struct list_head list;

	struct mlxsw_sp_kvdl_part_info *info;

	struct mlxsw_sp_kvdl_part_info info;

	unsigned long usage[0];	/* Entries */

};



struct mlxsw_sp_kvdl {

	struct list_head parts_list;

	struct mlxsw_sp_kvdl_part *parts[MLXSW_SP_KVDL_PARTS_INFO_LEN];

};



static struct mlxsw_sp_kvdl_part *
@@ -80,11 +103,13 @@ mlxsw_sp_kvdl_alloc_size_part(struct mlxsw_sp_kvdl *kvdl, 
			      unsigned int alloc_size)

{

	struct mlxsw_sp_kvdl_part *part, *min_part = NULL;

	int i;



	list_for_each_entry(part, &kvdl->parts_list, list) {

		if (alloc_size <= part->info->alloc_size &&

	for (i = 0; i < MLXSW_SP_KVDL_PARTS_INFO_LEN; i++) {

		part = kvdl->parts[i];

		if (alloc_size <= part->info.alloc_size &&

		    (!min_part ||

		     part->info->alloc_size <= min_part->info->alloc_size))

		     part->info.alloc_size <= min_part->info.alloc_size))

			min_part = part;

	}
@@ -95,10 +120,12 @@ static struct mlxsw_sp_kvdl_part * 
mlxsw_sp_kvdl_index_part(struct mlxsw_sp_kvdl *kvdl, u32 kvdl_index)

{

	struct mlxsw_sp_kvdl_part *part;

	int i;



	list_for_each_entry(part, &kvdl->parts_list, list) {

		if (kvdl_index >= part->info->start_index &&

		    kvdl_index <= part->info->end_index)

	for (i = 0; i < MLXSW_SP_KVDL_PARTS_INFO_LEN; i++) {

		part = kvdl->parts[i];

		if (kvdl_index >= part->info.start_index &&

		    kvdl_index <= part->info.end_index)

			return part;

	}
@@ -122,7 +149,7 @@ mlxsw_sp_kvdl_index_entry_index(const struct mlxsw_sp_kvdl_part_info *info, 
static int mlxsw_sp_kvdl_part_alloc(struct mlxsw_sp_kvdl_part *part,

				    u32 *p_kvdl_index)

{

	const struct mlxsw_sp_kvdl_part_info *info = part->info;

	const struct mlxsw_sp_kvdl_part_info *info = &part->info;

	unsigned int entry_index, nr_entries;



	nr_entries = (info->end_index - info->start_index + 1) /
@@ -132,8 +159,7 @@ static int mlxsw_sp_kvdl_part_alloc(struct mlxsw_sp_kvdl_part *part, 
		return -ENOBUFS;

	__set_bit(entry_index, part->usage);



	*p_kvdl_index = mlxsw_sp_entry_index_kvdl_index(part->info,

							entry_index);

	*p_kvdl_index = mlxsw_sp_entry_index_kvdl_index(info, entry_index);



	return 0;

}
@@ -141,10 +167,10 @@ static int mlxsw_sp_kvdl_part_alloc(struct mlxsw_sp_kvdl_part *part, 
static void mlxsw_sp_kvdl_part_free(struct mlxsw_sp_kvdl_part *part,

				    u32 kvdl_index)

{

	const struct mlxsw_sp_kvdl_part_info *info = &part->info;

	unsigned int entry_index;



	entry_index = mlxsw_sp_kvdl_index_entry_index(part->info,

						      kvdl_index);

	entry_index = mlxsw_sp_kvdl_index_entry_index(info, kvdl_index);

	__clear_bit(entry_index, part->usage);

}
@@ -183,74 +209,30 @@ int mlxsw_sp_kvdl_alloc_size_query(struct mlxsw_sp *mlxsw_sp, 
	if (IS_ERR(part))

		return PTR_ERR(part);



	*p_alloc_size = part->info->alloc_size;

	*p_alloc_size = part->info.alloc_size;



	return 0;

}



enum mlxsw_sp_kvdl_part_id {

	MLXSW_SP_KVDL_PART_SINGLE,

	MLXSW_SP_KVDL_PART_CHUNKS,

	MLXSW_SP_KVDL_PART_LARGE_CHUNKS,

};



static const struct mlxsw_sp_kvdl_part_info kvdl_parts_info[] = {

	{

		.part_index	= MLXSW_SP_KVDL_PART_SINGLE,

		.start_index	= MLXSW_SP_KVDL_SINGLE_BASE,

		.end_index	= MLXSW_SP_KVDL_SINGLE_END,

		.alloc_size	= 1,

	},

	{

		.part_index	= MLXSW_SP_KVDL_PART_CHUNKS,

		.start_index	= MLXSW_SP_KVDL_CHUNKS_BASE,

		.end_index	= MLXSW_SP_KVDL_CHUNKS_END,

		.alloc_size	= MLXSW_SP_CHUNK_MAX,

	},

	{

		.part_index	= MLXSW_SP_KVDL_PART_LARGE_CHUNKS,

		.start_index	= MLXSW_SP_KVDL_LARGE_CHUNKS_BASE,

		.end_index	= MLXSW_SP_KVDL_LARGE_CHUNKS_END,

		.alloc_size	= MLXSW_SP_LARGE_CHUNK_MAX,

	},

};



static struct mlxsw_sp_kvdl_part *

mlxsw_sp_kvdl_part_find(struct mlxsw_sp *mlxsw_sp, unsigned int part_index)

{

	struct mlxsw_sp_kvdl_part *part;



	list_for_each_entry(part, &mlxsw_sp->kvdl->parts_list, list) {

		if (part->info->part_index == part_index)

			return part;

	}



	return NULL;

}



static void

mlxsw_sp_kvdl_part_update(struct mlxsw_sp *mlxsw_sp,

			  struct mlxsw_sp_kvdl_part *part, unsigned int size)

static void mlxsw_sp_kvdl_part_update(struct mlxsw_sp_kvdl_part *part,

				      struct mlxsw_sp_kvdl_part *part_prev,

				      unsigned int size)

{

	struct mlxsw_sp_kvdl_part_info *info = part->info;



	if (list_is_last(&part->list, &mlxsw_sp->kvdl->parts_list)) {

		info->end_index = size - 1;

	if (!part_prev) {

		part->info.end_index = size - 1;

	} else {

		struct mlxsw_sp_kvdl_part *last_part;



		last_part = list_next_entry(part, list);

		info->start_index = last_part->info->end_index + 1;

		info->end_index = info->start_index + size - 1;

		part->info.start_index = part_prev->info.end_index + 1;

		part->info.end_index = part->info.start_index + size - 1;

	}

}



static int mlxsw_sp_kvdl_part_init(struct mlxsw_sp *mlxsw_sp,

				   unsigned int part_index)

static struct mlxsw_sp_kvdl_part *

mlxsw_sp_kvdl_part_init(struct mlxsw_sp *mlxsw_sp,

			const struct mlxsw_sp_kvdl_part_info *info,

			struct mlxsw_sp_kvdl_part *part_prev)

{

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

	const struct mlxsw_sp_kvdl_part_info *info;

	enum mlxsw_sp_resource_id resource_id;

	struct mlxsw_sp_kvdl_part *part;

	bool need_update = true;

	unsigned int nr_entries;
@@ -258,23 +240,8 @@ static int mlxsw_sp_kvdl_part_init(struct mlxsw_sp *mlxsw_sp, 
	u64 resource_size;

	int err;



	info = &kvdl_parts_info[part_index];



	switch (part_index) {

	case MLXSW_SP_KVDL_PART_SINGLE:

		resource_id = MLXSW_SP_RESOURCE_KVD_LINEAR_SINGLE;

		break;

	case MLXSW_SP_KVDL_PART_CHUNKS:

		resource_id = MLXSW_SP_RESOURCE_KVD_LINEAR_CHUNKS;

		break;

	case MLXSW_SP_KVDL_PART_LARGE_CHUNKS:

		resource_id = MLXSW_SP_RESOURCE_KVD_LINEAR_LARGE_CHUNKS;

		break;

	default:

		return -EINVAL;

	}



	err = devlink_resource_size_get(devlink, resource_id, &resource_size);

	err = devlink_resource_size_get(devlink, info->resource_id,

					&resource_size);

	if (err) {

		need_update = false;

		resource_size = info->end_index - info->start_index + 1;
@@ -284,86 +251,77 @@ static int mlxsw_sp_kvdl_part_init(struct mlxsw_sp *mlxsw_sp, 
	usage_size = BITS_TO_LONGS(nr_entries) * sizeof(unsigned long);

	part = kzalloc(sizeof(*part) + usage_size, GFP_KERNEL);

	if (!part)

		return -ENOMEM;

		return ERR_PTR(-ENOMEM);



	part->info = kmemdup(info, sizeof(*part->info), GFP_KERNEL);

	if (!part->info)

		goto err_part_info_alloc;

	memcpy(&part->info, info, sizeof(part->info));



	list_add(&part->list, &mlxsw_sp->kvdl->parts_list);

	if (need_update)

		mlxsw_sp_kvdl_part_update(mlxsw_sp, part, resource_size);

	return 0;



err_part_info_alloc:

	kfree(part);

	return -ENOMEM;

		mlxsw_sp_kvdl_part_update(part, part_prev, resource_size);

	return part;

}



static void mlxsw_sp_kvdl_part_fini(struct mlxsw_sp *mlxsw_sp,

				    unsigned int part_index)

static void mlxsw_sp_kvdl_part_fini(struct mlxsw_sp_kvdl_part *part)

{

	struct mlxsw_sp_kvdl_part *part;



	part = mlxsw_sp_kvdl_part_find(mlxsw_sp, part_index);

	if (!part)

		return;



	list_del(&part->list);

	kfree(part->info);

	kfree(part);

}



static int mlxsw_sp_kvdl_parts_init(struct mlxsw_sp *mlxsw_sp)

{

	struct mlxsw_sp_kvdl *kvdl = mlxsw_sp->kvdl;

	const struct mlxsw_sp_kvdl_part_info *info;

	struct mlxsw_sp_kvdl_part *part_prev = NULL;

	int err, i;



	INIT_LIST_HEAD(&mlxsw_sp->kvdl->parts_list);



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

		err = mlxsw_sp_kvdl_part_init(mlxsw_sp, i);

		if (err)

	for (i = 0; i < MLXSW_SP_KVDL_PARTS_INFO_LEN; i++) {

		info = &mlxsw_sp_kvdl_parts_info[i];

		kvdl->parts[i] = mlxsw_sp_kvdl_part_init(mlxsw_sp, info,

							 part_prev);

		if (IS_ERR(kvdl->parts[i])) {

			err = PTR_ERR(kvdl->parts[i]);

			goto err_kvdl_part_init;

		}



		part_prev = kvdl->parts[i];

	}

	return 0;



err_kvdl_part_init:

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

		mlxsw_sp_kvdl_part_fini(mlxsw_sp, i);

		mlxsw_sp_kvdl_part_fini(kvdl->parts[i]);

	return err;

}



static void mlxsw_sp_kvdl_parts_fini(struct mlxsw_sp *mlxsw_sp)

{

	struct mlxsw_sp_kvdl *kvdl = mlxsw_sp->kvdl;

	int i;



	for (i = ARRAY_SIZE(kvdl_parts_info) - 1; i >= 0; i--)

		mlxsw_sp_kvdl_part_fini(mlxsw_sp, i);

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

		mlxsw_sp_kvdl_part_fini(kvdl->parts[i]);

}



static u64 mlxsw_sp_kvdl_part_occ(struct mlxsw_sp_kvdl_part *part)

{

	const struct mlxsw_sp_kvdl_part_info *info = &part->info;

	unsigned int nr_entries;

	int bit = -1;

	u64 occ = 0;



	nr_entries = (part->info->end_index -

		      part->info->start_index + 1) /

		      part->info->alloc_size;

	nr_entries = (info->end_index -

		      info->start_index + 1) /

		      info->alloc_size;

	while ((bit = find_next_bit(part->usage, nr_entries, bit + 1))

		< nr_entries)

		occ += part->info->alloc_size;

		occ += info->alloc_size;

	return occ;

}



u64 mlxsw_sp_kvdl_occ_get(const struct mlxsw_sp *mlxsw_sp)

{

	struct mlxsw_sp_kvdl_part *part;

	u64 occ = 0;

	int i;



	list_for_each_entry(part, &mlxsw_sp->kvdl->parts_list, list)

		occ += mlxsw_sp_kvdl_part_occ(part);

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

		occ += mlxsw_sp_kvdl_part_occ(mlxsw_sp->kvdl->parts[i]);



	return occ;

}
@@ -374,10 +332,7 @@ static u64 mlxsw_sp_kvdl_single_occ_get(struct devlink *devlink) 
	struct mlxsw_sp *mlxsw_sp = mlxsw_core_driver_priv(mlxsw_core);

	struct mlxsw_sp_kvdl_part *part;



	part = mlxsw_sp_kvdl_part_find(mlxsw_sp, MLXSW_SP_KVDL_PART_SINGLE);

	if (!part)

		return -EINVAL;



	part = mlxsw_sp->kvdl->parts[MLXSW_SP_KVDL_PART_ID_SINGLE];

	return mlxsw_sp_kvdl_part_occ(part);

}
@@ -387,10 +342,7 @@ static u64 mlxsw_sp_kvdl_chunks_occ_get(struct devlink *devlink) 
	struct mlxsw_sp *mlxsw_sp = mlxsw_core_driver_priv(mlxsw_core);

	struct mlxsw_sp_kvdl_part *part;



	part = mlxsw_sp_kvdl_part_find(mlxsw_sp, MLXSW_SP_KVDL_PART_CHUNKS);

	if (!part)

		return -EINVAL;



	part = mlxsw_sp->kvdl->parts[MLXSW_SP_KVDL_PART_ID_CHUNKS];

	return mlxsw_sp_kvdl_part_occ(part);

}
@@ -400,11 +352,7 @@ static u64 mlxsw_sp_kvdl_large_chunks_occ_get(struct devlink *devlink) 
	struct mlxsw_sp *mlxsw_sp = mlxsw_core_driver_priv(mlxsw_core);

	struct mlxsw_sp_kvdl_part *part;



	part = mlxsw_sp_kvdl_part_find(mlxsw_sp,

				       MLXSW_SP_KVDL_PART_LARGE_CHUNKS);

	if (!part)

		return -EINVAL;



	part = mlxsw_sp->kvdl->parts[MLXSW_SP_KVDL_PART_ID_LARGE_CHUNKS];

	return mlxsw_sp_kvdl_part_occ(part);

}
@@ -431,7 +379,8 @@ int mlxsw_sp_kvdl_resources_register(struct devlink *devlink) 
			MLXSW_CORE_RES_GET(mlxsw_core, KVD_SINGLE_MIN_SIZE) -

			MLXSW_CORE_RES_GET(mlxsw_core, KVD_DOUBLE_MIN_SIZE);



	devlink_resource_size_params_init(&size_params, 0, kvdl_max_size, 1,

	devlink_resource_size_params_init(&size_params, 0, kvdl_max_size,

					  MLXSW_SP_KVDL_SINGLE_ALLOC_SIZE,

					  DEVLINK_RESOURCE_UNIT_ENTRY);

	err = devlink_resource_register(devlink, MLXSW_SP_RESOURCE_NAME_KVD_LINEAR_SINGLES,

					MLXSW_SP_KVDL_SINGLE_SIZE,
@@ -443,7 +392,7 @@ int mlxsw_sp_kvdl_resources_register(struct devlink *devlink) 
		return err;



	devlink_resource_size_params_init(&size_params, 0, kvdl_max_size,

					  MLXSW_SP_CHUNK_MAX,

					  MLXSW_SP_KVDL_CHUNKS_ALLOC_SIZE,

					  DEVLINK_RESOURCE_UNIT_ENTRY);

	err = devlink_resource_register(devlink, MLXSW_SP_RESOURCE_NAME_KVD_LINEAR_CHUNKS,

					MLXSW_SP_KVDL_CHUNKS_SIZE,
@@ -455,7 +404,7 @@ int mlxsw_sp_kvdl_resources_register(struct devlink *devlink) 
		return err;



	devlink_resource_size_params_init(&size_params, 0, kvdl_max_size,

					  MLXSW_SP_LARGE_CHUNK_MAX,

					  MLXSW_SP_KVDL_LARGE_CHUNKS_ALLOC_SIZE,

					  DEVLINK_RESOURCE_UNIT_ENTRY);

	err = devlink_resource_register(devlink, MLXSW_SP_RESOURCE_NAME_KVD_LINEAR_LARGE_CHUNKS,

					MLXSW_SP_KVDL_LARGE_CHUNKS_SIZE,