examples/ipsec-secgw/event_helper.h

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright (C) 2020 Marvell International Ltd.
   3  */
   4 #ifndef _EVENT_HELPER_H_
   5 #define _EVENT_HELPER_H_
   6
   7 #include <rte_log.h>
   8
   9 #define RTE_LOGTYPE_EH  RTE_LOGTYPE_USER4
  10
  11 #define EH_LOG_ERR(...) \
  12         RTE_LOG(ERR, EH, \
  13                 RTE_FMT("%s() line %u: " RTE_FMT_HEAD(__VA_ARGS__ ,) "\n", \
  14                         __func__, __LINE__, RTE_FMT_TAIL(__VA_ARGS__ ,)))
  15
  16 #define EH_LOG_INFO(...) \
  17         RTE_LOG(INFO, EH, \
  18                 RTE_FMT("%s() line %u: " RTE_FMT_HEAD(__VA_ARGS__ ,) "\n", \
  19                         __func__, __LINE__, RTE_FMT_TAIL(__VA_ARGS__ ,)))
  20
  21 /* Max event devices supported */
  22 #define EVENT_MODE_MAX_EVENT_DEVS RTE_EVENT_MAX_DEVS
  23
  24 /* Max Rx adapters supported */
  25 #define EVENT_MODE_MAX_RX_ADAPTERS RTE_EVENT_MAX_DEVS
  26
  27 /* Max Tx adapters supported */
  28 #define EVENT_MODE_MAX_TX_ADAPTERS RTE_EVENT_MAX_DEVS
  29
  30 /* Max Rx adapter connections */
  31 #define EVENT_MODE_MAX_CONNECTIONS_PER_ADAPTER 16
  32
  33 /* Max Tx adapter connections */
  34 #define EVENT_MODE_MAX_CONNECTIONS_PER_TX_ADAPTER 16
  35
  36 /* Max event queues supported per event device */
  37 #define EVENT_MODE_MAX_EVENT_QUEUES_PER_DEV RTE_EVENT_MAX_QUEUES_PER_DEV
  38
  39 /* Max event-lcore links */
  40 #define EVENT_MODE_MAX_LCORE_LINKS \
  41         (EVENT_MODE_MAX_EVENT_DEVS * EVENT_MODE_MAX_EVENT_QUEUES_PER_DEV)
  42
  43 /* Max adapters that one Rx core can handle */
  44 #define EVENT_MODE_MAX_ADAPTERS_PER_RX_CORE EVENT_MODE_MAX_RX_ADAPTERS
  45
  46 /* Max adapters that one Tx core can handle */
  47 #define EVENT_MODE_MAX_ADAPTERS_PER_TX_CORE EVENT_MODE_MAX_TX_ADAPTERS
  48
  49 /* Used to indicate that queue schedule type is not set */
  50 #define SCHED_TYPE_NOT_SET      3
  51
  52 /**
  53  * Packet transfer mode of the application
  54  */
  55 enum eh_pkt_transfer_mode {
  56         EH_PKT_TRANSFER_MODE_POLL = 0,
  57         EH_PKT_TRANSFER_MODE_EVENT,
  58 };
  59
  60 /**
  61  * Event mode packet rx types
  62  */
  63 enum eh_rx_types {
  64         EH_RX_TYPE_NON_BURST = 0,
  65         EH_RX_TYPE_BURST
  66 };
  67
  68 /**
  69  * Event mode packet tx types
  70  */
  71 enum eh_tx_types {
  72         EH_TX_TYPE_INTERNAL_PORT = 0,
  73         EH_TX_TYPE_NO_INTERNAL_PORT
  74 };
  75
  76 /**
  77  * Event mode ipsec mode types
  78  */
  79 enum eh_ipsec_mode_types {
  80         EH_IPSEC_MODE_TYPE_APP = 0,
  81         EH_IPSEC_MODE_TYPE_DRIVER
  82 };
  83
  84 /* Event dev params */
  85 struct eventdev_params {
  86         uint8_t eventdev_id;
  87         uint8_t nb_eventqueue;
  88         uint8_t nb_eventport;
  89         uint8_t ev_queue_mode;
  90         uint8_t all_internal_ports;
  91 };
  92
  93 /**
  94  * Event-lcore link configuration
  95  */
  96 struct eh_event_link_info {
  97         uint8_t eventdev_id;
  98                 /**< Event device ID */
  99         uint8_t event_port_id;
 100                 /**< Event port ID */
 101         uint8_t eventq_id;
 102                 /**< Event queue to be linked to the port */
 103         uint8_t lcore_id;
 104                 /**< Lcore to be polling on this port */
 105 };
 106
 107 /* Rx adapter connection info */
 108 struct rx_adapter_connection_info {
 109         uint8_t ethdev_id;
 110         uint8_t eventq_id;
 111         int32_t ethdev_rx_qid;
 112 };
 113
 114 /* Rx adapter conf */
 115 struct rx_adapter_conf {
 116         int32_t eventdev_id;
 117         int32_t adapter_id;
 118         uint32_t rx_core_id;
 119         uint8_t nb_connections;
 120         struct rx_adapter_connection_info
 121                         conn[EVENT_MODE_MAX_CONNECTIONS_PER_ADAPTER];
 122 };
 123
 124 /* Tx adapter connection info */
 125 struct tx_adapter_connection_info {
 126         uint8_t ethdev_id;
 127         int32_t ethdev_tx_qid;
 128 };
 129
 130 /* Tx adapter conf */
 131 struct tx_adapter_conf {
 132         int32_t eventdev_id;
 133         int32_t adapter_id;
 134         uint32_t tx_core_id;
 135         uint8_t nb_connections;
 136         struct tx_adapter_connection_info
 137                         conn[EVENT_MODE_MAX_CONNECTIONS_PER_TX_ADAPTER];
 138         uint8_t tx_ev_queue;
 139 };
 140
 141 /* Eventmode conf data */
 142 struct eventmode_conf {
 143         int nb_eventdev;
 144                 /**< No of event devs */
 145         struct eventdev_params eventdev_config[EVENT_MODE_MAX_EVENT_DEVS];
 146                 /**< Per event dev conf */
 147         uint8_t nb_rx_adapter;
 148                 /**< No of Rx adapters */
 149         struct rx_adapter_conf rx_adapter[EVENT_MODE_MAX_RX_ADAPTERS];
 150                 /**< Rx adapter conf */
 151         uint8_t nb_tx_adapter;
 152                 /**< No of Tx adapters */
 153         struct tx_adapter_conf tx_adapter[EVENT_MODE_MAX_TX_ADAPTERS];
 154                 /** Tx adapter conf */
 155         uint8_t nb_link;
 156                 /**< No of links */
 157         struct eh_event_link_info
 158                 link[EVENT_MODE_MAX_LCORE_LINKS];
 159                 /**< Per link conf */
 160         struct rte_bitmap *eth_core_mask;
 161                 /**< Core mask of cores to be used for software Rx and Tx */
 162         uint32_t eth_portmask;
 163                 /**< Mask of the eth ports to be used */
 164         union {
 165                 RTE_STD_C11
 166                 struct {
 167                         uint64_t sched_type                     : 2;
 168                 /**< Schedule type */
 169                         uint64_t all_ev_queue_to_ev_port        : 1;
 170                 /**<
 171                  * When enabled, all event queues need to be mapped to
 172                  * each event port
 173                  */
 174                 };
 175                 uint64_t u64;
 176         } ext_params;
 177                 /**< 64 bit field to specify extended params */
 178 };
 179
 180 /**
 181  * Event helper configuration
 182  */
 183 struct eh_conf {
 184         enum eh_pkt_transfer_mode mode;
 185                 /**< Packet transfer mode of the application */
 186         uint32_t eth_portmask;
 187                 /**<
 188                  * Mask of the eth ports to be used. This portmask would be
 189                  * checked while initializing devices using helper routines.
 190                  */
 191         void *mode_params;
 192                 /**< Mode specific parameters */
 193
 194                 /** Application specific params */
 195         enum eh_ipsec_mode_types ipsec_mode;
 196                 /**< Mode of ipsec run */
 197 };
 198
 199 /* Workers registered by the application */
 200 struct eh_app_worker_params {
 201         union {
 202                 RTE_STD_C11
 203                 struct {
 204                         uint64_t burst : 1;
 205                         /**< Specify status of rx type burst */
 206                         uint64_t tx_internal_port : 1;
 207                         /**< Specify whether tx internal port is available */
 208                         uint64_t ipsec_mode : 1;
 209                         /**< Specify ipsec processing level */
 210                 };
 211                 uint64_t u64;
 212         } cap;
 213                         /**< Capabilities of this worker */
 214         void (*worker_thread)(struct eh_event_link_info *links,
 215                         uint8_t nb_links);
 216                         /**< Worker thread */
 217 };
 218
 219 /**
 220  * Allocate memory for event helper configuration and initialize
 221  * it with default values.
 222  *
 223  * @return
 224  * - pointer to event helper configuration structure on success.
 225  * - NULL on failure.
 226  */
 227 struct eh_conf *
 228 eh_conf_init(void);
 229
 230 /**
 231  * Uninitialize event helper configuration and release its memory
 232 . *
 233  * @param conf
 234  *   Event helper configuration
 235  */
 236 void
 237 eh_conf_uninit(struct eh_conf *conf);
 238
 239 /**
 240  * Initialize event mode devices
 241  *
 242  * Application can call this function to get the event devices, eth devices
 243  * and eth rx & tx adapters initialized according to the default config or
 244  * config populated using the command line args.
 245  *
 246  * Application is expected to initialize the eth devices and then the event
 247  * mode helper subsystem will stop & start eth devices according to its
 248  * requirement. Call to this function should be done after the eth devices
 249  * are successfully initialized.
 250  *
 251  * @param conf
 252  *   Event helper configuration
 253  * @return
 254  *  - 0 on success.
 255  *  - (<0) on failure.
 256  */
 257 int32_t
 258 eh_devs_init(struct eh_conf *conf);
 259
 260 /**
 261  * Release event mode devices
 262  *
 263  * Application can call this function to release event devices,
 264  * eth rx & tx adapters according to the config.
 265  *
 266  * Call to this function should be done before application stops
 267  * and closes eth devices. This function will not close and stop
 268  * eth devices.
 269  *
 270  * @param conf
 271  *   Event helper configuration
 272  * @return
 273  *  - 0 on success.
 274  *  - (<0) on failure.
 275  */
 276 int32_t
 277 eh_devs_uninit(struct eh_conf *conf);
 278
 279 /**
 280  * Get eventdev tx queue
 281  *
 282  * If the application uses event device which does not support internal port
 283  * then it needs to submit the events to a Tx queue before final transmission.
 284  * This Tx queue will be created internally by the eventmode helper subsystem,
 285  * and application will need its queue ID when it runs the execution loop.
 286  *
 287  * @param mode_conf
 288  *   Event helper configuration
 289  * @param eventdev_id
 290  *   Event device ID
 291  * @return
 292  *   Tx queue ID
 293  */
 294 uint8_t
 295 eh_get_tx_queue(struct eh_conf *conf, uint8_t eventdev_id);
 296
 297 /**
 298  * Display event mode configuration
 299  *
 300  * @param conf
 301  *   Event helper configuration
 302  */
 303 void
 304 eh_display_conf(struct eh_conf *conf);
 305
 306
 307 /**
 308  * Launch eventmode worker
 309  *
 310  * The application can request the eventmode helper subsystem to launch the
 311  * worker based on the capabilities of event device and the options selected
 312  * while initializing the eventmode.
 313  *
 314  * @param conf
 315  *   Event helper configuration
 316  * @param app_wrkr
 317  *   List of all the workers registered by application, along with its
 318  *   capabilities
 319  * @param nb_wrkr_param
 320  *   Number of workers passed by the application
 321  *
 322  */
 323 void
 324 eh_launch_worker(struct eh_conf *conf, struct eh_app_worker_params *app_wrkr,
 325                 uint8_t nb_wrkr_param);
 326
 327 #endif /* _EVENT_HELPER_H_ */