marvell/prestera/prestera_counter.c

45 prestera_counter_is_ready(struct prestera_counter_block *block, u32 id)
47 	return block->counter_flag[id - block->offset] == COUNTER_FLAG_READY;
60 static void prestera_counter_block_lock(struct prestera_counter_block *block)
62 	mutex_lock(&block->mtx);
65 static void prestera_counter_block_unlock(struct prestera_counter_block *block)
67 	mutex_unlock(&block->mtx);
70 static bool prestera_counter_block_incref(struct prestera_counter_block *block)
72 	return refcount_inc_not_zero(&block->refcnt);
75 static bool prestera_counter_block_decref(struct prestera_counter_block *block)
77 	return refcount_dec_and_test(&block->refcnt);
81 static void prestera_counter_stats_clear(struct prestera_counter_block *block,
84 	memset(&block->stats[counter_id - block->offset], 0,
85 	       sizeof(*block->stats));
110 					   struct prestera_counter_block *block)
121 		counter->block_list[i] = block;
134 	counter->block_list[counter->block_list_len] = block;
143 	struct prestera_counter_block *block;
146 	block = prestera_counter_block_lookup_not_full(counter, client);
147 	if (block)
148 		return block;
150 	block = kzalloc(sizeof(*block), GFP_KERNEL);
151 	if (!block)
155 					    &block->id, &block->offset,
156 					    &block->num_counters);
160 	block->stats = kcalloc(block->num_counters,
161 			       sizeof(*block->stats), GFP_KERNEL);
162 	if (!block->stats) {
167 	block->counter_flag = kcalloc(block->num_counters,
168 				      sizeof(*block->counter_flag),
170 	if (!block->counter_flag) {
175 	block->client = client;
176 	mutex_init(&block->mtx);
177 	refcount_set(&block->refcnt, 1);
178 	idr_init_base(&block->counter_idr, block->offset);
180 	err = prestera_counter_block_list_add(counter, block);
184 	return block;
187 	idr_destroy(&block->counter_idr);
188 	mutex_destroy(&block->mtx);
189 	kfree(block->counter_flag);
191 	kfree(block->stats);
193 	prestera_hw_counter_block_release(counter->sw, block->id);
195 	kfree(block);
200 				       struct prestera_counter_block *block)
204 	if (!prestera_counter_block_decref(block))
210 		    counter->block_list[i]->id == block->id) {
217 	WARN_ON(!idr_is_empty(&block->counter_idr));
219 	prestera_hw_counter_block_release(counter->sw, block->id);
220 	idr_destroy(&block->counter_idr);
221 	mutex_destroy(&block->mtx);
222 	kfree(block->stats);
223 	kfree(block);
226 static int prestera_counter_get_vacant(struct prestera_counter_block *block,
231 	if (block->full)
234 	prestera_counter_block_lock(block);
235 	free_id = idr_alloc_cyclic(&block->counter_idr, NULL, block->offset,
236 				   block->offset + block->num_counters,
240 			block->full = true;
242 		prestera_counter_block_unlock(block);
246 	prestera_counter_block_unlock(block);
254 	struct prestera_counter_block *block;
259 	block = prestera_counter_block_get(counter, client);
260 	if (IS_ERR(block))
261 		return PTR_ERR(block);
263 	err = prestera_counter_get_vacant(block, &id);
265 		prestera_counter_block_put(counter, block);
273 	prestera_counter_block_lock(block);
274 	if (block->is_updating)
275 		block->counter_flag[id - block->offset] = COUNTER_FLAG_INVALID;
276 	prestera_counter_block_unlock(block);
279 	*bl = block;
285 			  struct prestera_counter_block *block, u32 counter_id)
287 	if (!block)
290 	prestera_counter_block_lock(block);
291 	idr_remove(&block->counter_idr, counter_id);
292 	block->full = false;
293 	prestera_counter_stats_clear(block, counter_id);
294 	prestera_counter_block_unlock(block);
296 	prestera_hw_counter_clear(counter->sw, block->id, counter_id);
297 	prestera_counter_block_put(counter, block);
343 	struct prestera_counter_block *block;
350 	block = prestera_counter_block_get_by_idx(counter, counter->curr_idx);
351 	if (!block) {
359 		err = prestera_hw_counter_trigger(counter->sw, block->id);
363 		prestera_counter_block_lock(block);
364 		block->is_updating = true;
365 		prestera_counter_block_unlock(block);
373 	prestera_counter_block_lock(block);
376 				       &block->stats[counter->total_read]);
377 	prestera_counter_block_unlock(block);
382 	if (!done || counter->total_read < block->num_counters) {
387 	for (i = 0; i < block->num_counters; i++) {
388 		if (block->counter_flag[i] == COUNTER_FLAG_INVALID) {
389 			prestera_counter_block_lock(block);
390 			block->counter_flag[i] = COUNTER_FLAG_READY;
391 			memset(&block->stats[i], 0, sizeof(*block->stats));
392 			prestera_counter_block_unlock(block);
396 	prestera_counter_block_lock(block);
397 	block->is_updating = false;
398 	prestera_counter_block_unlock(block);
408 	if (block)
409 		prestera_counter_block_put(counter, block);
418 			       struct prestera_counter_block *block,
421 	if (!block || !prestera_counter_is_ready(block, counter_id)) {
427 	prestera_counter_block_lock(block);
428 	*packets = block->stats[counter_id - block->offset].packets;
429 	*bytes = block->stats[counter_id - block->offset].bytes;
431 	prestera_counter_stats_clear(block, counter_id);
432 	prestera_counter_block_unlock(block);