spectrum_cnt.c

  1// SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0
  2/* Copyright (c) 2017-2018 Mellanox Technologies. All rights reserved */
  3
  4#include <linux/kernel.h>
  5#include <linux/bitops.h>
  6#include <linux/spinlock.h>
  7
  8#include "spectrum_cnt.h"
  9
 10struct mlxsw_sp_counter_sub_pool {
 11	u64 size;
 12	unsigned int base_index;
 13	enum mlxsw_res_id entry_size_res_id;
 14	const char *resource_name; /* devlink resource name */
 15	u64 resource_id; /* devlink resource id */
 16	unsigned int entry_size;
 17	unsigned int bank_count;
 18	atomic_t active_entries_count;
 19};
 20
 21struct mlxsw_sp_counter_pool {
 22	u64 pool_size;
 23	unsigned long *usage; /* Usage bitmap */
 24	spinlock_t counter_pool_lock; /* Protects counter pool allocations */
 25	atomic_t active_entries_count;
 26	unsigned int sub_pools_count;
 27	struct mlxsw_sp_counter_sub_pool sub_pools[] __counted_by(sub_pools_count);
 28};
 29
 30static const struct mlxsw_sp_counter_sub_pool mlxsw_sp_counter_sub_pools[] = {
 31	[MLXSW_SP_COUNTER_SUB_POOL_FLOW] = {
 32		.entry_size_res_id = MLXSW_RES_ID_COUNTER_SIZE_PACKETS_BYTES,
 33		.resource_name = MLXSW_SP_RESOURCE_NAME_COUNTERS_FLOW,
 34		.resource_id = MLXSW_SP_RESOURCE_COUNTERS_FLOW,
 35		.bank_count = 6,
 36	},
 37	[MLXSW_SP_COUNTER_SUB_POOL_RIF] = {
 38		.entry_size_res_id = MLXSW_RES_ID_COUNTER_SIZE_ROUTER_BASIC,
 39		.resource_name = MLXSW_SP_RESOURCE_NAME_COUNTERS_RIF,
 40		.resource_id = MLXSW_SP_RESOURCE_COUNTERS_RIF,
 41		.bank_count = 2,
 42	}
 43};
 44
 45static u64 mlxsw_sp_counter_sub_pool_occ_get(void *priv)
 46{
 47	const struct mlxsw_sp_counter_sub_pool *sub_pool = priv;
 48
 49	return atomic_read(&sub_pool->active_entries_count);
 50}
 51
 52static int mlxsw_sp_counter_sub_pools_init(struct mlxsw_sp *mlxsw_sp)
 53{
 54	struct mlxsw_sp_counter_pool *pool = mlxsw_sp->counter_pool;
 55	struct devlink *devlink = priv_to_devlink(mlxsw_sp->core);
 56	struct mlxsw_sp_counter_sub_pool *sub_pool;
 57	unsigned int base_index = 0;
 58	enum mlxsw_res_id res_id;
 59	int err;
 60	int i;
 61
 62	for (i = 0; i < pool->sub_pools_count; i++) {
 63		sub_pool = &pool->sub_pools[i];
 64		res_id = sub_pool->entry_size_res_id;
 65
 66		if (!mlxsw_core_res_valid(mlxsw_sp->core, res_id))
 67			return -EIO;
 68		sub_pool->entry_size = mlxsw_core_res_get(mlxsw_sp->core,
 69							  res_id);
 70		err = devl_resource_size_get(devlink,
 71					     sub_pool->resource_id,
 72					     &sub_pool->size);
 73		if (err)
 74			goto err_resource_size_get;
 75
 76		devl_resource_occ_get_register(devlink,
 77					       sub_pool->resource_id,
 78					       mlxsw_sp_counter_sub_pool_occ_get,
 79					       sub_pool);
 80
 81		sub_pool->base_index = base_index;
 82		base_index += sub_pool->size;
 83		atomic_set(&sub_pool->active_entries_count, 0);
 84	}
 85	return 0;
 86
 87err_resource_size_get:
 88	for (i--; i >= 0; i--) {
 89		sub_pool = &pool->sub_pools[i];
 90
 91		devl_resource_occ_get_unregister(devlink,
 92						 sub_pool->resource_id);
 93	}
 94	return err;
 95}
 96
 97static void mlxsw_sp_counter_sub_pools_fini(struct mlxsw_sp *mlxsw_sp)
 98{
 99	struct mlxsw_sp_counter_pool *pool = mlxsw_sp->counter_pool;
100	struct devlink *devlink = priv_to_devlink(mlxsw_sp->core);
101	struct mlxsw_sp_counter_sub_pool *sub_pool;
102	int i;
103
104	for (i = 0; i < pool->sub_pools_count; i++) {
105		sub_pool = &pool->sub_pools[i];
106
107		WARN_ON(atomic_read(&sub_pool->active_entries_count));
108		devl_resource_occ_get_unregister(devlink,
109						 sub_pool->resource_id);
110	}
111}
112
113static u64 mlxsw_sp_counter_pool_occ_get(void *priv)
114{
115	const struct mlxsw_sp_counter_pool *pool = priv;
116
117	return atomic_read(&pool->active_entries_count);
118}
119
120int mlxsw_sp_counter_pool_init(struct mlxsw_sp *mlxsw_sp)
121{
122	unsigned int sub_pools_count = ARRAY_SIZE(mlxsw_sp_counter_sub_pools);
123	struct devlink *devlink = priv_to_devlink(mlxsw_sp->core);
124	struct mlxsw_sp_counter_pool *pool;
125	int err;
126
127	pool = kzalloc(struct_size(pool, sub_pools, sub_pools_count),
128		       GFP_KERNEL);
129	if (!pool)
130		return -ENOMEM;
131	mlxsw_sp->counter_pool = pool;
132	pool->sub_pools_count = sub_pools_count;
133	memcpy(pool->sub_pools, mlxsw_sp_counter_sub_pools,
134	       flex_array_size(pool, sub_pools, pool->sub_pools_count));
135	spin_lock_init(&pool->counter_pool_lock);
136	atomic_set(&pool->active_entries_count, 0);
137
138	err = devl_resource_size_get(devlink, MLXSW_SP_RESOURCE_COUNTERS,
139				     &pool->pool_size);
140	if (err)
141		goto err_pool_resource_size_get;
142	devl_resource_occ_get_register(devlink, MLXSW_SP_RESOURCE_COUNTERS,
143				       mlxsw_sp_counter_pool_occ_get, pool);
144
145	pool->usage = bitmap_zalloc(pool->pool_size, GFP_KERNEL);
146	if (!pool->usage) {
147		err = -ENOMEM;
148		goto err_usage_alloc;
149	}
150
151	err = mlxsw_sp_counter_sub_pools_init(mlxsw_sp);
152	if (err)
153		goto err_sub_pools_init;
154
155	return 0;
156
157err_sub_pools_init:
158	bitmap_free(pool->usage);
159err_usage_alloc:
160	devl_resource_occ_get_unregister(devlink,
161					 MLXSW_SP_RESOURCE_COUNTERS);
162err_pool_resource_size_get:
163	kfree(pool);
164	return err;
165}
166
167void mlxsw_sp_counter_pool_fini(struct mlxsw_sp *mlxsw_sp)
168{
169	struct mlxsw_sp_counter_pool *pool = mlxsw_sp->counter_pool;
170	struct devlink *devlink = priv_to_devlink(mlxsw_sp->core);
171
172	mlxsw_sp_counter_sub_pools_fini(mlxsw_sp);
173	WARN_ON(!bitmap_empty(pool->usage, pool->pool_size));
174	WARN_ON(atomic_read(&pool->active_entries_count));
175	bitmap_free(pool->usage);
176	devl_resource_occ_get_unregister(devlink,
177					 MLXSW_SP_RESOURCE_COUNTERS);
178	kfree(pool);
179}
180
181int mlxsw_sp_counter_alloc(struct mlxsw_sp *mlxsw_sp,
182			   enum mlxsw_sp_counter_sub_pool_id sub_pool_id,
183			   unsigned int *p_counter_index)
184{
185	struct mlxsw_sp_counter_pool *pool = mlxsw_sp->counter_pool;
186	struct mlxsw_sp_counter_sub_pool *sub_pool;
187	unsigned int entry_index;
188	unsigned int stop_index;
189	int i, err;
190
191	sub_pool = &pool->sub_pools[sub_pool_id];
192	stop_index = sub_pool->base_index + sub_pool->size;
193	entry_index = sub_pool->base_index;
194
195	spin_lock(&pool->counter_pool_lock);
196	entry_index = find_next_zero_bit(pool->usage, stop_index, entry_index);
197	if (entry_index == stop_index) {
198		err = -ENOBUFS;
199		goto err_alloc;
200	}
201	/* The sub-pools can contain non-integer number of entries
202	 * so we must check for overflow
203	 */
204	if (entry_index + sub_pool->entry_size > stop_index) {
205		err = -ENOBUFS;
206		goto err_alloc;
207	}
208	for (i = 0; i < sub_pool->entry_size; i++)
209		__set_bit(entry_index + i, pool->usage);
210	spin_unlock(&pool->counter_pool_lock);
211
212	*p_counter_index = entry_index;
213	atomic_add(sub_pool->entry_size, &sub_pool->active_entries_count);
214	atomic_add(sub_pool->entry_size, &pool->active_entries_count);
215	return 0;
216
217err_alloc:
218	spin_unlock(&pool->counter_pool_lock);
219	return err;
220}
221
222void mlxsw_sp_counter_free(struct mlxsw_sp *mlxsw_sp,
223			   enum mlxsw_sp_counter_sub_pool_id sub_pool_id,
224			   unsigned int counter_index)
225{
226	struct mlxsw_sp_counter_pool *pool = mlxsw_sp->counter_pool;
227	struct mlxsw_sp_counter_sub_pool *sub_pool;
228	int i;
229
230	if (WARN_ON(counter_index >= pool->pool_size))
231		return;
232	sub_pool = &pool->sub_pools[sub_pool_id];
233	spin_lock(&pool->counter_pool_lock);
234	for (i = 0; i < sub_pool->entry_size; i++)
235		__clear_bit(counter_index + i, pool->usage);
236	spin_unlock(&pool->counter_pool_lock);
237	atomic_sub(sub_pool->entry_size, &sub_pool->active_entries_count);
238	atomic_sub(sub_pool->entry_size, &pool->active_entries_count);
239}
240
241int mlxsw_sp_counter_resources_register(struct mlxsw_core *mlxsw_core)
242{
243	static struct devlink_resource_size_params size_params;
244	struct devlink *devlink = priv_to_devlink(mlxsw_core);
245	const struct mlxsw_sp_counter_sub_pool *sub_pool;
246	unsigned int total_bank_config;
247	u64 sub_pool_size;
248	u64 base_index;
249	u64 pool_size;
250	u64 bank_size;
251	int err;
252	int i;
253
254	if (!MLXSW_CORE_RES_VALID(mlxsw_core, COUNTER_POOL_SIZE) ||
255	    !MLXSW_CORE_RES_VALID(mlxsw_core, COUNTER_BANK_SIZE))
256		return -EIO;
257
258	pool_size = MLXSW_CORE_RES_GET(mlxsw_core, COUNTER_POOL_SIZE);
259	bank_size = MLXSW_CORE_RES_GET(mlxsw_core, COUNTER_BANK_SIZE);
260
261	devlink_resource_size_params_init(&size_params, pool_size,
262					  pool_size, bank_size,
263					  DEVLINK_RESOURCE_UNIT_ENTRY);
264	err = devl_resource_register(devlink,
265				     MLXSW_SP_RESOURCE_NAME_COUNTERS,
266				     pool_size,
267				     MLXSW_SP_RESOURCE_COUNTERS,
268				     DEVLINK_RESOURCE_ID_PARENT_TOP,
269				     &size_params);
270	if (err)
271		return err;
272
273	/* Allocation is based on bank count which should be
274	 * specified for each sub pool statically.
275	 */
276	total_bank_config = 0;
277	base_index = 0;
278	for (i = 0; i < ARRAY_SIZE(mlxsw_sp_counter_sub_pools); i++) {
279		sub_pool = &mlxsw_sp_counter_sub_pools[i];
280		sub_pool_size = sub_pool->bank_count * bank_size;
281		/* The last bank can't be fully used */
282		if (base_index + sub_pool_size > pool_size)
283			sub_pool_size = pool_size - base_index;
284		base_index += sub_pool_size;
285
286		devlink_resource_size_params_init(&size_params, sub_pool_size,
287						  sub_pool_size, bank_size,
288						  DEVLINK_RESOURCE_UNIT_ENTRY);
289		err = devl_resource_register(devlink,
290					     sub_pool->resource_name,
291					     sub_pool_size,
292					     sub_pool->resource_id,
293					     MLXSW_SP_RESOURCE_COUNTERS,
294					     &size_params);
295		if (err)
296			return err;
297		total_bank_config += sub_pool->bank_count;
298	}
299
300	/* Check config is valid, no bank over subscription */
301	if (WARN_ON(total_bank_config > div64_u64(pool_size, bank_size) + 1))
302		return -EINVAL;
303
304	return 0;
305}