Branch data Line data Source code
1 : : /* SPDX-License-Identifier: BSD-3-Clause
2 : : *
3 : : * Copyright (c) 2010-2015 Intel Corporation
4 : : * Copyright (c) 2007,2008 Kip Macy kmacy@freebsd.org
5 : : * All rights reserved.
6 : : * Derived from FreeBSD's bufring.h
7 : : * Used as BSD-3 Licensed with permission from Kip Macy.
8 : : */
9 : :
10 : : #include <stdalign.h>
11 : : #include <stdio.h>
12 : : #include <string.h>
13 : : #include <stdint.h>
14 : : #include <inttypes.h>
15 : : #include <errno.h>
16 : : #include <sys/queue.h>
17 : :
18 : : #include <eal_export.h>
19 : : #include <rte_common.h>
20 : : #include <rte_log.h>
21 : : #include <rte_memzone.h>
22 : : #include <rte_malloc.h>
23 : : #include <rte_eal_memconfig.h>
24 : : #include <rte_errno.h>
25 : : #include <rte_string_fns.h>
26 : : #include <rte_tailq.h>
27 : : #include <rte_telemetry.h>
28 : : #include <rte_bitops.h>
29 : :
30 : : #include "rte_ring.h"
31 : : #include "rte_ring_elem.h"
32 : :
33 [ - + ]: 254 : RTE_LOG_REGISTER_DEFAULT(ring_logtype, INFO);
34 : : #define RTE_LOGTYPE_RING ring_logtype
35 : : #define RING_LOG(level, ...) \
36 : : RTE_LOG_LINE(level, RING, "" __VA_ARGS__)
37 : :
38 : : TAILQ_HEAD(rte_ring_list, rte_tailq_entry);
39 : :
40 : : static struct rte_tailq_elem rte_ring_tailq = {
41 : : .name = RTE_TAILQ_RING_NAME,
42 : : };
43 [ - + ]: 254 : EAL_REGISTER_TAILQ(rte_ring_tailq)
44 : :
45 : : /* mask of all valid flag values to ring_create() */
46 : : #define RING_F_MASK (RING_F_SP_ENQ | RING_F_SC_DEQ | RING_F_EXACT_SZ | \
47 : : RING_F_MP_RTS_ENQ | RING_F_MC_RTS_DEQ | \
48 : : RING_F_MP_HTS_ENQ | RING_F_MC_HTS_DEQ)
49 : :
50 : : /* by default set head/tail distance as 1/8 of ring capacity */
51 : : #define HTD_MAX_DEF 8
52 : :
53 : : /* return the size of memory occupied by a ring */
54 : : RTE_EXPORT_SYMBOL(rte_ring_get_memsize_elem)
55 : : ssize_t
56 : 4679 : rte_ring_get_memsize_elem(unsigned int esize, unsigned int count)
57 : : {
58 : : ssize_t sz;
59 : :
60 : : /* Check if element size is a multiple of 4B */
61 [ + + ]: 4679 : if (esize % 4 != 0) {
62 : 1 : RING_LOG(ERR, "element size is not a multiple of 4");
63 : :
64 : 1 : return -EINVAL;
65 : : }
66 : :
67 : : /* count must be a power of 2 */
68 [ + + + + : 4678 : if ((!RTE_IS_POWER_OF_2(count)) || (count > RTE_RING_SZ_MASK)) {
+ + ]
69 : 19 : RING_LOG(ERR,
70 : : "Requested number of elements is invalid, must be power of 2, and not exceed %u",
71 : : RTE_RING_SZ_MASK);
72 : :
73 : 19 : return -EINVAL;
74 : : }
75 : :
76 : 4659 : sz = sizeof(struct rte_ring) + (ssize_t)count * esize;
77 : 4659 : sz = RTE_ALIGN(sz, RTE_CACHE_LINE_SIZE);
78 : 4659 : return sz;
79 : : }
80 : :
81 : : /* return the size of memory occupied by a ring */
82 : : RTE_EXPORT_SYMBOL(rte_ring_get_memsize)
83 : : ssize_t
84 : 0 : rte_ring_get_memsize(unsigned int count)
85 : : {
86 : 0 : return rte_ring_get_memsize_elem(sizeof(void *), count);
87 : : }
88 : :
89 : : /*
90 : : * internal helper function to reset prod/cons head-tail values.
91 : : */
92 : : static void
93 : : reset_headtail(void *p)
94 : : {
95 : : struct rte_ring_headtail *ht;
96 : : struct rte_ring_hts_headtail *ht_hts;
97 : : struct rte_ring_rts_headtail *ht_rts;
98 : :
99 : : ht = p;
100 : : ht_hts = p;
101 : : ht_rts = p;
102 : :
103 : 40 : switch (ht->sync_type) {
104 : 40 : case RTE_RING_SYNC_MT:
105 : : case RTE_RING_SYNC_ST:
106 : 40 : ht->head = 0;
107 : 40 : ht->tail = 0;
108 : 40 : break;
109 : 0 : case RTE_RING_SYNC_MT_RTS:
110 : 0 : ht_rts->head.raw = 0;
111 : 0 : ht_rts->tail.raw = 0;
112 : 0 : break;
113 : 0 : case RTE_RING_SYNC_MT_HTS:
114 : 0 : ht_hts->ht.raw = 0;
115 : 0 : break;
116 [ + - - - ]: 20 : default:
117 : : /* unknown sync mode */
118 : : RTE_ASSERT(0);
119 : : }
120 : : }
121 : :
122 : : RTE_EXPORT_SYMBOL(rte_ring_reset)
123 : : void
124 [ + - - - ]: 20 : rte_ring_reset(struct rte_ring *r)
125 : : {
126 : : reset_headtail(&r->prod);
127 : : reset_headtail(&r->cons);
128 : 20 : }
129 : :
130 : : /*
131 : : * helper function, calculates sync_type values for prod and cons
132 : : * based on input flags. Returns zero at success or negative
133 : : * errno value otherwise.
134 : : */
135 : : static int
136 : 4638 : get_sync_type(uint32_t flags, enum rte_ring_sync_type *prod_st,
137 : : enum rte_ring_sync_type *cons_st)
138 : : {
139 : : static const uint32_t prod_st_flags =
140 : : (RING_F_SP_ENQ | RING_F_MP_RTS_ENQ | RING_F_MP_HTS_ENQ);
141 : : static const uint32_t cons_st_flags =
142 : : (RING_F_SC_DEQ | RING_F_MC_RTS_DEQ | RING_F_MC_HTS_DEQ);
143 : :
144 [ + + + + : 4638 : switch (flags & prod_st_flags) {
- ]
145 : 354 : case 0:
146 : 354 : *prod_st = RTE_RING_SYNC_MT;
147 : 354 : break;
148 : 4151 : case RING_F_SP_ENQ:
149 : 4151 : *prod_st = RTE_RING_SYNC_ST;
150 : 4151 : break;
151 : 53 : case RING_F_MP_RTS_ENQ:
152 : 53 : *prod_st = RTE_RING_SYNC_MT_RTS;
153 : 53 : break;
154 : 80 : case RING_F_MP_HTS_ENQ:
155 : 80 : *prod_st = RTE_RING_SYNC_MT_HTS;
156 : 80 : break;
157 : : default:
158 : : return -EINVAL;
159 : : }
160 : :
161 [ + + + + : 4638 : switch (flags & cons_st_flags) {
- ]
162 : 355 : case 0:
163 : 355 : *cons_st = RTE_RING_SYNC_MT;
164 : 355 : break;
165 : 4147 : case RING_F_SC_DEQ:
166 : 4147 : *cons_st = RTE_RING_SYNC_ST;
167 : 4147 : break;
168 : 40 : case RING_F_MC_RTS_DEQ:
169 : 40 : *cons_st = RTE_RING_SYNC_MT_RTS;
170 : 40 : break;
171 : 96 : case RING_F_MC_HTS_DEQ:
172 : 96 : *cons_st = RTE_RING_SYNC_MT_HTS;
173 : 96 : break;
174 : : default:
175 : : return -EINVAL;
176 : : }
177 : :
178 : : return 0;
179 : : }
180 : :
181 : : RTE_EXPORT_SYMBOL(rte_ring_init)
182 : : int
183 : 4638 : rte_ring_init(struct rte_ring *r, const char *name, unsigned int count,
184 : : unsigned int flags)
185 : : {
186 : : int ret;
187 : :
188 : : /* compilation-time checks */
189 : : RTE_BUILD_BUG_ON((sizeof(struct rte_ring) &
190 : : RTE_CACHE_LINE_MASK) != 0);
191 : : RTE_BUILD_BUG_ON((offsetof(struct rte_ring, cons) &
192 : : RTE_CACHE_LINE_MASK) != 0);
193 : : RTE_BUILD_BUG_ON((offsetof(struct rte_ring, prod) &
194 : : RTE_CACHE_LINE_MASK) != 0);
195 : :
196 : : RTE_BUILD_BUG_ON(offsetof(struct rte_ring_headtail, sync_type) !=
197 : : offsetof(struct rte_ring_hts_headtail, sync_type));
198 : : RTE_BUILD_BUG_ON(offsetof(struct rte_ring_headtail, tail) !=
199 : : offsetof(struct rte_ring_hts_headtail, ht.pos.tail));
200 : :
201 : : RTE_BUILD_BUG_ON(offsetof(struct rte_ring_headtail, sync_type) !=
202 : : offsetof(struct rte_ring_rts_headtail, sync_type));
203 : : RTE_BUILD_BUG_ON(offsetof(struct rte_ring_headtail, tail) !=
204 : : offsetof(struct rte_ring_rts_headtail, tail.val.pos));
205 : :
206 : : /* future proof flags, only allow supported values */
207 [ - + ]: 4638 : if (flags & ~RING_F_MASK) {
208 : 0 : RING_LOG(ERR,
209 : : "Unsupported flags requested %#x", flags);
210 : 0 : return -EINVAL;
211 : : }
212 : :
213 : : /* init the ring structure */
214 : : memset(r, 0, sizeof(*r));
215 [ + - ]: 4638 : ret = strlcpy(r->name, name, sizeof(r->name));
216 [ + - ]: 4638 : if (ret < 0 || ret >= (int)sizeof(r->name))
217 : : return -ENAMETOOLONG;
218 : 4638 : r->flags = flags;
219 : 4638 : ret = get_sync_type(flags, &r->prod.sync_type, &r->cons.sync_type);
220 [ + - ]: 4638 : if (ret != 0)
221 : : return ret;
222 : :
223 [ + + ]: 4638 : if (flags & RING_F_EXACT_SZ) {
224 : 238 : r->size = rte_align32pow2(count + 1);
225 : 238 : r->mask = r->size - 1;
226 : 238 : r->capacity = count;
227 : : } else {
228 [ + - + - : 4400 : if ((!RTE_IS_POWER_OF_2(count)) || (count > RTE_RING_SZ_MASK)) {
- + ]
229 : 0 : RING_LOG(ERR,
230 : : "Requested size is invalid, must be power of 2, and not exceed the size limit %u",
231 : : RTE_RING_SZ_MASK);
232 : 0 : return -EINVAL;
233 : : }
234 : 4400 : r->size = count;
235 : 4400 : r->mask = count - 1;
236 : 4400 : r->capacity = r->mask;
237 : : }
238 : :
239 : : /* set default values for head-tail distance */
240 [ + + ]: 4638 : if (flags & RING_F_MP_RTS_ENQ)
241 [ + - ]: 53 : rte_ring_set_prod_htd_max(r, r->capacity / HTD_MAX_DEF);
242 [ + + ]: 4638 : if (flags & RING_F_MC_RTS_DEQ)
243 [ + - ]: 40 : rte_ring_set_cons_htd_max(r, r->capacity / HTD_MAX_DEF);
244 : :
245 : : return 0;
246 : : }
247 : :
248 : : /* create the ring for a given element size */
249 : : RTE_EXPORT_SYMBOL(rte_ring_create_elem)
250 : : struct rte_ring *
251 : 4680 : rte_ring_create_elem(const char *name, unsigned int esize, unsigned int count,
252 : : int socket_id, unsigned int flags)
253 : : {
254 : : char mz_name[RTE_MEMZONE_NAMESIZE];
255 : : struct rte_ring *r;
256 : : struct rte_tailq_entry *te;
257 : : const struct rte_memzone *mz;
258 : : ssize_t ring_size;
259 : : int mz_flags = 0;
260 : : struct rte_ring_list* ring_list = NULL;
261 : : const unsigned int requested_count = count;
262 : : int ret;
263 : :
264 : 4680 : ring_list = RTE_TAILQ_CAST(rte_ring_tailq.head, rte_ring_list);
265 : :
266 : : /* for an exact size ring, round up from count to a power of two */
267 [ + + ]: 4680 : if (flags & RING_F_EXACT_SZ)
268 : : count = rte_align32pow2(count + 1);
269 : :
270 : 4680 : ring_size = rte_ring_get_memsize_elem(esize, count);
271 [ + + ]: 4681 : if (ring_size < 0) {
272 : 20 : rte_errno = -ring_size;
273 : 20 : return NULL;
274 : : }
275 : :
276 : : ret = snprintf(mz_name, sizeof(mz_name), "%s%s",
277 : : RTE_RING_MZ_PREFIX, name);
278 [ - + ]: 4661 : if (ret < 0 || ret >= (int)sizeof(mz_name)) {
279 : 0 : rte_errno = ENAMETOOLONG;
280 : 0 : return NULL;
281 : : }
282 : :
283 : 4661 : te = rte_zmalloc("RING_TAILQ_ENTRY", sizeof(*te), 0);
284 [ - + ]: 4661 : if (te == NULL) {
285 : 0 : RING_LOG(ERR, "Cannot reserve memory for tailq");
286 : 0 : rte_errno = ENOMEM;
287 : 0 : return NULL;
288 : : }
289 : :
290 : 4661 : rte_mcfg_tailq_write_lock();
291 : :
292 : : /* reserve a memory zone for this ring. If we can't get rte_config or
293 : : * we are secondary process, the memzone_reserve function will set
294 : : * rte_errno for us appropriately - hence no check in this function
295 : : */
296 : 4661 : mz = rte_memzone_reserve_aligned(mz_name, ring_size, socket_id,
297 : : mz_flags, alignof(typeof(*r)));
298 [ + + ]: 4661 : if (mz != NULL) {
299 : 4638 : r = mz->addr;
300 : : /* no need to check return value here, we already checked the
301 : : * arguments above */
302 : 4638 : rte_ring_init(r, name, requested_count, flags);
303 : :
304 : 4638 : te->data = (void *) r;
305 : 4638 : r->memzone = mz;
306 : :
307 : 4638 : TAILQ_INSERT_TAIL(ring_list, te, next);
308 : : } else {
309 : : r = NULL;
310 : 23 : RING_LOG(ERR, "Cannot reserve memory");
311 : 23 : rte_free(te);
312 : : }
313 : 4661 : rte_mcfg_tailq_write_unlock();
314 : :
315 : 4661 : return r;
316 : : }
317 : :
318 : : /* create the ring */
319 : : RTE_EXPORT_SYMBOL(rte_ring_create)
320 : : struct rte_ring *
321 : 4030 : rte_ring_create(const char *name, unsigned int count, int socket_id,
322 : : unsigned int flags)
323 : : {
324 : 4030 : return rte_ring_create_elem(name, sizeof(void *), count, socket_id,
325 : : flags);
326 : : }
327 : :
328 : : /* free the ring */
329 : : RTE_EXPORT_SYMBOL(rte_ring_free)
330 : : void
331 : 4924 : rte_ring_free(struct rte_ring *r)
332 : : {
333 : : struct rte_ring_list *ring_list = NULL;
334 : : struct rte_tailq_entry *te;
335 : :
336 [ + + ]: 4924 : if (r == NULL)
337 : : return;
338 : :
339 : : /*
340 : : * Ring was not created with rte_ring_create,
341 : : * therefore, there is no memzone to free.
342 : : */
343 [ - + ]: 4597 : if (r->memzone == NULL) {
344 : 0 : RING_LOG(ERR,
345 : : "Cannot free ring, not created with rte_ring_create()");
346 : 0 : return;
347 : : }
348 : :
349 : 4597 : ring_list = RTE_TAILQ_CAST(rte_ring_tailq.head, rte_ring_list);
350 : 4597 : rte_mcfg_tailq_write_lock();
351 : :
352 : : /* find out tailq entry */
353 [ + - ]: 20411 : TAILQ_FOREACH(te, ring_list, next) {
354 [ + + ]: 20411 : if (te->data == (void *) r)
355 : : break;
356 : : }
357 : :
358 [ - + ]: 4597 : if (te == NULL) {
359 : 0 : rte_mcfg_tailq_write_unlock();
360 : 0 : return;
361 : : }
362 : :
363 [ + + ]: 4597 : TAILQ_REMOVE(ring_list, te, next);
364 : :
365 : 4597 : rte_mcfg_tailq_write_unlock();
366 : :
367 [ - + ]: 4597 : if (rte_memzone_free(r->memzone) != 0)
368 : 0 : RING_LOG(ERR, "Cannot free memory");
369 : :
370 : 4597 : rte_free(te);
371 : : }
372 : :
373 : : static const char *
374 : : ring_get_sync_type(const enum rte_ring_sync_type st)
375 : : {
376 : 6 : switch (st) {
377 : : case RTE_RING_SYNC_ST:
378 : : return "ST";
379 : 5 : case RTE_RING_SYNC_MT:
380 : 5 : return "MT";
381 : 0 : case RTE_RING_SYNC_MT_RTS:
382 : 0 : return "MT_RTS";
383 : 0 : case RTE_RING_SYNC_MT_HTS:
384 : 0 : return "MT_HTS";
385 : 0 : default:
386 : 0 : return "unknown";
387 : : }
388 : : }
389 : :
390 : : static void
391 : 6 : ring_dump_ht_headtail(FILE *f, const char *prefix,
392 : : const struct rte_ring_headtail *ht)
393 : : {
394 : : fprintf(f, "%ssync_type=%s\n", prefix,
395 [ + - - - : 6 : ring_get_sync_type(ht->sync_type));
+ ]
396 : 6 : fprintf(f, "%shead=%"PRIu32"\n", prefix, ht->head);
397 : 6 : fprintf(f, "%stail=%"PRIu32"\n", prefix, ht->tail);
398 : 6 : }
399 : :
400 : : static void
401 : 0 : ring_dump_rts_headtail(FILE *f, const char *prefix,
402 : : const struct rte_ring_rts_headtail *rts)
403 : : {
404 : : fprintf(f, "%ssync_type=%s\n", prefix,
405 [ # # # # : 0 : ring_get_sync_type(rts->sync_type));
# ]
406 : 0 : fprintf(f, "%shead.pos=%"PRIu32"\n", prefix, rts->head.val.pos);
407 : 0 : fprintf(f, "%shead.cnt=%"PRIu32"\n", prefix, rts->head.val.cnt);
408 : 0 : fprintf(f, "%stail.pos=%"PRIu32"\n", prefix, rts->tail.val.pos);
409 : 0 : fprintf(f, "%stail.cnt=%"PRIu32"\n", prefix, rts->tail.val.cnt);
410 : 0 : fprintf(f, "%shtd_max=%"PRIu32"\n", prefix, rts->htd_max);
411 : 0 : }
412 : :
413 : : static void
414 : 0 : ring_dump_hts_headtail(FILE *f, const char *prefix,
415 : : const struct rte_ring_hts_headtail *hts)
416 : : {
417 : : fprintf(f, "%ssync_type=%s\n", prefix,
418 [ # # # # : 0 : ring_get_sync_type(hts->sync_type));
# ]
419 : 0 : fprintf(f, "%shead=%"PRIu32"\n", prefix, hts->ht.pos.head);
420 : 0 : fprintf(f, "%stail=%"PRIu32"\n", prefix, hts->ht.pos.tail);
421 : 0 : }
422 : :
423 : : RTE_EXPORT_EXPERIMENTAL_SYMBOL(rte_ring_headtail_dump, 25.03)
424 : : void
425 : 6 : rte_ring_headtail_dump(FILE *f, const char *prefix,
426 : : const struct rte_ring_headtail *r)
427 : : {
428 [ + - ]: 6 : if (f == NULL || r == NULL)
429 : : return;
430 : :
431 [ - + ]: 6 : prefix = (prefix != NULL) ? prefix : "";
432 : :
433 [ + - - - ]: 6 : switch (r->sync_type) {
434 : 6 : case RTE_RING_SYNC_ST:
435 : : case RTE_RING_SYNC_MT:
436 : 6 : ring_dump_ht_headtail(f, prefix, r);
437 : 6 : break;
438 : 0 : case RTE_RING_SYNC_MT_RTS:
439 : 0 : ring_dump_rts_headtail(f, prefix,
440 : : (const struct rte_ring_rts_headtail *)r);
441 : 0 : break;
442 : 0 : case RTE_RING_SYNC_MT_HTS:
443 : 0 : ring_dump_hts_headtail(f, prefix,
444 : : (const struct rte_ring_hts_headtail *)r);
445 : 0 : break;
446 : 0 : default:
447 : 0 : RING_LOG(ERR, "Invalid ring sync type detected");
448 : : }
449 : : }
450 : :
451 : : /* dump the status of the ring on the console */
452 : : RTE_EXPORT_SYMBOL(rte_ring_dump)
453 : : void
454 : 1 : rte_ring_dump(FILE *f, const struct rte_ring *r)
455 : : {
456 [ + - ]: 1 : if (f == NULL || r == NULL)
457 : : return;
458 : :
459 : 1 : fprintf(f, "ring <%s>@%p\n", r->name, r);
460 : 1 : fprintf(f, " flags=%x\n", r->flags);
461 : 1 : fprintf(f, " size=%"PRIu32"\n", r->size);
462 : 1 : fprintf(f, " capacity=%"PRIu32"\n", r->capacity);
463 : : fprintf(f, " used=%u\n", rte_ring_count(r));
464 : : fprintf(f, " avail=%u\n", rte_ring_free_count(r));
465 : :
466 : 1 : rte_ring_headtail_dump(f, " cons.", &(r->cons));
467 : 1 : rte_ring_headtail_dump(f, " prod.", &(r->prod));
468 : : }
469 : :
470 : : /* dump the status of all rings on the console */
471 : : RTE_EXPORT_SYMBOL(rte_ring_list_dump)
472 : : void
473 : 1 : rte_ring_list_dump(FILE *f)
474 : : {
475 : : const struct rte_tailq_entry *te;
476 : : struct rte_ring_list *ring_list;
477 : :
478 : 1 : ring_list = RTE_TAILQ_CAST(rte_ring_tailq.head, rte_ring_list);
479 : :
480 : 1 : rte_mcfg_tailq_read_lock();
481 : :
482 [ - + ]: 1 : TAILQ_FOREACH(te, ring_list, next) {
483 : 0 : rte_ring_dump(f, (struct rte_ring *) te->data);
484 : : }
485 : :
486 : 1 : rte_mcfg_tailq_read_unlock();
487 : 1 : }
488 : :
489 : : /* search a ring from its name */
490 : : RTE_EXPORT_SYMBOL(rte_ring_lookup)
491 : : struct rte_ring *
492 : 4073 : rte_ring_lookup(const char *name)
493 : : {
494 : : struct rte_tailq_entry *te;
495 : : struct rte_ring *r = NULL;
496 : : struct rte_ring_list *ring_list;
497 : :
498 : 4073 : ring_list = RTE_TAILQ_CAST(rte_ring_tailq.head, rte_ring_list);
499 : :
500 : 4073 : rte_mcfg_tailq_read_lock();
501 : :
502 [ + + ]: 47190 : TAILQ_FOREACH(te, ring_list, next) {
503 : 43302 : r = (struct rte_ring *) te->data;
504 [ + + ]: 43302 : if (strncmp(name, r->name, RTE_RING_NAMESIZE) == 0)
505 : : break;
506 : : }
507 : :
508 : 4073 : rte_mcfg_tailq_read_unlock();
509 : :
510 [ + + ]: 4073 : if (te == NULL) {
511 : 3888 : rte_errno = ENOENT;
512 : 3888 : return NULL;
513 : : }
514 : :
515 : : return r;
516 : : }
517 : :
518 : : static void
519 : 5 : ring_walk(void (*func)(struct rte_ring *, void *), void *arg)
520 : : {
521 : : struct rte_ring_list *ring_list;
522 : : struct rte_tailq_entry *tailq_entry;
523 : :
524 : 5 : ring_list = RTE_TAILQ_CAST(rte_ring_tailq.head, rte_ring_list);
525 : 5 : rte_mcfg_tailq_read_lock();
526 : :
527 [ - + ]: 5 : TAILQ_FOREACH(tailq_entry, ring_list, next) {
528 : 0 : (*func)((struct rte_ring *) tailq_entry->data, arg);
529 : : }
530 : :
531 : 5 : rte_mcfg_tailq_read_unlock();
532 : 5 : }
533 : :
534 : : static void
535 : 0 : ring_list_cb(struct rte_ring *r, void *arg)
536 : : {
537 : : struct rte_tel_data *d = (struct rte_tel_data *)arg;
538 : :
539 : 0 : rte_tel_data_add_array_string(d, r->name);
540 : 0 : }
541 : :
542 : : static int
543 : 3 : ring_handle_list(const char *cmd __rte_unused,
544 : : const char *params __rte_unused, struct rte_tel_data *d)
545 : : {
546 : 3 : rte_tel_data_start_array(d, RTE_TEL_STRING_VAL);
547 : 3 : ring_walk(ring_list_cb, d);
548 : 3 : return 0;
549 : : }
550 : :
551 : : static const char *
552 : : ring_prod_sync_type_to_name(struct rte_ring *r)
553 : : {
554 [ # # # # : 0 : switch (r->prod.sync_type) {
# ]
555 : : case RTE_RING_SYNC_MT:
556 : : return "MP";
557 : 0 : case RTE_RING_SYNC_ST:
558 : 0 : return "SP";
559 : 0 : case RTE_RING_SYNC_MT_RTS:
560 : 0 : return "MP_RTS";
561 : 0 : case RTE_RING_SYNC_MT_HTS:
562 : 0 : return "MP_HTS";
563 : 0 : default:
564 : 0 : return "Unknown";
565 : : }
566 : : }
567 : :
568 : : static const char *
569 : : ring_cons_sync_type_to_name(struct rte_ring *r)
570 : : {
571 [ # # # # : 0 : switch (r->cons.sync_type) {
# ]
572 : : case RTE_RING_SYNC_MT:
573 : : return "MC";
574 : 0 : case RTE_RING_SYNC_ST:
575 : 0 : return "SC";
576 : 0 : case RTE_RING_SYNC_MT_RTS:
577 : 0 : return "MC_RTS";
578 : 0 : case RTE_RING_SYNC_MT_HTS:
579 : 0 : return "MC_HTS";
580 : 0 : default:
581 : 0 : return "Unknown";
582 : : }
583 : : }
584 : :
585 : : struct ring_info_cb_arg {
586 : : char *ring_name;
587 : : struct rte_tel_data *d;
588 : : };
589 : :
590 : : static void
591 : 0 : ring_info_cb(struct rte_ring *r, void *arg)
592 : : {
593 : : struct ring_info_cb_arg *ring_arg = (struct ring_info_cb_arg *)arg;
594 : 0 : struct rte_tel_data *d = ring_arg->d;
595 : : const struct rte_memzone *mz;
596 : :
597 [ # # ]: 0 : if (strncmp(r->name, ring_arg->ring_name, RTE_RING_NAMESIZE))
598 : : return;
599 : :
600 : 0 : rte_tel_data_add_dict_string(d, "name", r->name);
601 : 0 : rte_tel_data_add_dict_int(d, "socket", r->memzone->socket_id);
602 : 0 : rte_tel_data_add_dict_int(d, "flags", r->flags);
603 : 0 : rte_tel_data_add_dict_string(d, "producer_type",
604 : : ring_prod_sync_type_to_name(r));
605 : 0 : rte_tel_data_add_dict_string(d, "consumer_type",
606 : : ring_cons_sync_type_to_name(r));
607 : 0 : rte_tel_data_add_dict_uint(d, "size", r->size);
608 : 0 : rte_tel_data_add_dict_uint_hex(d, "mask", r->mask, 0);
609 : 0 : rte_tel_data_add_dict_uint(d, "capacity", r->capacity);
610 : 0 : rte_tel_data_add_dict_uint(d, "used_count", rte_ring_count(r));
611 : :
612 : 0 : mz = r->memzone;
613 [ # # ]: 0 : if (mz == NULL)
614 : : return;
615 : 0 : rte_tel_data_add_dict_string(d, "mz_name", mz->name);
616 : 0 : rte_tel_data_add_dict_uint(d, "mz_len", mz->len);
617 : 0 : rte_tel_data_add_dict_uint(d, "mz_hugepage_sz", mz->hugepage_sz);
618 : 0 : rte_tel_data_add_dict_int(d, "mz_socket_id", mz->socket_id);
619 : 0 : rte_tel_data_add_dict_uint_hex(d, "mz_flags", mz->flags, 0);
620 : : }
621 : :
622 : : static int
623 : 3 : ring_handle_info(const char *cmd __rte_unused, const char *params,
624 : : struct rte_tel_data *d)
625 : : {
626 : 3 : char name[RTE_RING_NAMESIZE] = {0};
627 : : struct ring_info_cb_arg ring_arg;
628 : :
629 [ + + + - ]: 3 : if (params == NULL || strlen(params) == 0 ||
630 [ + - ]: 2 : strlen(params) >= RTE_RING_NAMESIZE)
631 : : return -EINVAL;
632 : :
633 : : rte_strlcpy(name, params, RTE_RING_NAMESIZE);
634 : :
635 : 2 : ring_arg.ring_name = name;
636 : 2 : ring_arg.d = d;
637 : :
638 : 2 : rte_tel_data_start_dict(d);
639 : 2 : ring_walk(ring_info_cb, &ring_arg);
640 : :
641 : 2 : return 0;
642 : : }
643 : :
644 : 254 : RTE_INIT(ring_init_telemetry)
645 : : {
646 : 254 : rte_telemetry_register_cmd("/ring/list", ring_handle_list,
647 : : "Returns list of available rings. Takes no parameters");
648 : 254 : rte_telemetry_register_cmd("/ring/info", ring_handle_info,
649 : : "Returns ring info. Parameters: ring_name.");
650 : 254 : }
|
