1 /* SPDX-License-Identifier: BSD-3-Clause
2 * Copyright (C) 2020 Marvell International Ltd.
4 #include <rte_bitmap.h>
5 #include <rte_ethdev.h>
6 #include <rte_eventdev.h>
7 #include <rte_event_eth_rx_adapter.h>
8 #include <rte_event_eth_tx_adapter.h>
9 #include <rte_malloc.h>
12 #include "event_helper.h"
13 #include "ipsec-secgw.h"
15 #define DEFAULT_VECTOR_SIZE 16
16 #define DEFAULT_VECTOR_TMO 102400
18 static volatile bool eth_core_running;
21 eh_get_enabled_cores(struct rte_bitmap *eth_core_mask)
25 RTE_LCORE_FOREACH(i) {
26 /* Check if this core is enabled in core mask*/
27 if (rte_bitmap_get(eth_core_mask, i)) {
28 /* Found enabled core */
35 static inline unsigned int
36 eh_get_next_eth_core(struct eventmode_conf *em_conf)
38 static unsigned int prev_core = -1;
39 unsigned int next_core;
42 * Make sure we have at least one eth core running, else the following
43 * logic would lead to an infinite loop.
45 if (eh_get_enabled_cores(em_conf->eth_core_mask) == 0) {
46 EH_LOG_ERR("No enabled eth core found");
50 /* Only some cores are marked as eth cores, skip others */
52 /* Get the next core */
53 next_core = rte_get_next_lcore(prev_core, 0, 1);
55 /* Check if we have reached max lcores */
56 if (next_core == RTE_MAX_LCORE)
59 /* Update prev_core */
60 prev_core = next_core;
61 } while (!(rte_bitmap_get(em_conf->eth_core_mask, next_core)));
66 static inline unsigned int
67 eh_get_next_active_core(struct eventmode_conf *em_conf, unsigned int prev_core)
69 unsigned int next_core;
71 /* Get next active core skipping cores reserved as eth cores */
73 /* Get the next core */
74 next_core = rte_get_next_lcore(prev_core, 0, 0);
76 /* Check if we have reached max lcores */
77 if (next_core == RTE_MAX_LCORE)
80 prev_core = next_core;
81 } while (rte_bitmap_get(em_conf->eth_core_mask, next_core));
86 static struct eventdev_params *
87 eh_get_eventdev_params(struct eventmode_conf *em_conf, uint8_t eventdev_id)
91 for (i = 0; i < em_conf->nb_eventdev; i++) {
92 if (em_conf->eventdev_config[i].eventdev_id == eventdev_id)
97 if (i == em_conf->nb_eventdev)
100 return &(em_conf->eventdev_config[i]);
104 eh_dev_has_rx_internal_port(uint8_t eventdev_id)
109 RTE_ETH_FOREACH_DEV(j) {
112 ret = rte_event_eth_rx_adapter_caps_get(eventdev_id, j, &caps);
116 if (!(caps & RTE_EVENT_ETH_RX_ADAPTER_CAP_INTERNAL_PORT))
123 eh_dev_has_tx_internal_port(uint8_t eventdev_id)
128 RTE_ETH_FOREACH_DEV(j) {
131 ret = rte_event_eth_tx_adapter_caps_get(eventdev_id, j, &caps);
135 if (!(caps & RTE_EVENT_ETH_TX_ADAPTER_CAP_INTERNAL_PORT))
142 eh_dev_has_burst_mode(uint8_t dev_id)
144 struct rte_event_dev_info dev_info;
146 rte_event_dev_info_get(dev_id, &dev_info);
147 return (dev_info.event_dev_cap & RTE_EVENT_DEV_CAP_BURST_MODE) ?
152 eh_set_default_conf_eventdev(struct eventmode_conf *em_conf)
154 int lcore_count, nb_eventdev, nb_eth_dev, ret;
155 struct eventdev_params *eventdev_config;
156 struct rte_event_dev_info dev_info;
158 /* Get the number of event devices */
159 nb_eventdev = rte_event_dev_count();
160 if (nb_eventdev == 0) {
161 EH_LOG_ERR("No event devices detected");
165 if (nb_eventdev != 1) {
166 EH_LOG_ERR("Event mode does not support multiple event devices. "
167 "Please provide only one event device.");
171 /* Get the number of eth devs */
172 nb_eth_dev = rte_eth_dev_count_avail();
173 if (nb_eth_dev == 0) {
174 EH_LOG_ERR("No eth devices detected");
178 /* Get the number of lcores */
179 lcore_count = rte_lcore_count();
181 /* Read event device info */
182 ret = rte_event_dev_info_get(0, &dev_info);
184 EH_LOG_ERR("Failed to read event device info %d", ret);
188 /* Check if enough ports are available */
189 if (dev_info.max_event_ports < 2) {
190 EH_LOG_ERR("Not enough event ports available");
194 /* Get the first event dev conf */
195 eventdev_config = &(em_conf->eventdev_config[0]);
197 /* Save number of queues & ports available */
198 eventdev_config->eventdev_id = 0;
199 eventdev_config->nb_eventqueue = dev_info.max_event_queues;
200 eventdev_config->nb_eventport = dev_info.max_event_ports;
201 eventdev_config->ev_queue_mode = RTE_EVENT_QUEUE_CFG_ALL_TYPES;
203 /* Check if there are more queues than required */
204 if (eventdev_config->nb_eventqueue > nb_eth_dev + 1) {
205 /* One queue is reserved for Tx */
206 eventdev_config->nb_eventqueue = nb_eth_dev + 1;
209 /* Check if there are more ports than required */
210 if (eventdev_config->nb_eventport > lcore_count) {
211 /* One port per lcore is enough */
212 eventdev_config->nb_eventport = lcore_count;
215 /* Update the number of event devices */
216 em_conf->nb_eventdev++;
222 eh_do_capability_check(struct eventmode_conf *em_conf)
224 struct eventdev_params *eventdev_config;
225 int all_internal_ports = 1;
226 uint32_t eventdev_id;
229 for (i = 0; i < em_conf->nb_eventdev; i++) {
231 /* Get the event dev conf */
232 eventdev_config = &(em_conf->eventdev_config[i]);
233 eventdev_id = eventdev_config->eventdev_id;
235 /* Check if event device has internal port for Rx & Tx */
236 if (eh_dev_has_rx_internal_port(eventdev_id) &&
237 eh_dev_has_tx_internal_port(eventdev_id)) {
238 eventdev_config->all_internal_ports = 1;
240 all_internal_ports = 0;
245 * If Rx & Tx internal ports are supported by all event devices then
246 * eth cores won't be required. Override the eth core mask requested
247 * and decrement number of event queues by one as it won't be needed
250 if (all_internal_ports) {
251 rte_bitmap_reset(em_conf->eth_core_mask);
252 for (i = 0; i < em_conf->nb_eventdev; i++)
253 em_conf->eventdev_config[i].nb_eventqueue--;
258 eh_set_default_conf_link(struct eventmode_conf *em_conf)
260 struct eventdev_params *eventdev_config;
261 struct eh_event_link_info *link;
262 unsigned int lcore_id = -1;
266 * Create a 1:1 mapping from event ports to cores. If the number
267 * of event ports is lesser than the cores, some cores won't
268 * execute worker. If there are more event ports, then some ports
274 * The event queue-port mapping is done according to the link. Since
275 * we are falling back to the default link config, enabling
276 * "all_ev_queue_to_ev_port" mode flag. This will map all queues
279 em_conf->ext_params.all_ev_queue_to_ev_port = 1;
281 /* Get first event dev conf */
282 eventdev_config = &(em_conf->eventdev_config[0]);
284 /* Loop through the ports */
285 for (i = 0; i < eventdev_config->nb_eventport; i++) {
287 /* Get next active core id */
288 lcore_id = eh_get_next_active_core(em_conf,
291 if (lcore_id == RTE_MAX_LCORE) {
292 /* Reached max cores */
296 /* Save the current combination as one link */
299 link_index = em_conf->nb_link;
301 /* Get the corresponding link */
302 link = &(em_conf->link[link_index]);
305 link->eventdev_id = eventdev_config->eventdev_id;
306 link->event_port_id = i;
307 link->lcore_id = lcore_id;
310 * Don't set eventq_id as by default all queues
311 * need to be mapped to the port, which is controlled
312 * by the operating mode.
315 /* Update number of links */
323 eh_set_default_conf_rx_adapter(struct eventmode_conf *em_conf)
325 struct rx_adapter_connection_info *conn;
326 struct eventdev_params *eventdev_config;
327 struct rx_adapter_conf *adapter;
328 bool rx_internal_port = true;
329 bool single_ev_queue = false;
339 /* Create one adapter with eth queues mapped to event queue(s) */
341 if (em_conf->nb_eventdev == 0) {
342 EH_LOG_ERR("No event devs registered");
346 /* Get the number of eth devs */
347 nb_eth_dev = rte_eth_dev_count_avail();
349 /* Use the first event dev */
350 eventdev_config = &(em_conf->eventdev_config[0]);
352 /* Get eventdev ID */
353 eventdev_id = eventdev_config->eventdev_id;
356 /* Get adapter conf */
357 adapter = &(em_conf->rx_adapter[adapter_id]);
359 /* Set adapter conf */
360 adapter->eventdev_id = eventdev_id;
361 adapter->adapter_id = adapter_id;
364 * If event device does not have internal ports for passing
365 * packets then reserved one queue for Tx path
367 nb_eventqueue = eventdev_config->all_internal_ports ?
368 eventdev_config->nb_eventqueue :
369 eventdev_config->nb_eventqueue - 1;
372 * Map all queues of eth device (port) to an event queue. If there
373 * are more event queues than eth ports then create 1:1 mapping.
374 * Otherwise map all eth ports to a single event queue.
376 if (nb_eth_dev > nb_eventqueue)
377 single_ev_queue = true;
379 for (i = 0; i < nb_eth_dev; i++) {
381 /* Use only the ports enabled */
382 if ((em_conf->eth_portmask & (1 << i)) == 0)
385 /* Get the connection id */
386 conn_id = adapter->nb_connections;
388 /* Get the connection */
389 conn = &(adapter->conn[conn_id]);
391 /* Set mapping between eth ports & event queues*/
393 conn->eventq_id = single_ev_queue ? 0 : i;
395 /* Add all eth queues eth port to event queue */
396 conn->ethdev_rx_qid = -1;
398 /* Get Rx adapter capabilities */
399 ret = rte_event_eth_rx_adapter_caps_get(eventdev_id, i, &caps);
401 EH_LOG_ERR("Failed to get event device %d eth rx adapter"
402 " capabilities for port %d", eventdev_id, i);
405 if (!(caps & RTE_EVENT_ETH_RX_ADAPTER_CAP_INTERNAL_PORT))
406 rx_internal_port = false;
408 /* Update no of connections */
409 adapter->nb_connections++;
413 if (rx_internal_port) {
414 /* Rx core is not required */
415 adapter->rx_core_id = -1;
417 /* Rx core is required */
418 adapter->rx_core_id = eh_get_next_eth_core(em_conf);
421 /* We have setup one adapter */
422 em_conf->nb_rx_adapter = 1;
428 eh_set_default_conf_tx_adapter(struct eventmode_conf *em_conf)
430 struct tx_adapter_connection_info *conn;
431 struct eventdev_params *eventdev_config;
432 struct tx_adapter_conf *tx_adapter;
433 bool tx_internal_port = true;
443 * Create one Tx adapter with all eth queues mapped to event queues
447 if (em_conf->nb_eventdev == 0) {
448 EH_LOG_ERR("No event devs registered");
452 /* Get the number of eth devs */
453 nb_eth_dev = rte_eth_dev_count_avail();
455 /* Use the first event dev */
456 eventdev_config = &(em_conf->eventdev_config[0]);
458 /* Get eventdev ID */
459 eventdev_id = eventdev_config->eventdev_id;
462 /* Get adapter conf */
463 tx_adapter = &(em_conf->tx_adapter[adapter_id]);
465 /* Set adapter conf */
466 tx_adapter->eventdev_id = eventdev_id;
467 tx_adapter->adapter_id = adapter_id;
470 * Map all Tx queues of the eth device (port) to the event device.
473 /* Set defaults for connections */
476 * One eth device (port) is one connection. Map all Tx queues
477 * of the device to the Tx adapter.
480 for (i = 0; i < nb_eth_dev; i++) {
482 /* Use only the ports enabled */
483 if ((em_conf->eth_portmask & (1 << i)) == 0)
486 /* Get the connection id */
487 conn_id = tx_adapter->nb_connections;
489 /* Get the connection */
490 conn = &(tx_adapter->conn[conn_id]);
492 /* Add ethdev to connections */
495 /* Add all eth tx queues to adapter */
496 conn->ethdev_tx_qid = -1;
498 /* Get Tx adapter capabilities */
499 ret = rte_event_eth_tx_adapter_caps_get(eventdev_id, i, &caps);
501 EH_LOG_ERR("Failed to get event device %d eth tx adapter"
502 " capabilities for port %d", eventdev_id, i);
505 if (!(caps & RTE_EVENT_ETH_TX_ADAPTER_CAP_INTERNAL_PORT))
506 tx_internal_port = false;
508 /* Update no of connections */
509 tx_adapter->nb_connections++;
512 if (tx_internal_port) {
513 /* Tx core is not required */
514 tx_adapter->tx_core_id = -1;
516 /* Tx core is required */
517 tx_adapter->tx_core_id = eh_get_next_eth_core(em_conf);
520 * Use one event queue per adapter for submitting packets
521 * for Tx. Reserving the last queue available
523 /* Queue numbers start at 0 */
524 tx_adapter->tx_ev_queue = eventdev_config->nb_eventqueue - 1;
527 /* We have setup one adapter */
528 em_conf->nb_tx_adapter = 1;
533 eh_validate_conf(struct eventmode_conf *em_conf)
538 * Check if event devs are specified. Else probe the event devices
539 * and initialize the config with all ports & queues available
541 if (em_conf->nb_eventdev == 0) {
542 ret = eh_set_default_conf_eventdev(em_conf);
547 /* Perform capability check for the selected event devices */
548 eh_do_capability_check(em_conf);
551 * Check if links are specified. Else generate a default config for
552 * the event ports used.
554 if (em_conf->nb_link == 0) {
555 ret = eh_set_default_conf_link(em_conf);
561 * Check if rx adapters are specified. Else generate a default config
562 * with one rx adapter and all eth queues - event queue mapped.
564 if (em_conf->nb_rx_adapter == 0) {
565 ret = eh_set_default_conf_rx_adapter(em_conf);
571 * Check if tx adapters are specified. Else generate a default config
572 * with one tx adapter.
574 if (em_conf->nb_tx_adapter == 0) {
575 ret = eh_set_default_conf_tx_adapter(em_conf);
584 eh_initialize_eventdev(struct eventmode_conf *em_conf)
586 struct rte_event_queue_conf eventq_conf = {0};
587 struct rte_event_dev_info evdev_default_conf;
588 struct rte_event_dev_config eventdev_conf;
589 struct eventdev_params *eventdev_config;
590 int nb_eventdev = em_conf->nb_eventdev;
591 struct eh_event_link_info *link;
592 uint8_t *queue = NULL;
598 for (i = 0; i < nb_eventdev; i++) {
600 /* Get eventdev config */
601 eventdev_config = &(em_conf->eventdev_config[i]);
603 /* Get event dev ID */
604 eventdev_id = eventdev_config->eventdev_id;
606 /* Get the number of queues */
607 nb_eventqueue = eventdev_config->nb_eventqueue;
609 /* Reset the default conf */
610 memset(&evdev_default_conf, 0,
611 sizeof(struct rte_event_dev_info));
613 /* Get default conf of eventdev */
614 ret = rte_event_dev_info_get(eventdev_id, &evdev_default_conf);
617 "Error in getting event device info[devID:%d]",
622 memset(&eventdev_conf, 0, sizeof(struct rte_event_dev_config));
623 eventdev_conf.nb_events_limit =
624 evdev_default_conf.max_num_events;
625 eventdev_conf.nb_event_queues = nb_eventqueue;
626 eventdev_conf.nb_event_ports =
627 eventdev_config->nb_eventport;
628 eventdev_conf.nb_event_queue_flows =
629 evdev_default_conf.max_event_queue_flows;
630 eventdev_conf.nb_event_port_dequeue_depth =
631 evdev_default_conf.max_event_port_dequeue_depth;
632 eventdev_conf.nb_event_port_enqueue_depth =
633 evdev_default_conf.max_event_port_enqueue_depth;
635 /* Configure event device */
636 ret = rte_event_dev_configure(eventdev_id, &eventdev_conf);
638 EH_LOG_ERR("Error in configuring event device");
642 /* Configure event queues */
643 for (j = 0; j < nb_eventqueue; j++) {
645 memset(&eventq_conf, 0,
646 sizeof(struct rte_event_queue_conf));
648 /* Per event dev queues can be ATQ or SINGLE LINK */
649 eventq_conf.event_queue_cfg =
650 eventdev_config->ev_queue_mode;
652 * All queues need to be set with sched_type as
653 * schedule type for the application stage. One
654 * queue would be reserved for the final eth tx
655 * stage if event device does not have internal
656 * ports. This will be an atomic queue.
658 if (!eventdev_config->all_internal_ports &&
659 j == nb_eventqueue-1) {
660 eventq_conf.schedule_type =
661 RTE_SCHED_TYPE_ATOMIC;
663 eventq_conf.schedule_type =
664 em_conf->ext_params.sched_type;
667 /* Set max atomic flows to 1024 */
668 eventq_conf.nb_atomic_flows = 1024;
669 eventq_conf.nb_atomic_order_sequences = 1024;
671 /* Setup the queue */
672 ret = rte_event_queue_setup(eventdev_id, j,
675 EH_LOG_ERR("Failed to setup event queue %d",
681 /* Configure event ports */
682 for (j = 0; j < eventdev_config->nb_eventport; j++) {
683 ret = rte_event_port_setup(eventdev_id, j, NULL);
685 EH_LOG_ERR("Failed to setup event port %d",
692 /* Make event queue - event port link */
693 for (j = 0; j < em_conf->nb_link; j++) {
696 link = &(em_conf->link[j]);
698 /* Get event dev ID */
699 eventdev_id = link->eventdev_id;
702 * If "all_ev_queue_to_ev_port" params flag is selected, all
703 * queues need to be mapped to the port.
705 if (em_conf->ext_params.all_ev_queue_to_ev_port)
708 queue = &(link->eventq_id);
710 /* Link queue to port */
711 ret = rte_event_port_link(eventdev_id, link->event_port_id,
714 EH_LOG_ERR("Failed to link event port %d", ret);
723 eh_start_eventdev(struct eventmode_conf *em_conf)
725 struct eventdev_params *eventdev_config;
726 int nb_eventdev = em_conf->nb_eventdev;
729 /* Start event devices */
730 for (i = 0; i < nb_eventdev; i++) {
732 /* Get eventdev config */
733 eventdev_config = &(em_conf->eventdev_config[i]);
735 ret = rte_event_dev_start(eventdev_config->eventdev_id);
737 EH_LOG_ERR("Failed to start event device %d, %d",
746 eh_event_vector_limits_validate(struct eventmode_conf *em_conf,
747 uint8_t ev_dev_id, uint8_t ethdev_id)
749 struct rte_event_eth_rx_adapter_vector_limits limits = {0};
750 uint16_t vector_size = em_conf->ext_params.vector_size;
753 ret = rte_event_eth_rx_adapter_vector_limits_get(ev_dev_id, ethdev_id,
756 EH_LOG_ERR("failed to get vector limits");
760 if (vector_size < limits.min_sz || vector_size > limits.max_sz) {
761 EH_LOG_ERR("Vector size [%d] not within limits min[%d] max[%d]",
762 vector_size, limits.min_sz, limits.max_sz);
766 if (limits.log2_sz && !rte_is_power_of_2(vector_size)) {
767 EH_LOG_ERR("Vector size [%d] not power of 2", vector_size);
771 if (em_conf->vector_tmo_ns > limits.max_timeout_ns ||
772 em_conf->vector_tmo_ns < limits.min_timeout_ns) {
773 EH_LOG_ERR("Vector timeout [%" PRIu64
774 "] not within limits max[%" PRIu64
775 "] min[%" PRIu64 "]",
776 em_conf->vector_tmo_ns,
777 limits.max_timeout_ns,
778 limits.min_timeout_ns);
785 eh_rx_adapter_configure(struct eventmode_conf *em_conf,
786 struct rx_adapter_conf *adapter)
788 struct rte_event_eth_rx_adapter_queue_conf queue_conf = {0};
789 struct rte_event_dev_info evdev_default_conf = {0};
790 struct rte_event_port_conf port_conf = {0};
791 struct rx_adapter_connection_info *conn;
792 uint32_t service_id, socket_id, nb_elem;
793 struct rte_mempool *vector_pool = NULL;
794 uint32_t lcore_id = rte_lcore_id();
795 int ret, portid, nb_ports = 0;
799 /* Get event dev ID */
800 eventdev_id = adapter->eventdev_id;
802 /* Get default configuration of event dev */
803 ret = rte_event_dev_info_get(eventdev_id, &evdev_default_conf);
805 EH_LOG_ERR("Failed to get event dev info %d", ret);
809 RTE_ETH_FOREACH_DEV(portid)
810 if ((em_conf->eth_portmask & (1 << portid)))
813 if (em_conf->ext_params.event_vector) {
814 socket_id = rte_lcore_to_socket_id(lcore_id);
816 if (em_conf->vector_pool_sz) {
817 nb_elem = em_conf->vector_pool_sz;
819 nb_elem = (nb_bufs_in_pool /
820 em_conf->ext_params.vector_size) + 1;
822 nb_elem = nb_ports * nb_elem;
825 vector_pool = rte_event_vector_pool_create(
826 "vector_pool", nb_elem, 0,
827 em_conf->ext_params.vector_size,
829 if (vector_pool == NULL) {
830 EH_LOG_ERR("failed to create event vector pool");
834 /* Setup port conf */
835 port_conf.new_event_threshold = 1200;
836 port_conf.dequeue_depth =
837 evdev_default_conf.max_event_port_dequeue_depth;
838 port_conf.enqueue_depth =
839 evdev_default_conf.max_event_port_enqueue_depth;
841 /* Create Rx adapter */
842 ret = rte_event_eth_rx_adapter_create(adapter->adapter_id,
843 adapter->eventdev_id, &port_conf);
845 EH_LOG_ERR("Failed to create rx adapter %d", ret);
849 /* Setup various connections in the adapter */
850 for (j = 0; j < adapter->nb_connections; j++) {
852 conn = &(adapter->conn[j]);
854 /* Setup queue conf */
855 queue_conf.ev.queue_id = conn->eventq_id;
856 queue_conf.ev.sched_type = em_conf->ext_params.sched_type;
857 queue_conf.ev.event_type = RTE_EVENT_TYPE_ETHDEV;
859 if (em_conf->ext_params.event_vector) {
860 ret = eh_event_vector_limits_validate(em_conf,
866 queue_conf.vector_sz = em_conf->ext_params.vector_size;
867 queue_conf.vector_timeout_ns = em_conf->vector_tmo_ns;
868 queue_conf.vector_mp = vector_pool;
869 queue_conf.rx_queue_flags =
870 RTE_EVENT_ETH_RX_ADAPTER_QUEUE_EVENT_VECTOR;
873 /* Add queue to the adapter */
874 ret = rte_event_eth_rx_adapter_queue_add(adapter->adapter_id,
875 conn->ethdev_id, conn->ethdev_rx_qid,
878 EH_LOG_ERR("Failed to add eth queue to rx adapter %d",
884 /* Get the service ID used by rx adapter */
885 ret = rte_event_eth_rx_adapter_service_id_get(adapter->adapter_id,
887 if (ret != -ESRCH && ret < 0) {
888 EH_LOG_ERR("Failed to get service id used by rx adapter %d",
893 rte_service_set_runstate_mapped_check(service_id, 0);
896 ret = rte_event_eth_rx_adapter_start(adapter->adapter_id);
898 EH_LOG_ERR("Failed to start rx adapter %d", ret);
906 eh_initialize_rx_adapter(struct eventmode_conf *em_conf)
908 struct rx_adapter_conf *adapter;
911 /* Configure rx adapters */
912 for (i = 0; i < em_conf->nb_rx_adapter; i++) {
913 adapter = &(em_conf->rx_adapter[i]);
914 ret = eh_rx_adapter_configure(em_conf, adapter);
916 EH_LOG_ERR("Failed to configure rx adapter %d", ret);
924 eh_start_worker_eth_core(struct eventmode_conf *conf, uint32_t lcore_id)
926 uint32_t service_id[EVENT_MODE_MAX_ADAPTERS_PER_RX_CORE];
927 struct rx_adapter_conf *rx_adapter;
928 struct tx_adapter_conf *tx_adapter;
929 int service_count = 0;
934 EH_LOG_INFO("Entering eth_core processing on lcore %u", lcore_id);
937 * Parse adapter config to check which of all Rx adapters need
938 * to be handled by this core.
940 for (i = 0; i < conf->nb_rx_adapter; i++) {
941 /* Check if we have exceeded the max allowed */
942 if (service_count > EVENT_MODE_MAX_ADAPTERS_PER_RX_CORE) {
944 "Exceeded the max allowed adapters per rx core");
948 rx_adapter = &(conf->rx_adapter[i]);
949 if (rx_adapter->rx_core_id != lcore_id)
952 /* Adapter is handled by this core */
953 adapter_id = rx_adapter->adapter_id;
955 /* Get the service ID for the adapters */
956 ret = rte_event_eth_rx_adapter_service_id_get(adapter_id,
957 &(service_id[service_count]));
959 if (ret != -ESRCH && ret < 0) {
961 "Failed to get service id used by rx adapter");
965 /* Update service count */
970 * Parse adapter config to see which of all Tx adapters need
971 * to be handled by this core.
973 for (i = 0; i < conf->nb_tx_adapter; i++) {
974 /* Check if we have exceeded the max allowed */
975 if (service_count > EVENT_MODE_MAX_ADAPTERS_PER_TX_CORE) {
977 "Exceeded the max allowed adapters per tx core");
981 tx_adapter = &conf->tx_adapter[i];
982 if (tx_adapter->tx_core_id != lcore_id)
985 /* Adapter is handled by this core */
986 adapter_id = tx_adapter->adapter_id;
988 /* Get the service ID for the adapters */
989 ret = rte_event_eth_tx_adapter_service_id_get(adapter_id,
990 &(service_id[service_count]));
992 if (ret != -ESRCH && ret < 0) {
994 "Failed to get service id used by tx adapter");
998 /* Update service count */
1002 eth_core_running = true;
1004 while (eth_core_running) {
1005 for (i = 0; i < service_count; i++) {
1006 /* Initiate adapter service */
1007 rte_service_run_iter_on_app_lcore(service_id[i], 0);
1015 eh_stop_worker_eth_core(void)
1017 if (eth_core_running) {
1018 EH_LOG_INFO("Stopping eth cores");
1019 eth_core_running = false;
1024 static struct eh_app_worker_params *
1025 eh_find_worker(uint32_t lcore_id, struct eh_conf *conf,
1026 struct eh_app_worker_params *app_wrkrs, uint8_t nb_wrkr_param)
1028 struct eh_app_worker_params curr_conf = { {{0} }, NULL};
1029 struct eh_event_link_info *link = NULL;
1030 struct eh_app_worker_params *tmp_wrkr;
1031 struct eventmode_conf *em_conf;
1032 uint8_t eventdev_id;
1035 /* Get eventmode config */
1036 em_conf = conf->mode_params;
1039 * Use event device from the first lcore-event link.
1041 * Assumption: All lcore-event links tied to a core are using the
1042 * same event device. In other words, one core would be polling on
1043 * queues of a single event device only.
1046 /* Get a link for this lcore */
1047 for (i = 0; i < em_conf->nb_link; i++) {
1048 link = &(em_conf->link[i]);
1049 if (link->lcore_id == lcore_id)
1054 EH_LOG_ERR("No valid link found for lcore %d", lcore_id);
1058 /* Get event dev ID */
1059 eventdev_id = link->eventdev_id;
1061 /* Populate the curr_conf with the capabilities */
1063 /* Check for Tx internal port */
1064 if (eh_dev_has_tx_internal_port(eventdev_id))
1065 curr_conf.cap.tx_internal_port = EH_TX_TYPE_INTERNAL_PORT;
1067 curr_conf.cap.tx_internal_port = EH_TX_TYPE_NO_INTERNAL_PORT;
1069 /* Check for burst mode */
1070 if (eh_dev_has_burst_mode(eventdev_id))
1071 curr_conf.cap.burst = EH_RX_TYPE_BURST;
1073 curr_conf.cap.burst = EH_RX_TYPE_NON_BURST;
1075 curr_conf.cap.ipsec_mode = conf->ipsec_mode;
1077 /* Parse the passed list and see if we have matching capabilities */
1079 /* Initialize the pointer used to traverse the list */
1080 tmp_wrkr = app_wrkrs;
1082 for (i = 0; i < nb_wrkr_param; i++, tmp_wrkr++) {
1084 /* Skip this if capabilities are not matching */
1085 if (tmp_wrkr->cap.u64 != curr_conf.cap.u64)
1088 /* If the checks pass, we have a match */
1096 eh_verify_match_worker(struct eh_app_worker_params *match_wrkr)
1098 /* Verify registered worker */
1099 if (match_wrkr->worker_thread == NULL) {
1100 EH_LOG_ERR("No worker registered");
1109 eh_get_event_lcore_links(uint32_t lcore_id, struct eh_conf *conf,
1110 struct eh_event_link_info **links)
1112 struct eh_event_link_info *link_cache;
1113 struct eventmode_conf *em_conf = NULL;
1114 struct eh_event_link_info *link;
1115 uint8_t lcore_nb_link = 0;
1116 size_t single_link_size;
1121 if (conf == NULL || links == NULL) {
1122 EH_LOG_ERR("Invalid args");
1126 /* Get eventmode conf */
1127 em_conf = conf->mode_params;
1129 if (em_conf == NULL) {
1130 EH_LOG_ERR("Invalid event mode parameters");
1134 /* Get the number of links registered */
1135 for (i = 0; i < em_conf->nb_link; i++) {
1138 link = &(em_conf->link[i]);
1140 /* Check if we have link intended for this lcore */
1141 if (link->lcore_id == lcore_id) {
1143 /* Update the number of links for this core */
1149 /* Compute size of one entry to be copied */
1150 single_link_size = sizeof(struct eh_event_link_info);
1152 /* Compute size of the buffer required */
1153 cache_size = lcore_nb_link * sizeof(struct eh_event_link_info);
1155 /* Compute size of the buffer required */
1156 link_cache = calloc(1, cache_size);
1158 /* Get the number of links registered */
1159 for (i = 0; i < em_conf->nb_link; i++) {
1162 link = &(em_conf->link[i]);
1164 /* Check if we have link intended for this lcore */
1165 if (link->lcore_id == lcore_id) {
1167 /* Cache the link */
1168 memcpy(&link_cache[index], link, single_link_size);
1175 /* Update the links for application to use the cached links */
1176 *links = link_cache;
1178 /* Return the number of cached links */
1179 return lcore_nb_link;
1183 eh_tx_adapter_configure(struct eventmode_conf *em_conf,
1184 struct tx_adapter_conf *adapter)
1186 struct rte_event_dev_info evdev_default_conf = {0};
1187 struct rte_event_port_conf port_conf = {0};
1188 struct tx_adapter_connection_info *conn;
1189 struct eventdev_params *eventdev_config;
1190 uint8_t tx_port_id = 0;
1191 uint8_t eventdev_id;
1192 uint32_t service_id;
1195 /* Get event dev ID */
1196 eventdev_id = adapter->eventdev_id;
1198 /* Get event device conf */
1199 eventdev_config = eh_get_eventdev_params(em_conf, eventdev_id);
1201 /* Create Tx adapter */
1203 /* Get default configuration of event dev */
1204 ret = rte_event_dev_info_get(eventdev_id, &evdev_default_conf);
1206 EH_LOG_ERR("Failed to get event dev info %d", ret);
1210 /* Setup port conf */
1211 port_conf.new_event_threshold =
1212 evdev_default_conf.max_num_events;
1213 port_conf.dequeue_depth =
1214 evdev_default_conf.max_event_port_dequeue_depth;
1215 port_conf.enqueue_depth =
1216 evdev_default_conf.max_event_port_enqueue_depth;
1218 /* Create adapter */
1219 ret = rte_event_eth_tx_adapter_create(adapter->adapter_id,
1220 adapter->eventdev_id, &port_conf);
1222 EH_LOG_ERR("Failed to create tx adapter %d", ret);
1226 /* Setup various connections in the adapter */
1227 for (j = 0; j < adapter->nb_connections; j++) {
1229 /* Get connection */
1230 conn = &(adapter->conn[j]);
1232 /* Add queue to the adapter */
1233 ret = rte_event_eth_tx_adapter_queue_add(adapter->adapter_id,
1234 conn->ethdev_id, conn->ethdev_tx_qid);
1236 EH_LOG_ERR("Failed to add eth queue to tx adapter %d",
1243 * Check if Tx core is assigned. If Tx core is not assigned then
1244 * the adapter has internal port for submitting Tx packets and
1245 * Tx event queue & port setup is not required
1247 if (adapter->tx_core_id == (uint32_t) (-1)) {
1248 /* Internal port is present */
1249 goto skip_tx_queue_port_setup;
1252 /* Setup Tx queue & port */
1254 /* Get event port used by the adapter */
1255 ret = rte_event_eth_tx_adapter_event_port_get(
1256 adapter->adapter_id, &tx_port_id);
1258 EH_LOG_ERR("Failed to get tx adapter port id %d", ret);
1263 * Tx event queue is reserved for Tx adapter. Unlink this queue
1264 * from all other ports
1267 for (j = 0; j < eventdev_config->nb_eventport; j++) {
1268 rte_event_port_unlink(eventdev_id, j,
1269 &(adapter->tx_ev_queue), 1);
1272 /* Link Tx event queue to Tx port */
1273 ret = rte_event_port_link(eventdev_id, tx_port_id,
1274 &(adapter->tx_ev_queue), NULL, 1);
1276 EH_LOG_ERR("Failed to link event queue to port");
1280 /* Get the service ID used by Tx adapter */
1281 ret = rte_event_eth_tx_adapter_service_id_get(adapter->adapter_id,
1283 if (ret != -ESRCH && ret < 0) {
1284 EH_LOG_ERR("Failed to get service id used by tx adapter %d",
1289 rte_service_set_runstate_mapped_check(service_id, 0);
1291 skip_tx_queue_port_setup:
1293 ret = rte_event_eth_tx_adapter_start(adapter->adapter_id);
1295 EH_LOG_ERR("Failed to start tx adapter %d", ret);
1303 eh_initialize_tx_adapter(struct eventmode_conf *em_conf)
1305 struct tx_adapter_conf *adapter;
1308 /* Configure Tx adapters */
1309 for (i = 0; i < em_conf->nb_tx_adapter; i++) {
1310 adapter = &(em_conf->tx_adapter[i]);
1311 ret = eh_tx_adapter_configure(em_conf, adapter);
1313 EH_LOG_ERR("Failed to configure tx adapter %d", ret);
1321 eh_display_operating_mode(struct eventmode_conf *em_conf)
1323 char sched_types[][32] = {
1324 "RTE_SCHED_TYPE_ORDERED",
1325 "RTE_SCHED_TYPE_ATOMIC",
1326 "RTE_SCHED_TYPE_PARALLEL",
1328 EH_LOG_INFO("Operating mode:");
1330 EH_LOG_INFO("\tScheduling type: \t%s",
1331 sched_types[em_conf->ext_params.sched_type]);
1337 eh_display_event_dev_conf(struct eventmode_conf *em_conf)
1339 char queue_mode[][32] = {
1341 "ATQ (ALL TYPE QUEUE)",
1344 char print_buf[256] = { 0 };
1347 EH_LOG_INFO("Event Device Configuration:");
1349 for (i = 0; i < em_conf->nb_eventdev; i++) {
1351 "\tDev ID: %-2d \tQueues: %-2d \tPorts: %-2d",
1352 em_conf->eventdev_config[i].eventdev_id,
1353 em_conf->eventdev_config[i].nb_eventqueue,
1354 em_conf->eventdev_config[i].nb_eventport);
1355 sprintf(print_buf + strlen(print_buf),
1357 queue_mode[em_conf->eventdev_config[i].ev_queue_mode]);
1358 EH_LOG_INFO("%s", print_buf);
1364 eh_display_rx_adapter_conf(struct eventmode_conf *em_conf)
1366 int nb_rx_adapter = em_conf->nb_rx_adapter;
1367 struct rx_adapter_connection_info *conn;
1368 struct rx_adapter_conf *adapter;
1369 char print_buf[256] = { 0 };
1372 EH_LOG_INFO("Rx adapters configured: %d", nb_rx_adapter);
1374 for (i = 0; i < nb_rx_adapter; i++) {
1375 adapter = &(em_conf->rx_adapter[i]);
1377 "\tRx adapter ID: %-2d\tConnections: %-2d\tEvent dev ID: %-2d",
1378 adapter->adapter_id,
1379 adapter->nb_connections,
1380 adapter->eventdev_id);
1381 if (adapter->rx_core_id == (uint32_t)-1)
1382 sprintf(print_buf + strlen(print_buf),
1383 "\tRx core: %-2s", "[INTERNAL PORT]");
1384 else if (adapter->rx_core_id == RTE_MAX_LCORE)
1385 sprintf(print_buf + strlen(print_buf),
1386 "\tRx core: %-2s", "[NONE]");
1388 sprintf(print_buf + strlen(print_buf),
1389 "\tRx core: %-2d", adapter->rx_core_id);
1391 EH_LOG_INFO("%s", print_buf);
1393 for (j = 0; j < adapter->nb_connections; j++) {
1394 conn = &(adapter->conn[j]);
1397 "\t\tEthdev ID: %-2d", conn->ethdev_id);
1399 if (conn->ethdev_rx_qid == -1)
1400 sprintf(print_buf + strlen(print_buf),
1401 "\tEth rx queue: %-2s", "ALL");
1403 sprintf(print_buf + strlen(print_buf),
1404 "\tEth rx queue: %-2d",
1405 conn->ethdev_rx_qid);
1407 sprintf(print_buf + strlen(print_buf),
1408 "\tEvent queue: %-2d", conn->eventq_id);
1409 EH_LOG_INFO("%s", print_buf);
1416 eh_display_tx_adapter_conf(struct eventmode_conf *em_conf)
1418 int nb_tx_adapter = em_conf->nb_tx_adapter;
1419 struct tx_adapter_connection_info *conn;
1420 struct tx_adapter_conf *adapter;
1421 char print_buf[256] = { 0 };
1424 EH_LOG_INFO("Tx adapters configured: %d", nb_tx_adapter);
1426 for (i = 0; i < nb_tx_adapter; i++) {
1427 adapter = &(em_conf->tx_adapter[i]);
1429 "\tTx adapter ID: %-2d\tConnections: %-2d\tEvent dev ID: %-2d",
1430 adapter->adapter_id,
1431 adapter->nb_connections,
1432 adapter->eventdev_id);
1433 if (adapter->tx_core_id == (uint32_t)-1)
1434 sprintf(print_buf + strlen(print_buf),
1435 "\tTx core: %-2s", "[INTERNAL PORT]");
1436 else if (adapter->tx_core_id == RTE_MAX_LCORE)
1437 sprintf(print_buf + strlen(print_buf),
1438 "\tTx core: %-2s", "[NONE]");
1440 sprintf(print_buf + strlen(print_buf),
1441 "\tTx core: %-2d,\tInput event queue: %-2d",
1442 adapter->tx_core_id, adapter->tx_ev_queue);
1444 EH_LOG_INFO("%s", print_buf);
1446 for (j = 0; j < adapter->nb_connections; j++) {
1447 conn = &(adapter->conn[j]);
1450 "\t\tEthdev ID: %-2d", conn->ethdev_id);
1452 if (conn->ethdev_tx_qid == -1)
1453 sprintf(print_buf + strlen(print_buf),
1454 "\tEth tx queue: %-2s", "ALL");
1456 sprintf(print_buf + strlen(print_buf),
1457 "\tEth tx queue: %-2d",
1458 conn->ethdev_tx_qid);
1459 EH_LOG_INFO("%s", print_buf);
1466 eh_display_link_conf(struct eventmode_conf *em_conf)
1468 struct eh_event_link_info *link;
1469 char print_buf[256] = { 0 };
1472 EH_LOG_INFO("Links configured: %d", em_conf->nb_link);
1474 for (i = 0; i < em_conf->nb_link; i++) {
1475 link = &(em_conf->link[i]);
1478 "\tEvent dev ID: %-2d\tEvent port: %-2d",
1480 link->event_port_id);
1482 if (em_conf->ext_params.all_ev_queue_to_ev_port)
1483 sprintf(print_buf + strlen(print_buf),
1484 "Event queue: %-2s\t", "ALL");
1486 sprintf(print_buf + strlen(print_buf),
1487 "Event queue: %-2d\t", link->eventq_id);
1489 sprintf(print_buf + strlen(print_buf),
1490 "Lcore: %-2d", link->lcore_id);
1491 EH_LOG_INFO("%s", print_buf);
1499 struct eventmode_conf *em_conf = NULL;
1500 struct eh_conf *conf = NULL;
1501 unsigned int eth_core_id;
1502 void *bitmap = NULL;
1505 /* Allocate memory for config */
1506 conf = calloc(1, sizeof(struct eh_conf));
1508 EH_LOG_ERR("Failed to allocate memory for eventmode helper "
1513 /* Set default conf */
1515 /* Packet transfer mode: poll */
1516 conf->mode = EH_PKT_TRANSFER_MODE_POLL;
1517 conf->ipsec_mode = EH_IPSEC_MODE_TYPE_APP;
1519 /* Keep all ethernet ports enabled by default */
1520 conf->eth_portmask = -1;
1522 /* Allocate memory for event mode params */
1523 conf->mode_params = calloc(1, sizeof(struct eventmode_conf));
1524 if (conf->mode_params == NULL) {
1525 EH_LOG_ERR("Failed to allocate memory for event mode params");
1529 /* Get eventmode conf */
1530 em_conf = conf->mode_params;
1532 /* Allocate and initialize bitmap for eth cores */
1533 nb_bytes = rte_bitmap_get_memory_footprint(RTE_MAX_LCORE);
1535 EH_LOG_ERR("Failed to get bitmap footprint");
1539 bitmap = rte_zmalloc("event-helper-ethcore-bitmap", nb_bytes,
1540 RTE_CACHE_LINE_SIZE);
1542 EH_LOG_ERR("Failed to allocate memory for eth cores bitmap\n");
1546 em_conf->eth_core_mask = rte_bitmap_init(RTE_MAX_LCORE, bitmap,
1548 if (!em_conf->eth_core_mask) {
1549 EH_LOG_ERR("Failed to initialize bitmap");
1553 /* Set schedule type as not set */
1554 em_conf->ext_params.sched_type = SCHED_TYPE_NOT_SET;
1556 /* Set two cores as eth cores for Rx & Tx */
1558 /* Use first core other than main core as Rx core */
1559 eth_core_id = rte_get_next_lcore(0, /* curr core */
1560 1, /* skip main core */
1563 rte_bitmap_set(em_conf->eth_core_mask, eth_core_id);
1565 /* Use next core as Tx core */
1566 eth_core_id = rte_get_next_lcore(eth_core_id, /* curr core */
1567 1, /* skip main core */
1570 rte_bitmap_set(em_conf->eth_core_mask, eth_core_id);
1572 em_conf->ext_params.vector_size = DEFAULT_VECTOR_SIZE;
1573 em_conf->vector_tmo_ns = DEFAULT_VECTOR_TMO;
1587 eh_conf_uninit(struct eh_conf *conf)
1589 struct eventmode_conf *em_conf = NULL;
1591 if (!conf || !conf->mode_params)
1594 /* Get eventmode conf */
1595 em_conf = conf->mode_params;
1597 /* Free evenmode configuration memory */
1598 rte_free(em_conf->eth_core_mask);
1604 eh_display_conf(struct eh_conf *conf)
1606 struct eventmode_conf *em_conf;
1609 EH_LOG_ERR("Invalid event helper configuration");
1613 if (conf->mode != EH_PKT_TRANSFER_MODE_EVENT)
1616 if (conf->mode_params == NULL) {
1617 EH_LOG_ERR("Invalid event mode parameters");
1621 /* Get eventmode conf */
1622 em_conf = (struct eventmode_conf *)(conf->mode_params);
1624 /* Display user exposed operating modes */
1625 eh_display_operating_mode(em_conf);
1627 /* Display event device conf */
1628 eh_display_event_dev_conf(em_conf);
1630 /* Display Rx adapter conf */
1631 eh_display_rx_adapter_conf(em_conf);
1633 /* Display Tx adapter conf */
1634 eh_display_tx_adapter_conf(em_conf);
1636 /* Display event-lcore link */
1637 eh_display_link_conf(em_conf);
1641 eh_devs_init(struct eh_conf *conf)
1643 struct eventmode_conf *em_conf;
1648 EH_LOG_ERR("Invalid event helper configuration");
1652 if (conf->mode != EH_PKT_TRANSFER_MODE_EVENT)
1655 if (conf->mode_params == NULL) {
1656 EH_LOG_ERR("Invalid event mode parameters");
1660 /* Get eventmode conf */
1661 em_conf = conf->mode_params;
1663 /* Eventmode conf would need eth portmask */
1664 em_conf->eth_portmask = conf->eth_portmask;
1666 /* Validate the requested config */
1667 ret = eh_validate_conf(em_conf);
1669 EH_LOG_ERR("Failed to validate the requested config %d", ret);
1673 /* Display the current configuration */
1674 eh_display_conf(conf);
1676 /* Stop eth devices before setting up adapter */
1677 RTE_ETH_FOREACH_DEV(port_id) {
1679 /* Use only the ports enabled */
1680 if ((conf->eth_portmask & (1 << port_id)) == 0)
1683 ret = rte_eth_dev_stop(port_id);
1685 EH_LOG_ERR("Failed to stop port %u, err: %d",
1691 /* Setup eventdev */
1692 ret = eh_initialize_eventdev(em_conf);
1694 EH_LOG_ERR("Failed to initialize event dev %d", ret);
1698 /* Setup Rx adapter */
1699 ret = eh_initialize_rx_adapter(em_conf);
1701 EH_LOG_ERR("Failed to initialize rx adapter %d", ret);
1705 /* Setup Tx adapter */
1706 ret = eh_initialize_tx_adapter(em_conf);
1708 EH_LOG_ERR("Failed to initialize tx adapter %d", ret);
1712 /* Start eventdev */
1713 ret = eh_start_eventdev(em_conf);
1715 EH_LOG_ERR("Failed to start event dev %d", ret);
1719 /* Start eth devices after setting up adapter */
1720 RTE_ETH_FOREACH_DEV(port_id) {
1722 /* Use only the ports enabled */
1723 if ((conf->eth_portmask & (1 << port_id)) == 0)
1726 ret = rte_eth_dev_start(port_id);
1728 EH_LOG_ERR("Failed to start eth dev %d, %d",
1738 eh_devs_uninit(struct eh_conf *conf)
1740 struct eventmode_conf *em_conf;
1745 EH_LOG_ERR("Invalid event helper configuration");
1749 if (conf->mode != EH_PKT_TRANSFER_MODE_EVENT)
1752 if (conf->mode_params == NULL) {
1753 EH_LOG_ERR("Invalid event mode parameters");
1757 /* Get eventmode conf */
1758 em_conf = conf->mode_params;
1760 /* Stop and release rx adapters */
1761 for (i = 0; i < em_conf->nb_rx_adapter; i++) {
1763 id = em_conf->rx_adapter[i].adapter_id;
1764 ret = rte_event_eth_rx_adapter_stop(id);
1766 EH_LOG_ERR("Failed to stop rx adapter %d", ret);
1770 for (j = 0; j < em_conf->rx_adapter[i].nb_connections; j++) {
1772 ret = rte_event_eth_rx_adapter_queue_del(id,
1773 em_conf->rx_adapter[i].conn[j].ethdev_id, -1);
1776 "Failed to remove rx adapter queues %d",
1782 ret = rte_event_eth_rx_adapter_free(id);
1784 EH_LOG_ERR("Failed to free rx adapter %d", ret);
1789 /* Stop and release event devices */
1790 for (i = 0; i < em_conf->nb_eventdev; i++) {
1792 id = em_conf->eventdev_config[i].eventdev_id;
1793 rte_event_dev_stop(id);
1795 ret = rte_event_dev_close(id);
1797 EH_LOG_ERR("Failed to close event dev %d, %d", id, ret);
1802 /* Stop and release tx adapters */
1803 for (i = 0; i < em_conf->nb_tx_adapter; i++) {
1805 id = em_conf->tx_adapter[i].adapter_id;
1806 ret = rte_event_eth_tx_adapter_stop(id);
1808 EH_LOG_ERR("Failed to stop tx adapter %d", ret);
1812 for (j = 0; j < em_conf->tx_adapter[i].nb_connections; j++) {
1814 ret = rte_event_eth_tx_adapter_queue_del(id,
1815 em_conf->tx_adapter[i].conn[j].ethdev_id, -1);
1818 "Failed to remove tx adapter queues %d",
1824 ret = rte_event_eth_tx_adapter_free(id);
1826 EH_LOG_ERR("Failed to free tx adapter %d", ret);
1835 eh_launch_worker(struct eh_conf *conf, struct eh_app_worker_params *app_wrkr,
1836 uint8_t nb_wrkr_param)
1838 struct eh_app_worker_params *match_wrkr;
1839 struct eh_event_link_info *links = NULL;
1840 struct eventmode_conf *em_conf;
1845 EH_LOG_ERR("Invalid event helper configuration");
1849 if (conf->mode_params == NULL) {
1850 EH_LOG_ERR("Invalid event mode parameters");
1854 /* Get eventmode conf */
1855 em_conf = conf->mode_params;
1858 lcore_id = rte_lcore_id();
1860 /* Check if this is eth core */
1861 if (rte_bitmap_get(em_conf->eth_core_mask, lcore_id)) {
1862 eh_start_worker_eth_core(em_conf, lcore_id);
1866 if (app_wrkr == NULL || nb_wrkr_param == 0) {
1867 EH_LOG_ERR("Invalid args");
1872 * This is a regular worker thread. The application registers
1873 * multiple workers with various capabilities. Run worker
1874 * based on the selected capabilities of the event
1875 * device configured.
1878 /* Get the first matching worker for the event device */
1879 match_wrkr = eh_find_worker(lcore_id, conf, app_wrkr, nb_wrkr_param);
1880 if (match_wrkr == NULL) {
1881 EH_LOG_ERR("Failed to match worker registered for lcore %d",
1883 goto clean_and_exit;
1886 /* Verify sanity of the matched worker */
1887 if (eh_verify_match_worker(match_wrkr) != 1) {
1888 EH_LOG_ERR("Failed to validate the matched worker");
1889 goto clean_and_exit;
1892 /* Get worker links */
1893 nb_links = eh_get_event_lcore_links(lcore_id, conf, &links);
1895 /* Launch the worker thread */
1896 match_wrkr->worker_thread(links, nb_links);
1898 /* Free links info memory */
1903 /* Flag eth_cores to stop, if started */
1904 eh_stop_worker_eth_core();
1908 eh_get_tx_queue(struct eh_conf *conf, uint8_t eventdev_id)
1910 struct eventdev_params *eventdev_config;
1911 struct eventmode_conf *em_conf;
1914 EH_LOG_ERR("Invalid event helper configuration");
1918 if (conf->mode_params == NULL) {
1919 EH_LOG_ERR("Invalid event mode parameters");
1923 /* Get eventmode conf */
1924 em_conf = conf->mode_params;
1926 /* Get event device conf */
1927 eventdev_config = eh_get_eventdev_params(em_conf, eventdev_id);
1929 if (eventdev_config == NULL) {
1930 EH_LOG_ERR("Failed to read eventdev config");
1935 * The last queue is reserved to be used as atomic queue for the
1936 * last stage (eth packet tx stage)
1938 return eventdev_config->nb_eventqueue - 1;