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                         uint64_t event_vector                   : 1;
 175                 /**<
 176                  * Enable event vector, when enabled application can
 177                  * receive vector of events.
 178                  */
 179                         uint64_t vector_size                    : 16;
 180                 };
 181                 uint64_t u64;
 182         } ext_params;
 183                 /**< 64 bit field to specify extended params */
 184         uint64_t vector_tmo_ns;
 185                 /**< Max vector timeout in nanoseconds */
 186 };
 187
 188 /**
 189  * Event helper configuration
 190  */
 191 struct eh_conf {
 192         enum eh_pkt_transfer_mode mode;
 193                 /**< Packet transfer mode of the application */
 194         uint32_t eth_portmask;
 195                 /**<
 196                  * Mask of the eth ports to be used. This portmask would be
 197                  * checked while initializing devices using helper routines.
 198                  */
 199         void *mode_params;
 200                 /**< Mode specific parameters */
 201
 202                 /** Application specific params */
 203         enum eh_ipsec_mode_types ipsec_mode;
 204                 /**< Mode of ipsec run */
 205 };
 206
 207 /* Workers registered by the application */
 208 struct eh_app_worker_params {
 209         union {
 210                 RTE_STD_C11
 211                 struct {
 212                         uint64_t burst : 1;
 213                         /**< Specify status of rx type burst */
 214                         uint64_t tx_internal_port : 1;
 215                         /**< Specify whether tx internal port is available */
 216                         uint64_t ipsec_mode : 1;
 217                         /**< Specify ipsec processing level */
 218                 };
 219                 uint64_t u64;
 220         } cap;
 221                         /**< Capabilities of this worker */
 222         void (*worker_thread)(struct eh_event_link_info *links,
 223                         uint8_t nb_links);
 224                         /**< Worker thread */
 225 };
 226
 227 /**
 228  * Allocate memory for event helper configuration and initialize
 229  * it with default values.
 230  *
 231  * @return
 232  * - pointer to event helper configuration structure on success.
 233  * - NULL on failure.
 234  */
 235 struct eh_conf *
 236 eh_conf_init(void);
 237
 238 /**
 239  * Uninitialize event helper configuration and release its memory
 240 . *
 241  * @param conf
 242  *   Event helper configuration
 243  */
 244 void
 245 eh_conf_uninit(struct eh_conf *conf);
 246
 247 /**
 248  * Initialize event mode devices
 249  *
 250  * Application can call this function to get the event devices, eth devices
 251  * and eth rx & tx adapters initialized according to the default config or
 252  * config populated using the command line args.
 253  *
 254  * Application is expected to initialize the eth devices and then the event
 255  * mode helper subsystem will stop & start eth devices according to its
 256  * requirement. Call to this function should be done after the eth devices
 257  * are successfully initialized.
 258  *
 259  * @param conf
 260  *   Event helper configuration
 261  * @return
 262  *  - 0 on success.
 263  *  - (<0) on failure.
 264  */
 265 int32_t
 266 eh_devs_init(struct eh_conf *conf);
 267
 268 /**
 269  * Release event mode devices
 270  *
 271  * Application can call this function to release event devices,
 272  * eth rx & tx adapters according to the config.
 273  *
 274  * Call to this function should be done before application stops
 275  * and closes eth devices. This function will not close and stop
 276  * eth devices.
 277  *
 278  * @param conf
 279  *   Event helper configuration
 280  * @return
 281  *  - 0 on success.
 282  *  - (<0) on failure.
 283  */
 284 int32_t
 285 eh_devs_uninit(struct eh_conf *conf);
 286
 287 /**
 288  * Get eventdev tx queue
 289  *
 290  * If the application uses event device which does not support internal port
 291  * then it needs to submit the events to a Tx queue before final transmission.
 292  * This Tx queue will be created internally by the eventmode helper subsystem,
 293  * and application will need its queue ID when it runs the execution loop.
 294  *
 295  * @param mode_conf
 296  *   Event helper configuration
 297  * @param eventdev_id
 298  *   Event device ID
 299  * @return
 300  *   Tx queue ID
 301  */
 302 uint8_t
 303 eh_get_tx_queue(struct eh_conf *conf, uint8_t eventdev_id);
 304
 305 /**
 306  * Display event mode configuration
 307  *
 308  * @param conf
 309  *   Event helper configuration
 310  */
 311 void
 312 eh_display_conf(struct eh_conf *conf);
 313
 314
 315 /**
 316  * Launch eventmode worker
 317  *
 318  * The application can request the eventmode helper subsystem to launch the
 319  * worker based on the capabilities of event device and the options selected
 320  * while initializing the eventmode.
 321  *
 322  * @param conf
 323  *   Event helper configuration
 324  * @param app_wrkr
 325  *   List of all the workers registered by application, along with its
 326  *   capabilities
 327  * @param nb_wrkr_param
 328  *   Number of workers passed by the application
 329  *
 330  */
 331 void
 332 eh_launch_worker(struct eh_conf *conf, struct eh_app_worker_params *app_wrkr,
 333                 uint8_t nb_wrkr_param);
 334
 335 #endif /* _EVENT_HELPER_H_ */