> -----Original Message-----
> From: Zhang, Yuying <yuying.zh...@intel.com>
> Sent: Saturday, August 12, 2023 3:55 PM
> To: dev@dpdk.org; Xing, Beilei <beilei.x...@intel.com>; Zhang, Qi Z
> <qi.z.zh...@intel.com>; Wu, Jingjing <jingjing...@intel.com>
> Cc: Zhang, Yuying <yuying.zh...@intel.com>
> Subject: [PATCH v1 5/5] net/cpfl: add fxp flow engine
>
> Adapt fxp low level as a flow engine.
>
> Signed-off-by: Yuying Zhang <yuying.zh...@intel.com>
> Signed-off-by: Qi Zhang <qi.z.zh...@intel.com>
> ---
> drivers/net/cpfl/cpfl_ethdev.h | 85 ++++
> drivers/net/cpfl/cpfl_flow_engine_fxp.c | 610 ++++++++++++++++++++++++
> drivers/net/cpfl/meson.build | 1 +
> 3 files changed, 696 insertions(+)
> create mode 100644 drivers/net/cpfl/cpfl_flow_engine_fxp.c
>
> diff --git a/drivers/net/cpfl/cpfl_ethdev.h b/drivers/net/cpfl/cpfl_ethdev.h
> index 63bcc5551f..d7e9ea1a74 100644
> --- a/drivers/net/cpfl/cpfl_ethdev.h
> +++ b/drivers/net/cpfl/cpfl_ethdev.h
> @@ -92,6 +92,8 @@
<...>
> +static inline uint16_t
> +cpfl_get_vsi_id(struct cpfl_itf *itf)
> +{
> + struct cpfl_adapter_ext *adapter = itf->adapter;
> + struct cpfl_vport_info *info;
> + uint32_t vport_id;
> + int ret;
> + struct cpfl_vport_id vport_identity;
> +
> + if (!itf)
> + return CPFL_INVALID_HW_ID;
> +
> + if (itf->type == CPFL_ITF_TYPE_REPRESENTOR) {
> + struct cpfl_repr *repr = (void *)itf;
> +
> + return repr->vport_info->vport_info.vsi_id;
> + } else if (itf->type == CPFL_ITF_TYPE_VPORT) {
> + vport_id = ((struct cpfl_vport *)itf)->base.vport_id;
> + vport_identity.func_type = CPCHNL2_FUNC_TYPE_PF;
> + /* host: HOST0_CPF_ID, acc: ACC_CPF_ID */
> + vport_identity.pf_id = ACC_CPF_ID;
> + vport_identity.vf_id = 0;
> + vport_identity.vport_id = vport_id;
> +
> + ret = rte_hash_lookup_data(adapter->vport_map_hash,
> &vport_identity,
> + (void **)&info);
> + if (ret < 0) {
> + PMD_DRV_LOG(ERR, "vport id not exist");
> + goto err;
> + }
> +
> + /* rte_spinlock_unlock(&adapter->vport_map_lock); */
So do we need lock in the function?
> + return info->vport_info.vsi_id;
> + }
> +
> +err:
> + /* rte_spinlock_unlock(&adapter->vport_map_lock); */
> + return CPFL_INVALID_HW_ID;
> +}
> +
<...>
>
> #endif /* _CPFL_ETHDEV_H_ */
> diff --git a/drivers/net/cpfl/cpfl_flow_engine_fxp.c
> b/drivers/net/cpfl/cpfl_flow_engine_fxp.c
> new file mode 100644
> index 0000000000..e10639c842
> --- /dev/null
> +++ b/drivers/net/cpfl/cpfl_flow_engine_fxp.c
> @@ -0,0 +1,610 @@
> +/* SPDX-License-Identifier: BSD-3-Clause
> + * Copyright(c) 2023 Intel Corporation
> + */
> +
> +#include <sys/queue.h>
> +#include <stdio.h>
> +#include <errno.h>
> +#include <stdint.h>
> +#include <string.h>
> +#include <unistd.h>
> +#include <stdarg.h>
> +#include <math.h>
> +#include <rte_debug.h>
> +#include <rte_ether.h>
> +#include <ethdev_driver.h>
> +#include <rte_log.h>
> +#include <rte_malloc.h>
> +#include <rte_eth_ctrl.h>
> +#include <rte_tailq.h>
> +#include <rte_flow_driver.h>
> +#include <rte_flow.h>
> +#include <rte_bitmap.h>
> +#include "cpfl_rules.h"
> +#include "cpfl_logs.h"
> +#include "cpfl_ethdev.h"
> +#include "cpfl_flow.h"
> +#include "cpfl_fxp_rule.h"
> +#include "cpfl_flow_parser.h"
> +#include "rte_memcpy.h"
#include <rte_memcpy.h> and move above?
> +
> +#define COOKIE_DEF 0x1000
> +#define PREC_MAX 7
> +#define PREC_DEF 1
> +#define PREC_SET 5
> +#define TYPE_ID 3
> +#define OFFSET 0x0a
> +#define HOST_ID_DEF 0
> +#define PF_NUM_DEF 0
> +#define PORT_NUM_DEF 0
> +#define RESP_REQ_DEF 2
> +#define PIN_TO_CACHE_DEF 0
> +#define CLEAR_MIRROR_1ST_STATE_DEF 0
> +#define FIXED_FETCH_DEF 0
> +#define PTI_DEF 0
> +#define MOD_OBJ_SIZE_DEF 0
> +#define PIN_MOD_CONTENT_DEF 0
> +
> +#define MAX_MOD_CONTENT_INDEX 256
> +#define MAX_MR_ACTION_NUM 8
For the new defined macros in PMD, better to use CPFL_ prefix.
> +
> +struct rule_info_meta {
cpfl_rule_info_meta.
Please check all other macros, global variables, structures and functions, etc.
I will not comment for those.
BTW, Could you add some comments for the new structures and the members? Then
it will be more readable.
> + struct cpfl_flow_pr_action pr_action;
> + uint32_t pr_num;
> + uint32_t mr_num;
> + uint32_t rule_num;
> + struct cpfl_rule_info rules[0];
> +};
> +
> +static uint32_t fxp_mod_idx_alloc(struct cpfl_adapter_ext *ad); static
> +void fxp_mod_idx_free(struct cpfl_adapter_ext *ad, uint32_t idx);
> +uint64_t rule_cookie = COOKIE_DEF;
> +
> +static int
> +cpfl_fxp_create(struct rte_eth_dev *dev,
> + struct rte_flow *flow,
> + void *meta,
> + struct rte_flow_error *error)
> +{
> + int ret = 0;
> + uint32_t cpq_id = 0;
> + struct cpfl_itf *itf = CPFL_DEV_TO_ITF(dev);
> + struct cpfl_adapter_ext *ad = itf->adapter;
> + struct rule_info_meta *rim = meta;
> + struct cpfl_vport *vport;
> +
> + if (!rim)
> + return ret;
> +
> + if (itf->type == CPFL_ITF_TYPE_VPORT) {
> + vport = (struct cpfl_vport *)itf;
> + cpq_id = vport->base.devarg_id * 2;
Why is vport->base.devarg_id * 2 here? Could you add some comments?
> + } else if (itf->type == CPFL_ITF_TYPE_REPRESENTOR) {
So is the patch support both representor rule and represented port action?
It's better to split VPORT and REPRESENTOR support.
> + cpq_id = CPFL_FPCP_CFGQ_TX;
> + } else {
> + rte_flow_error_set(error, EINVAL,
> RTE_FLOW_ERROR_TYPE_HANDLE, NULL,
> + "fail to find correct control queue");
> + return -rte_errno;
> + }
> +
> + ret = cpfl_rule_update(itf, ad->ctlqp[cpq_id], ad->ctlqp[cpq_id + 1],
> + rim->rules, rim->rule_num, true);
OK, I understand the function is to process the rule, right?
So how about cplf_rule_process?
> + if (ret < 0) {
> + rte_flow_error_set(error, EINVAL,
> RTE_FLOW_ERROR_TYPE_HANDLE, NULL,
> + "cpfl filter create flow fail");
> + rte_free(rim);
> + return ret;
> + }
> +
> + flow->rule = rim;
> +
> + return ret;
> +}
> +
> +static inline void
> +cpfl_fxp_rule_free(struct rte_flow *flow) {
> + rte_free(flow->rule);
> + flow->rule = NULL;
> +}
> +
> +static int
> +cpfl_fxp_destroy(struct rte_eth_dev *dev,
> + struct rte_flow *flow,
> + struct rte_flow_error *error)
> +{
> + int ret = 0;
> + uint32_t cpq_id = 0;
> + struct cpfl_itf *itf = CPFL_DEV_TO_ITF(dev);
> + struct cpfl_adapter_ext *ad = itf->adapter;
> + struct rule_info_meta *rim;
> + uint32_t i;
> + struct cpfl_vport *vport;
> +
> + rim = flow->rule;
> + if (!rim) {
> + rte_flow_error_set(error, EINVAL,
> + RTE_FLOW_ERROR_TYPE_HANDLE, NULL,
> + "no such flow create by cpfl filter");
> +
> + cpfl_fxp_rule_free(flow);
flow->rule is NULL, so no need to call the function.
> +
> + return -rte_errno;
> + }
> +
> + if (itf->type == CPFL_ITF_TYPE_VPORT) {
> + vport = (struct cpfl_vport *)itf;
> + cpq_id = vport->base.devarg_id * 2;
> + } else if (itf->type == CPFL_ITF_TYPE_REPRESENTOR) {
> + cpq_id = CPFL_FPCP_CFGQ_TX;
> + } else {
> + rte_flow_error_set(error, EINVAL,
> RTE_FLOW_ERROR_TYPE_HANDLE, NULL,
> + "fail to find correct control queue");
Need to goto err here?
> + return -rte_errno;
> + }
> +
> + ret = cpfl_rule_update(itf, ad->ctlqp[cpq_id], ad->ctlqp[cpq_id + 1],
> rim->rules,
> + rim->rule_num, false);
> + if (ret < 0) {
> + rte_flow_error_set(error, EINVAL,
> + RTE_FLOW_ERROR_TYPE_HANDLE, NULL,
> + "fail to destroy cpfl filter rule");
> + goto err;
> + }
> +
> + /* free mod index */
> + for (i = rim->pr_num; i < rim->rule_num; i++)
> + fxp_mod_idx_free(ad, rim->rules[i].mod.mod_index);
> +err:
> + cpfl_fxp_rule_free(flow);
> + return ret;
> +}
> +
<...>
> +
> +static int
> +cpfl_parse_mod_content(struct cpfl_adapter_ext *adapter,
> + struct cpfl_rule_info *match_rinfo,
> + struct cpfl_rule_info *mod_rinfo,
> + const struct cpfl_flow_mr_action *mr_action) {
> + struct cpfl_mod_rule_info *minfo = &mod_rinfo->mod;
> + uint32_t mod_idx;
> + int i;
> + int next = match_rinfo->act_byte_len / (sizeof(union cpfl_action_set));
> + union cpfl_action_set *act_set =
> + &((union cpfl_action_set *)match_rinfo->act_bytes)[next];
> +
> + if (!mr_action || mr_action->type != CPFL_JS_MR_ACTION_TYPE_MOD)
> + return -EINVAL;
> +
> + *act_set = cpfl_act_mod_profile(PREC_DEF,
> + mr_action->mod.prof,
> + PTI_DEF,
> + 0, /* append */
> + 0, /* prepend */
> +
> CPFL_ACT_MOD_PROFILE_PREFETCH_256B);
> +
> + act_set++;
> + match_rinfo->act_byte_len += sizeof(union cpfl_action_set);
> +
> + mod_idx = fxp_mod_idx_alloc(adapter);
> + if (mod_idx == MAX_MOD_CONTENT_INDEX) {
> + PMD_DRV_LOG(ERR, "Out of Mod Index.");
> + return -ENOMEM;
> + }
> +
> + *act_set = cpfl_act_mod_addr(PREC_DEF, mod_idx);
> +
> + act_set++;
> + match_rinfo->act_byte_len += sizeof(union cpfl_action_set);
> +
> + mod_rinfo->type = CPFL_RULE_TYPE_MOD;
> + minfo->mod_obj_size = MOD_OBJ_SIZE_DEF;
> + minfo->pin_mod_content = PIN_MOD_CONTENT_DEF;
> + minfo->mod_index = mod_idx;
> + mod_rinfo->cookie = 0x1237561;
How about add a macro for 0x1237561?
> + mod_rinfo->port_num = PORT_NUM_DEF;
> + mod_rinfo->resp_req = RESP_REQ_DEF;
> +
> + minfo->mod_content_byte_len = mr_action->mod.byte_len + 2;
> + for (i = 0; i < minfo->mod_content_byte_len; i++)
> + minfo->mod_content[i] = mr_action->mod.data[i];
> +
> + return 0;
> +}
> +
> +static int
> +cpfl_fxp_parse_action(struct cpfl_itf *itf,
> + const struct rte_flow_action *actions,
> + const struct cpfl_flow_mr_action *mr_action,
> + struct rule_info_meta *rim,
> + int priority,
> + int index,
> + bool is_vport_rule)
> +{
> + const struct rte_flow_action_ethdev *act_ethdev;
> + const struct rte_flow_action *action;
> + const struct rte_flow_action_queue *act_q;
> + const struct rte_flow_action_rss *rss;
> + struct rte_eth_dev_data *data;
> + enum rte_flow_action_type action_type;
> + struct cpfl_vport *vport;
> + /* used when action is REPRESENTED_PORT or REPRESENTED_PORT
> type */
Represented port or port representor?
Also, can we split the VPORT and REPRESENTOR flow support?
> + struct cpfl_itf *dst_itf;
> + uint16_t dev_id; /*vsi_id or phyical port id*/
> + bool is_vsi;
> + bool set_meta_valid = false;
> + int queue_id = -1;
> + bool fwd_vsi = false;
> + bool fwd_q = false;
> + bool fwd_jump = false;
> + uint32_t i;
> + struct cpfl_rule_info *rinfo = &rim->rules[index];
> + union cpfl_action_set *act_set = (void *)rinfo->act_bytes;
> +
> + priority = PREC_MAX - priority;
> + for (action = actions; action->type !=
> + RTE_FLOW_ACTION_TYPE_END; action++) {
> + action_type = action->type;
> + switch (action_type) {
> + case RTE_FLOW_ACTION_TYPE_REPRESENTED_PORT:
> + case RTE_FLOW_ACTION_TYPE_PORT_REPRESENTOR:
> + if (!fwd_vsi && !fwd_jump)
> + fwd_vsi = true;
> + else
> + goto err;
> + if (is_vport_rule) {
> + dst_itf = itf;
> + } else {
> + act_ethdev = action->conf;
> + dst_itf = cpfl_get_itf_by_port_id(act_ethdev-
> >port_id);
> + }
> +
> + if (!dst_itf)
> + goto err;
> +
> + if (dst_itf->type == CPFL_ITF_TYPE_VPORT) {
> + vport = (struct cpfl_vport *)dst_itf;
> + queue_id = vport-
> >base.chunks_info.rx_start_qid;
> + } else {
> + queue_id = -2;
Why's -2 here?
> + }
> +
> + is_vsi = (action_type ==
> RTE_FLOW_ACTION_TYPE_PORT_REPRESENTOR ||
> + dst_itf->type ==
> CPFL_ITF_TYPE_REPRESENTOR);
> + if (is_vsi || is_vport_rule)
> + dev_id = cpfl_get_vsi_id(dst_itf);
> + else
> + dev_id = cpfl_get_port_id(dst_itf);
> +
> + if (dev_id == CPFL_INVALID_HW_ID)
> + goto err;
> +
> + if (is_vsi || is_vport_rule)
> + *act_set = cpfl_act_fwd_vsi(0, priority, 0,
> dev_id);
> + else
> + *act_set = cpfl_act_fwd_port(0, priority, 0,
> dev_id);
> + act_set++;
> + rinfo->act_byte_len += sizeof(union cpfl_action_set);
> + break;
> + case RTE_FLOW_ACTION_TYPE_QUEUE:
> + if (!fwd_q && !fwd_jump)
> + fwd_q = true;
> + else
> + goto err;
> + if (queue_id == -2)
> + goto err;
> + act_q = action->conf;
> + data = itf->data;
> + if (act_q->index >= data->nb_rx_queues)
> + goto err;
> +
> + vport = (struct cpfl_vport *)itf;
> + if (queue_id < 0)
> + queue_id = vport-
> >base.chunks_info.rx_start_qid;
> + queue_id += act_q->index;
> + *act_set = cpfl_act_set_hash_queue(priority, 0,
> queue_id, 0);
> + act_set++;
> + rinfo->act_byte_len += sizeof(union cpfl_action_set);
> + break;
> + case RTE_FLOW_ACTION_TYPE_RSS:
> + rss = action->conf;
> + if (rss->queue_num <= 1)
> + goto err;
> + for (i = 0; i < rss->queue_num - 1; i++) {
> + if (rss->queue[i + 1] != rss->queue[i] + 1)
> + goto err;
> + }
> + data = itf->data;
> + if (rss->queue[rss->queue_num - 1] >= data-
> >nb_rx_queues)
> + goto err;
> +#define FXP_MAX_QREGION_SIZE 128
> + if (!(rte_is_power_of_2(rss->queue_num) &&
> + rss->queue_num <= FXP_MAX_QREGION_SIZE))
> + goto err;
> +
> + if (!fwd_q && !fwd_jump)
> + fwd_q = true;
> + else
> + goto err;
> + if (queue_id == -2)
> + goto err;
> + vport = (struct cpfl_vport *)itf;
> + if (queue_id < 0)
> + queue_id = vport-
> >base.chunks_info.rx_start_qid;
> + queue_id += rss->queue[0];
> + *act_set = cpfl_act_set_hash_queue_region(priority, 0,
> queue_id,
> + log(rss-
> >queue_num) / log(2), 0);
> + act_set++;
> + rinfo->act_byte_len += sizeof(union cpfl_action_set);
> + break;
> + case RTE_FLOW_ACTION_TYPE_DROP:
> + (*act_set).data = cpfl_act_drop(priority).data;
> + act_set++;
> + rinfo->act_byte_len += sizeof(union cpfl_action_set);
> + (*act_set).data = cpfl_act_set_commit_mode(priority,
> 0).data;
> + act_set++;
> + rinfo->act_byte_len += sizeof(union cpfl_action_set);
> + break;
> + case RTE_FLOW_ACTION_TYPE_VXLAN_ENCAP:
> + case RTE_FLOW_ACTION_TYPE_VXLAN_DECAP:
> + break;
> + case RTE_FLOW_ACTION_TYPE_VOID:
> + break;
> + default:
> + goto err;
> + }
> + }
> +
> + if (mr_action != NULL && !set_meta_valid) {
> + uint32_t i;
> +
> + for (i = 0; i < rim->mr_num; i++)
> + if (cpfl_parse_mod_content(itf->adapter, rinfo,
> + &rim->rules[rim->pr_num +
> i],
> + &mr_action[i]))
> + goto err;
> + }
> +
> + return 0;
> +
> +err:
> + PMD_DRV_LOG(ERR, "Invalid action type");
> + return -EINVAL;
> +}
> +
> [] <...>
> +
> +static int
> +cpfl_fxp_parse_pattern_action(struct rte_eth_dev *dev,
> + const struct rte_flow_attr *attr,
> + const struct rte_flow_item pattern[],
> + const struct rte_flow_action actions[],
> + void **meta)
> +{
> + struct cpfl_itf *itf = CPFL_DEV_TO_ITF(dev);
> + struct cpfl_flow_pr_action pr_action = { 0 };
> + struct cpfl_adapter_ext *adapter = itf->adapter;
> + struct cpfl_flow_mr_action mr_action[MAX_MR_ACTION_NUM] = { 0 };
> + uint32_t pr_num = 0, mr_num = 0;
> + struct cpfl_vport *vport;
> + struct rule_info_meta *rim;
> + bool set_meta_valid = false;
> + int ret;
> +
> + if (itf->type == CPFL_ITF_TYPE_VPORT) {
> + vport = (struct cpfl_vport *)itf;
> + if (vport->exceptional) {
Exception vport won't be in this release, so remove it.
> + PMD_DRV_LOG(ERR, "Can't create rte_flow with
> exceptional vport.");
> + return -EINVAL;
> + }
> + }
> +
> + ret = cpfl_flow_parse_items(adapter->flow_parser, pattern, attr,
> &pr_action);
> + if (ret) {
> + PMD_DRV_LOG(ERR, "No Match pattern support.");
> + return -EINVAL;
> + }
> +
> + if (is_mod_action(actions, &set_meta_valid)) {
> + ret = cpfl_flow_parse_actions(adapter->flow_parser, actions,
> mr_action);
> + if (ret) {
> + PMD_DRV_LOG(ERR, "action parse fails.");
> + return -EINVAL;
> + }
> + if (!set_meta_valid)
> + mr_num++;
> + }
> +
> + pr_num = 1;
> + rim = rte_zmalloc(NULL,
> + sizeof(struct rule_info_meta) +
> + (pr_num + mr_num) * sizeof(struct cpfl_rule_info),
> + 0);
> + if (!rim)
> + return -ENOMEM;
> +
> + rim->pr_action = pr_action;
> + rim->pr_num = pr_num;
> + rim->mr_num = mr_num;
> + rim->rule_num = pr_num + mr_num;
> +
> + if (!cpfl_fxp_parse_pattern(&pr_action, rim, 0)) {
> + PMD_DRV_LOG(ERR, "Invalid input set");
Invalid pattern?
> + rte_free(rim);
> + return -rte_errno;
> + }
> +
> + if (cpfl_fxp_parse_action(itf, actions, mr_action, rim, attr->priority,
> + 0, false)) {
> + PMD_DRV_LOG(ERR, "Invalid input set");
Invalid action?
> + rte_free(rim);
> + return -rte_errno;
> + }
> +
> + cpfl_fill_rinfo_default_value(&rim->rules[0]);
> +
> + if (!meta)
> + rte_free(rim);
> + else
> + *meta = rim;
> +
> + return 0;
> +}
> +
> +static int fxp_mod_init(struct cpfl_adapter_ext *ad) {
Check and refine the functions' coding style.
> + uint32_t size =
> +rte_bitmap_get_memory_footprint(MAX_MOD_CONTENT_INDEX);
> +
> + void *mem = rte_zmalloc(NULL, size, RTE_CACHE_LINE_SIZE);
> +
> + if (!mem)
> + return -ENOMEM;
> +
> + /* a set bit represent a free slot */
> + ad->mod_bm =
> rte_bitmap_init_with_all_set(MAX_MOD_CONTENT_INDEX, mem, size);
> + if (!ad->mod_bm) {
> + rte_free(mem);
> + return -EINVAL;
> + }
> +
> + ad->mod_bm_mem = mem;
> +
> + return 0;
> +}
> +
> +static void fxp_mod_uninit(struct cpfl_adapter_ext *ad) {
> + rte_free(ad->mod_bm_mem);
> + ad->mod_bm_mem = NULL;
> + ad->mod_bm = NULL;
> +}
> +
> +static uint32_t fxp_mod_idx_alloc(struct cpfl_adapter_ext *ad) {
> + uint64_t slab = 0;
> + uint32_t pos = 0;
> +
> + if (!rte_bitmap_scan(ad->mod_bm, &pos, &slab))
> + return MAX_MOD_CONTENT_INDEX;
> +
> + pos += __builtin_ffsll(slab) - 1;
> + rte_bitmap_clear(ad->mod_bm, pos);
> +
> + return pos;
> +}
> +
> +static void fxp_mod_idx_free(struct cpfl_adapter_ext *ad, uint32_t idx)
> +{
> + rte_bitmap_set(ad->mod_bm, idx);
> +}
What's the benefit of the function? Can we call rte_bitmap_set directly?
> +
> +static int
> +cpfl_fxp_query(struct rte_eth_dev *dev __rte_unused,
> + struct rte_flow *flow __rte_unused,
> + struct rte_flow_query_count *count __rte_unused,
> + struct rte_flow_error *error)
> +{
> + rte_flow_error_set(error, EINVAL,
> + RTE_FLOW_ERROR_TYPE_HANDLE,
> + NULL,
> + "count action not supported by this module");
> +
> + return -rte_errno;
> +}
> +
> +static void
> +cpfl_fxp_uninit(struct cpfl_adapter_ext *ad) {
> + fxp_mod_uninit(ad);
> +}
Why do we need the function wrapper?
> +
> +static int
> +cpfl_fxp_init(struct cpfl_adapter_ext *ad) {
> + int ret = 0;
> +
> + ret = fxp_mod_init(ad);
> + if (ret) {
> + PMD_DRV_LOG(ERR, "Failed to init mod content bitmap.");
> + return ret;
> + }
> +
> + return ret;
> +}
> +
> +static struct
> +cpfl_flow_engine cpfl_fxp_engine = {
> + .type = CPFL_FLOW_ENGINE_FXP,
> + .init = cpfl_fxp_init,
> + .uninit = cpfl_fxp_uninit,
> + .create = cpfl_fxp_create,
> + .destroy = cpfl_fxp_destroy,
> + .query_count = cpfl_fxp_query,
> + .parse_pattern_action = cpfl_fxp_parse_pattern_action, };
> +
> +RTE_INIT(cpfl_sw_engine_init)
> +{
> + struct cpfl_flow_engine *engine = &cpfl_fxp_engine;
> +
> + cpfl_flow_engine_register(engine);
> +}
> diff --git a/drivers/net/cpfl/meson.build b/drivers/net/cpfl/meson.build index
> 4061123034..ce46d7e76e 100644
> --- a/drivers/net/cpfl/meson.build
> +++ b/drivers/net/cpfl/meson.build
> @@ -43,6 +43,7 @@ js_dep = dependency('json-c', required: false, method :
> 'pkg-config') if js_dep.found()
> sources += files(
> 'cpfl_flow.c',
> + 'cpfl_flow_engine_fxp.c',
> 'cpfl_flow_parser.c',
> 'cpfl_rules.c',
> 'cpfl_controlq.c',
> --
> 2.25.1
