table: remove deprecated variable size key lru hash tables
[dpdk.git] / lib / librte_eal / common / rte_service.c
1 /*-
2  *   BSD LICENSE
3  *
4  *   Copyright(c) 2017 Intel Corporation. All rights reserved.
5  *   All rights reserved.
6  *
7  *   Redistribution and use in source and binary forms, with or without
8  *   modification, are permitted provided that the following conditions
9  *   are met:
10  *
11  *     * Redistributions of source code must retain the above copyright
12  *       notice, this list of conditions and the following disclaimer.
13  *     * Redistributions in binary form must reproduce the above copyright
14  *       notice, this list of conditions and the following disclaimer in
15  *       the documentation and/or other materials provided with the
16  *       distribution.
17  *     * Neither the name of Intel Corporation nor the names of its
18  *       contributors may be used to endorse or promote products derived
19  *       from this software without specific prior written permission.
20  *
21  *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22  *   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23  *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
24  *   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
25  *   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
26  *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
27  *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
28  *   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
29  *   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
30  *   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
31  *   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
32  */
33
34 #include <stdio.h>
35 #include <unistd.h>
36 #include <inttypes.h>
37 #include <limits.h>
38 #include <string.h>
39 #include <dirent.h>
40
41 #include <rte_service.h>
42 #include "include/rte_service_component.h"
43
44 #include <rte_eal.h>
45 #include <rte_lcore.h>
46 #include <rte_common.h>
47 #include <rte_debug.h>
48 #include <rte_cycles.h>
49 #include <rte_atomic.h>
50 #include <rte_memory.h>
51 #include <rte_malloc.h>
52
53 #define RTE_SERVICE_NUM_MAX 64
54
55 #define SERVICE_F_REGISTERED    (1 << 0)
56 #define SERVICE_F_STATS_ENABLED (1 << 1)
57
58 /* runstates for services and lcores, denoting if they are active or not */
59 #define RUNSTATE_STOPPED 0
60 #define RUNSTATE_RUNNING 1
61
62 /* internal representation of a service */
63 struct rte_service_spec_impl {
64         /* public part of the struct */
65         struct rte_service_spec spec;
66
67         /* atomic lock that when set indicates a service core is currently
68          * running this service callback. When not set, a core may take the
69          * lock and then run the service callback.
70          */
71         rte_atomic32_t execute_lock;
72
73         /* API set/get-able variables */
74         int8_t app_runstate;
75         int8_t comp_runstate;
76         uint8_t internal_flags;
77
78         /* per service statistics */
79         uint32_t num_mapped_cores;
80         uint64_t calls;
81         uint64_t cycles_spent;
82 } __rte_cache_aligned;
83
84 /* the internal values of a service core */
85 struct core_state {
86         /* map of services IDs are run on this core */
87         uint64_t service_mask;
88         uint8_t runstate; /* running or stopped */
89         uint8_t is_service_core; /* set if core is currently a service core */
90
91         /* extreme statistics */
92         uint64_t calls_per_service[RTE_SERVICE_NUM_MAX];
93 } __rte_cache_aligned;
94
95 static uint32_t rte_service_count;
96 static struct rte_service_spec_impl *rte_services;
97 static struct core_state *lcore_states;
98 static uint32_t rte_service_library_initialized;
99
100 int32_t rte_service_init(void)
101 {
102         if (rte_service_library_initialized) {
103                 printf("service library init() called, init flag %d\n",
104                         rte_service_library_initialized);
105                 return -EALREADY;
106         }
107
108         rte_services = rte_calloc("rte_services", RTE_SERVICE_NUM_MAX,
109                         sizeof(struct rte_service_spec_impl),
110                         RTE_CACHE_LINE_SIZE);
111         if (!rte_services) {
112                 printf("error allocating rte services array\n");
113                 return -ENOMEM;
114         }
115
116         lcore_states = rte_calloc("rte_service_core_states", RTE_MAX_LCORE,
117                         sizeof(struct core_state), RTE_CACHE_LINE_SIZE);
118         if (!lcore_states) {
119                 printf("error allocating core states array\n");
120                 return -ENOMEM;
121         }
122
123         int i;
124         int count = 0;
125         struct rte_config *cfg = rte_eal_get_configuration();
126         for (i = 0; i < RTE_MAX_LCORE; i++) {
127                 if (lcore_config[i].core_role == ROLE_SERVICE) {
128                         if ((unsigned int)i == cfg->master_lcore)
129                                 continue;
130                         rte_service_lcore_add(i);
131                         count++;
132                 }
133         }
134
135         rte_service_library_initialized = 1;
136         return 0;
137 }
138
139 /* returns 1 if service is registered and has not been unregistered
140  * Returns 0 if service never registered, or has been unregistered
141  */
142 static inline int
143 service_valid(uint32_t id)
144 {
145         return !!(rte_services[id].internal_flags & SERVICE_F_REGISTERED);
146 }
147
148 /* validate ID and retrieve service pointer, or return error value */
149 #define SERVICE_VALID_GET_OR_ERR_RET(id, service, retval) do {          \
150         if (id >= RTE_SERVICE_NUM_MAX || !service_valid(id))            \
151                 return retval;                                          \
152         service = &rte_services[id];                                    \
153 } while (0)
154
155 /* returns 1 if statistics should be colleced for service
156  * Returns 0 if statistics should not be collected for service
157  */
158 static inline int
159 service_stats_enabled(struct rte_service_spec_impl *impl)
160 {
161         return !!(impl->internal_flags & SERVICE_F_STATS_ENABLED);
162 }
163
164 static inline int
165 service_mt_safe(struct rte_service_spec_impl *s)
166 {
167         return !!(s->spec.capabilities & RTE_SERVICE_CAP_MT_SAFE);
168 }
169
170 int32_t rte_service_set_stats_enable(uint32_t id, int32_t enabled)
171 {
172         struct rte_service_spec_impl *s;
173         SERVICE_VALID_GET_OR_ERR_RET(id, s, 0);
174
175         if (enabled)
176                 s->internal_flags |= SERVICE_F_STATS_ENABLED;
177         else
178                 s->internal_flags &= ~(SERVICE_F_STATS_ENABLED);
179
180         return 0;
181 }
182
183 uint32_t
184 rte_service_get_count(void)
185 {
186         return rte_service_count;
187 }
188
189 int32_t rte_service_get_by_name(const char *name, uint32_t *service_id)
190 {
191         if (!service_id)
192                 return -EINVAL;
193
194         int i;
195         for (i = 0; i < RTE_SERVICE_NUM_MAX; i++) {
196                 if (service_valid(i) &&
197                                 strcmp(name, rte_services[i].spec.name) == 0) {
198                         *service_id = i;
199                         return 0;
200                 }
201         }
202
203         return -ENODEV;
204 }
205
206 const char *
207 rte_service_get_name(uint32_t id)
208 {
209         struct rte_service_spec_impl *s;
210         SERVICE_VALID_GET_OR_ERR_RET(id, s, 0);
211         return s->spec.name;
212 }
213
214 int32_t
215 rte_service_probe_capability(uint32_t id, uint32_t capability)
216 {
217         struct rte_service_spec_impl *s;
218         SERVICE_VALID_GET_OR_ERR_RET(id, s, -EINVAL);
219         return !!(s->spec.capabilities & capability);
220 }
221
222 int32_t
223 rte_service_component_register(const struct rte_service_spec *spec,
224                                uint32_t *id_ptr)
225 {
226         uint32_t i;
227         int32_t free_slot = -1;
228
229         if (spec->callback == NULL || strlen(spec->name) == 0)
230                 return -EINVAL;
231
232         for (i = 0; i < RTE_SERVICE_NUM_MAX; i++) {
233                 if (!service_valid(i)) {
234                         free_slot = i;
235                         break;
236                 }
237         }
238
239         if ((free_slot < 0) || (i == RTE_SERVICE_NUM_MAX))
240                 return -ENOSPC;
241
242         struct rte_service_spec_impl *s = &rte_services[free_slot];
243         s->spec = *spec;
244         s->internal_flags |= SERVICE_F_REGISTERED;
245
246         rte_smp_wmb();
247         rte_service_count++;
248
249         if (id_ptr)
250                 *id_ptr = free_slot;
251
252         return 0;
253 }
254
255 int32_t
256 rte_service_component_unregister(uint32_t id)
257 {
258         uint32_t i;
259         struct rte_service_spec_impl *s;
260         SERVICE_VALID_GET_OR_ERR_RET(id, s, -EINVAL);
261
262         rte_service_count--;
263         rte_smp_wmb();
264
265         s->internal_flags &= ~(SERVICE_F_REGISTERED);
266
267         /* clear the run-bit in all cores */
268         for (i = 0; i < RTE_MAX_LCORE; i++)
269                 lcore_states[i].service_mask &= ~(UINT64_C(1) << id);
270
271         memset(&rte_services[id], 0, sizeof(struct rte_service_spec_impl));
272
273         return 0;
274 }
275
276 int32_t
277 rte_service_component_runstate_set(uint32_t id, uint32_t runstate)
278 {
279         struct rte_service_spec_impl *s;
280         SERVICE_VALID_GET_OR_ERR_RET(id, s, -EINVAL);
281
282         if (runstate)
283                 s->comp_runstate = RUNSTATE_RUNNING;
284         else
285                 s->comp_runstate = RUNSTATE_STOPPED;
286
287         rte_smp_wmb();
288         return 0;
289 }
290
291 int32_t
292 rte_service_runstate_set(uint32_t id, uint32_t runstate)
293 {
294         struct rte_service_spec_impl *s;
295         SERVICE_VALID_GET_OR_ERR_RET(id, s, -EINVAL);
296
297         if (runstate)
298                 s->app_runstate = RUNSTATE_RUNNING;
299         else
300                 s->app_runstate = RUNSTATE_STOPPED;
301
302         rte_smp_wmb();
303         return 0;
304 }
305
306 int32_t
307 rte_service_runstate_get(uint32_t id)
308 {
309         struct rte_service_spec_impl *s;
310         SERVICE_VALID_GET_OR_ERR_RET(id, s, -EINVAL);
311         rte_smp_rmb();
312         return (s->app_runstate == RUNSTATE_RUNNING) &&
313                 (s->comp_runstate == RUNSTATE_RUNNING) &&
314                 (s->num_mapped_cores > 0);
315 }
316
317 static inline void
318 rte_service_runner_do_callback(struct rte_service_spec_impl *s,
319                                struct core_state *cs, uint32_t service_idx)
320 {
321         void *userdata = s->spec.callback_userdata;
322
323         if (service_stats_enabled(s)) {
324                 uint64_t start = rte_rdtsc();
325                 s->spec.callback(userdata);
326                 uint64_t end = rte_rdtsc();
327                 s->cycles_spent += end - start;
328                 cs->calls_per_service[service_idx]++;
329                 s->calls++;
330         } else
331                 s->spec.callback(userdata);
332 }
333
334 static int32_t
335 rte_service_runner_func(void *arg)
336 {
337         RTE_SET_USED(arg);
338         uint32_t i;
339         const int lcore = rte_lcore_id();
340         struct core_state *cs = &lcore_states[lcore];
341
342         while (lcore_states[lcore].runstate == RUNSTATE_RUNNING) {
343                 const uint64_t service_mask = cs->service_mask;
344
345                 for (i = 0; i < RTE_SERVICE_NUM_MAX; i++) {
346                         if (!service_valid(i))
347                                 continue;
348                         struct rte_service_spec_impl *s = &rte_services[i];
349                         if (s->comp_runstate != RUNSTATE_RUNNING ||
350                                         s->app_runstate != RUNSTATE_RUNNING ||
351                                         !(service_mask & (UINT64_C(1) << i)))
352                                 continue;
353
354                         /* check do we need cmpset, if MT safe or <= 1 core
355                          * mapped, atomic ops are not required.
356                          */
357                         const int use_atomics = (service_mt_safe(s) == 0) &&
358                                                 (s->num_mapped_cores > 1);
359                         if (use_atomics) {
360                                 uint32_t *lock = (uint32_t *)&s->execute_lock;
361                                 if (rte_atomic32_cmpset(lock, 0, 1)) {
362                                         rte_service_runner_do_callback(s, cs, i);
363                                         rte_atomic32_clear(&s->execute_lock);
364                                 }
365                         } else
366                                 rte_service_runner_do_callback(s, cs, i);
367                 }
368
369                 rte_smp_rmb();
370         }
371
372         lcore_config[lcore].state = WAIT;
373
374         return 0;
375 }
376
377 int32_t
378 rte_service_lcore_count(void)
379 {
380         int32_t count = 0;
381         uint32_t i;
382         for (i = 0; i < RTE_MAX_LCORE; i++)
383                 count += lcore_states[i].is_service_core;
384         return count;
385 }
386
387 int32_t
388 rte_service_lcore_list(uint32_t array[], uint32_t n)
389 {
390         uint32_t count = rte_service_lcore_count();
391         if (count > n)
392                 return -ENOMEM;
393
394         if (!array)
395                 return -EINVAL;
396
397         uint32_t i;
398         uint32_t idx = 0;
399         for (i = 0; i < RTE_MAX_LCORE; i++) {
400                 struct core_state *cs = &lcore_states[i];
401                 if (cs->is_service_core) {
402                         array[idx] = i;
403                         idx++;
404                 }
405         }
406
407         return count;
408 }
409
410 int32_t
411 rte_service_lcore_count_services(uint32_t lcore)
412 {
413         if (lcore >= RTE_MAX_LCORE)
414                 return -EINVAL;
415
416         struct core_state *cs = &lcore_states[lcore];
417         if (!cs->is_service_core)
418                 return -ENOTSUP;
419
420         return __builtin_popcountll(cs->service_mask);
421 }
422
423 int32_t
424 rte_service_start_with_defaults(void)
425 {
426         /* create a default mapping from cores to services, then start the
427          * services to make them transparent to unaware applications.
428          */
429         uint32_t i;
430         int ret;
431         uint32_t count = rte_service_get_count();
432
433         int32_t lcore_iter = 0;
434         uint32_t ids[RTE_MAX_LCORE] = {0};
435         int32_t lcore_count = rte_service_lcore_list(ids, RTE_MAX_LCORE);
436
437         if (lcore_count == 0)
438                 return -ENOTSUP;
439
440         for (i = 0; (int)i < lcore_count; i++)
441                 rte_service_lcore_start(ids[i]);
442
443         for (i = 0; i < count; i++) {
444                 /* do 1:1 core mapping here, with each service getting
445                  * assigned a single core by default. Adding multiple services
446                  * should multiplex to a single core, or 1:1 if there are the
447                  * same amount of services as service-cores
448                  */
449                 ret = rte_service_map_lcore_set(i, ids[lcore_iter], 1);
450                 if (ret)
451                         return -ENODEV;
452
453                 lcore_iter++;
454                 if (lcore_iter >= lcore_count)
455                         lcore_iter = 0;
456
457                 ret = rte_service_runstate_set(i, 1);
458                 if (ret)
459                         return -ENOEXEC;
460         }
461
462         return 0;
463 }
464
465 static int32_t
466 service_update(struct rte_service_spec *service, uint32_t lcore,
467                 uint32_t *set, uint32_t *enabled)
468 {
469         uint32_t i;
470         int32_t sid = -1;
471
472         for (i = 0; i < RTE_SERVICE_NUM_MAX; i++) {
473                 if ((struct rte_service_spec *)&rte_services[i] == service &&
474                                 service_valid(i)) {
475                         sid = i;
476                         break;
477                 }
478         }
479
480         if (sid == -1 || lcore >= RTE_MAX_LCORE)
481                 return -EINVAL;
482
483         if (!lcore_states[lcore].is_service_core)
484                 return -EINVAL;
485
486         uint64_t sid_mask = UINT64_C(1) << sid;
487         if (set) {
488                 if (*set) {
489                         lcore_states[lcore].service_mask |= sid_mask;
490                         rte_services[sid].num_mapped_cores++;
491                 } else {
492                         lcore_states[lcore].service_mask &= ~(sid_mask);
493                         rte_services[sid].num_mapped_cores--;
494                 }
495         }
496
497         if (enabled)
498                 *enabled = !!(lcore_states[lcore].service_mask & (sid_mask));
499
500         rte_smp_wmb();
501
502         return 0;
503 }
504
505 int32_t
506 rte_service_map_lcore_set(uint32_t id, uint32_t lcore, uint32_t enabled)
507 {
508         struct rte_service_spec_impl *s;
509         SERVICE_VALID_GET_OR_ERR_RET(id, s, -EINVAL);
510         uint32_t on = enabled > 0;
511         return service_update(&s->spec, lcore, &on, 0);
512 }
513
514 int32_t
515 rte_service_map_lcore_get(uint32_t id, uint32_t lcore)
516 {
517         struct rte_service_spec_impl *s;
518         SERVICE_VALID_GET_OR_ERR_RET(id, s, -EINVAL);
519         uint32_t enabled;
520         int ret = service_update(&s->spec, lcore, 0, &enabled);
521         if (ret == 0)
522                 return enabled;
523         return ret;
524 }
525
526 int32_t rte_service_lcore_reset_all(void)
527 {
528         /* loop over cores, reset all to mask 0 */
529         uint32_t i;
530         for (i = 0; i < RTE_MAX_LCORE; i++) {
531                 lcore_states[i].service_mask = 0;
532                 lcore_states[i].is_service_core = 0;
533                 lcore_states[i].runstate = RUNSTATE_STOPPED;
534         }
535         for (i = 0; i < RTE_SERVICE_NUM_MAX; i++)
536                 rte_services[i].num_mapped_cores = 0;
537
538         rte_smp_wmb();
539
540         return 0;
541 }
542
543 static void
544 set_lcore_state(uint32_t lcore, int32_t state)
545 {
546         /* mark core state in hugepage backed config */
547         struct rte_config *cfg = rte_eal_get_configuration();
548         cfg->lcore_role[lcore] = state;
549
550         /* mark state in process local lcore_config */
551         lcore_config[lcore].core_role = state;
552
553         /* update per-lcore optimized state tracking */
554         lcore_states[lcore].is_service_core = (state == ROLE_SERVICE);
555 }
556
557 int32_t
558 rte_service_lcore_add(uint32_t lcore)
559 {
560         if (lcore >= RTE_MAX_LCORE)
561                 return -EINVAL;
562         if (lcore_states[lcore].is_service_core)
563                 return -EALREADY;
564
565         set_lcore_state(lcore, ROLE_SERVICE);
566
567         /* ensure that after adding a core the mask and state are defaults */
568         lcore_states[lcore].service_mask = 0;
569         lcore_states[lcore].runstate = RUNSTATE_STOPPED;
570
571         rte_smp_wmb();
572
573         return rte_eal_wait_lcore(lcore);
574 }
575
576 int32_t
577 rte_service_lcore_del(uint32_t lcore)
578 {
579         if (lcore >= RTE_MAX_LCORE)
580                 return -EINVAL;
581
582         struct core_state *cs = &lcore_states[lcore];
583         if (!cs->is_service_core)
584                 return -EINVAL;
585
586         if (cs->runstate != RUNSTATE_STOPPED)
587                 return -EBUSY;
588
589         set_lcore_state(lcore, ROLE_RTE);
590
591         rte_smp_wmb();
592         return 0;
593 }
594
595 int32_t
596 rte_service_lcore_start(uint32_t lcore)
597 {
598         if (lcore >= RTE_MAX_LCORE)
599                 return -EINVAL;
600
601         struct core_state *cs = &lcore_states[lcore];
602         if (!cs->is_service_core)
603                 return -EINVAL;
604
605         if (cs->runstate == RUNSTATE_RUNNING)
606                 return -EALREADY;
607
608         /* set core to run state first, and then launch otherwise it will
609          * return immediately as runstate keeps it in the service poll loop
610          */
611         lcore_states[lcore].runstate = RUNSTATE_RUNNING;
612
613         int ret = rte_eal_remote_launch(rte_service_runner_func, 0, lcore);
614         /* returns -EBUSY if the core is already launched, 0 on success */
615         return ret;
616 }
617
618 int32_t
619 rte_service_lcore_stop(uint32_t lcore)
620 {
621         if (lcore >= RTE_MAX_LCORE)
622                 return -EINVAL;
623
624         if (lcore_states[lcore].runstate == RUNSTATE_STOPPED)
625                 return -EALREADY;
626
627         uint32_t i;
628         uint64_t service_mask = lcore_states[lcore].service_mask;
629         for (i = 0; i < RTE_SERVICE_NUM_MAX; i++) {
630                 int32_t enabled = service_mask & (UINT64_C(1) << i);
631                 int32_t service_running = rte_service_runstate_get(i);
632                 int32_t only_core = rte_services[i].num_mapped_cores == 1;
633
634                 /* if the core is mapped, and the service is running, and this
635                  * is the only core that is mapped, the service would cease to
636                  * run if this core stopped, so fail instead.
637                  */
638                 if (enabled && service_running && only_core)
639                         return -EBUSY;
640         }
641
642         lcore_states[lcore].runstate = RUNSTATE_STOPPED;
643
644         return 0;
645 }
646
647 static void
648 rte_service_dump_one(FILE *f, struct rte_service_spec_impl *s,
649                      uint64_t all_cycles, uint32_t reset)
650 {
651         /* avoid divide by zero */
652         if (all_cycles == 0)
653                 all_cycles = 1;
654
655         int calls = 1;
656         if (s->calls != 0)
657                 calls = s->calls;
658
659         fprintf(f, "  %s: stats %d\tcalls %"PRIu64"\tcycles %"
660                         PRIu64"\tavg: %"PRIu64"\n",
661                         s->spec.name, service_stats_enabled(s), s->calls,
662                         s->cycles_spent, s->cycles_spent / calls);
663
664         if (reset) {
665                 s->cycles_spent = 0;
666                 s->calls = 0;
667         }
668 }
669
670 static void
671 service_dump_calls_per_lcore(FILE *f, uint32_t lcore, uint32_t reset)
672 {
673         uint32_t i;
674         struct core_state *cs = &lcore_states[lcore];
675
676         fprintf(f, "%02d\t", lcore);
677         for (i = 0; i < RTE_SERVICE_NUM_MAX; i++) {
678                 if (!service_valid(i))
679                         continue;
680                 fprintf(f, "%"PRIu64"\t", cs->calls_per_service[i]);
681                 if (reset)
682                         cs->calls_per_service[i] = 0;
683         }
684         fprintf(f, "\n");
685 }
686
687 int32_t rte_service_dump(FILE *f, uint32_t id)
688 {
689         uint32_t i;
690         int print_one = (id != UINT32_MAX);
691
692         uint64_t total_cycles = 0;
693
694         for (i = 0; i < RTE_SERVICE_NUM_MAX; i++) {
695                 if (!service_valid(i))
696                         continue;
697                 total_cycles += rte_services[i].cycles_spent;
698         }
699
700         /* print only the specified service */
701         if (print_one) {
702                 struct rte_service_spec_impl *s;
703                 SERVICE_VALID_GET_OR_ERR_RET(id, s, -EINVAL);
704                 fprintf(f, "Service %s Summary\n", s->spec.name);
705                 uint32_t reset = 0;
706                 rte_service_dump_one(f, s, total_cycles, reset);
707                 return 0;
708         }
709
710         /* print all services, as UINT32_MAX was passed as id */
711         fprintf(f, "Services Summary\n");
712         for (i = 0; i < RTE_SERVICE_NUM_MAX; i++) {
713                 if (!service_valid(i))
714                         continue;
715                 uint32_t reset = 1;
716                 rte_service_dump_one(f, &rte_services[i], total_cycles, reset);
717         }
718
719         fprintf(f, "Service Cores Summary\n");
720         for (i = 0; i < RTE_MAX_LCORE; i++) {
721                 if (lcore_config[i].core_role != ROLE_SERVICE)
722                         continue;
723
724                 uint32_t reset = 1;
725                 service_dump_calls_per_lcore(f, i, reset);
726         }
727
728         return 0;
729 }