@@ -304,3 +304,121 @@
return 0;
}
+
+int
+nfp_flower_cmsg_tun_off_v4(struct nfp_app_fw_flower *app_fw_flower)
+{
+ uint16_t cnt;
+ uint32_t count = 0;
+ struct rte_mbuf *mbuf;
+ struct nfp_flow_priv *priv;
+ struct nfp_ipv4_addr_entry *entry;
+ struct nfp_flower_cmsg_tun_ipv4_addr *msg;
+
+ mbuf = rte_pktmbuf_alloc(app_fw_flower->ctrl_pktmbuf_pool);
+ if (mbuf == NULL) {
+ PMD_DRV_LOG(DEBUG, "Failed to alloc mbuf for v4 tun addr");
+ return -ENOMEM;
+ }
+
+ msg = nfp_flower_cmsg_init(mbuf, NFP_FLOWER_CMSG_TYPE_TUN_IPS, sizeof(*msg));
+
+ priv = app_fw_flower->flow_priv;
+ rte_spinlock_lock(&priv->ipv4_off_lock);
+ LIST_FOREACH(entry, &priv->ipv4_off_list, next) {
+ if (count >= NFP_FL_IPV4_ADDRS_MAX) {
+ rte_spinlock_unlock(&priv->ipv4_off_lock);
+ PMD_DRV_LOG(ERR, "IPv4 offload exceeds limit.");
+ return -ERANGE;
+ }
+ msg->ipv4_addr[count] = entry->ipv4_addr;
+ count++;
+ }
+ msg->count = rte_cpu_to_be_32(count);
+ rte_spinlock_unlock(&priv->ipv4_off_lock);
+
+ cnt = nfp_flower_ctrl_vnic_xmit(app_fw_flower, mbuf);
+ if (cnt == 0) {
+ PMD_DRV_LOG(ERR, "Send cmsg through ctrl vnic failed.");
+ rte_pktmbuf_free(mbuf);
+ return -EIO;
+ }
+
+ return 0;
+}
+
+int
+nfp_flower_cmsg_pre_tunnel_rule(struct nfp_app_fw_flower *app_fw_flower,
+ struct nfp_fl_rule_metadata *nfp_flow_meta,
+ uint16_t mac_idx,
+ bool is_del)
+{
+ uint16_t cnt;
+ struct rte_mbuf *mbuf;
+ struct nfp_flower_meta_tci *meta_tci;
+ struct nfp_flower_cmsg_pre_tun_rule *msg;
+
+ mbuf = rte_pktmbuf_alloc(app_fw_flower->ctrl_pktmbuf_pool);
+ if (mbuf == NULL) {
+ PMD_DRV_LOG(DEBUG, "Failed to alloc mbuf for pre tunnel rule");
+ return -ENOMEM;
+ }
+
+ msg = nfp_flower_cmsg_init(mbuf, NFP_FLOWER_CMSG_TYPE_PRE_TUN_RULE, sizeof(*msg));
+
+ meta_tci = (struct nfp_flower_meta_tci *)((char *)nfp_flow_meta +
+ sizeof(struct nfp_fl_rule_metadata));
+ if (meta_tci->tci)
+ msg->vlan_tci = meta_tci->tci;
+ else
+ msg->vlan_tci = 0xffff;
+
+ if (is_del)
+ msg->flags = rte_cpu_to_be_32(NFP_TUN_PRE_TUN_RULE_DEL);
+
+ msg->port_idx = rte_cpu_to_be_16(mac_idx);
+ msg->host_ctx_id = nfp_flow_meta->host_ctx_id;
+
+ cnt = nfp_flower_ctrl_vnic_xmit(app_fw_flower, mbuf);
+ if (cnt == 0) {
+ PMD_DRV_LOG(ERR, "Send cmsg through ctrl vnic failed.");
+ rte_pktmbuf_free(mbuf);
+ return -EIO;
+ }
+
+ return 0;
+}
+
+int
+nfp_flower_cmsg_tun_mac_rule(struct nfp_app_fw_flower *app_fw_flower,
+ struct rte_ether_addr *mac,
+ uint16_t mac_idx,
+ bool is_del)
+{
+ uint16_t cnt;
+ struct rte_mbuf *mbuf;
+ struct nfp_flower_cmsg_tun_mac *msg;
+
+ mbuf = rte_pktmbuf_alloc(app_fw_flower->ctrl_pktmbuf_pool);
+ if (mbuf == NULL) {
+ PMD_DRV_LOG(DEBUG, "Failed to alloc mbuf for tunnel mac");
+ return -ENOMEM;
+ }
+
+ msg = nfp_flower_cmsg_init(mbuf, NFP_FLOWER_CMSG_TYPE_TUN_MAC, sizeof(*msg));
+
+ msg->count = rte_cpu_to_be_16(1);
+ msg->index = rte_cpu_to_be_16(mac_idx);
+ rte_ether_addr_copy(mac, &msg->addr);
+ if (is_del)
+ msg->flags = rte_cpu_to_be_16(NFP_TUN_MAC_OFFLOAD_DEL_FLAG);
+
+ cnt = nfp_flower_ctrl_vnic_xmit(app_fw_flower, mbuf);
+ if (cnt == 0) {
+ PMD_DRV_LOG(ERR, "Send cmsg through ctrl vnic failed.");
+ rte_pktmbuf_free(mbuf);
+ return -EIO;
+ }
+
+ return 0;
+}
@@ -195,6 +195,91 @@ struct nfp_flower_cmsg_tun_neigh_v6 {
struct nfp_flower_tun_neigh common;
};
+#define NFP_TUN_PRE_TUN_RULE_DEL (1 << 0)
+#define NFP_TUN_PRE_TUN_IDX_BIT (1 << 3)
+#define NFP_TUN_PRE_TUN_IPV6_BIT (1 << 7)
+
+/*
+ * NFP_FLOWER_CMSG_TYPE_PRE_TUN_RULE
+ * Bit 3 3 2 2 2 2 2 2 2 2 2 2 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0
+ * -----\ 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0
+ * +---------------------------------------------------------------+
+ * 0 | FLAGS |
+ * +---------------------------------------------------------------+
+ * 1 | MAC_IDX | VLAN_ID |
+ * +---------------------------------------------------------------+
+ * 2 | HOST_CTX |
+ * +---------------------------------------------------------------+
+ */
+struct nfp_flower_cmsg_pre_tun_rule {
+ rte_be32_t flags;
+ rte_be16_t port_idx;
+ rte_be16_t vlan_tci;
+ rte_be32_t host_ctx_id;
+};
+
+#define NFP_TUN_MAC_OFFLOAD_DEL_FLAG 0x2
+
+/*
+ * NFP_FLOWER_CMSG_TYPE_TUN_MAC
+ * Bit 3 3 2 2 2 2 2 2 2 2 2 2 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0
+ * -----\ 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0
+ * Word +-----------------------+---+-+-+---------------+---------------+
+ * 0 | spare |NBI|D|F| Amount of MAC’s in this msg |
+ * +---------------+-------+---+-+-+---------------+---------------+
+ * 1 | Index 0 | MAC[0] | MAC[1] |
+ * +---------------+---------------+---------------+---------------+
+ * 2 | MAC[2] | MAC[3] | MAC[4] | MAC[5] |
+ * +---------------+---------------+---------------+---------------+
+ * 3 | Index 1 | MAC[0] | MAC[1] |
+ * +---------------+---------------+---------------+---------------+
+ * 4 | MAC[2] | MAC[3] | MAC[4] | MAC[5] |
+ * +---------------+---------------+---------------+---------------+
+ * ...
+ * +---------------+---------------+---------------+---------------+
+ * 2N-1 | Index N | MAC[0] | MAC[1] |
+ * +---------------+---------------+---------------+---------------+
+ * 2N | MAC[2] | MAC[3] | MAC[4] | MAC[5] |
+ * +---------------+---------------+---------------+---------------+
+ *
+ * F: Flush bit. Set if entire table must be flushed. Rest of info in cmsg
+ * will be ignored. Not implemented.
+ * D: Delete bit. Set if entry must be deleted instead of added
+ * NBI: Network Block Interface. Set to 0
+ * The amount of MAC’s per control message is limited only by the packet
+ * buffer size. A 2048B buffer can fit 253 MAC address and a 10240B buffer
+ * 1277 MAC addresses.
+ */
+struct nfp_flower_cmsg_tun_mac {
+ rte_be16_t flags;
+ rte_be16_t count; /**< Should always be 1 */
+ rte_be16_t index;
+ struct rte_ether_addr addr;
+};
+
+#define NFP_FL_IPV4_ADDRS_MAX 32
+
+/*
+ * NFP_FLOWER_CMSG_TYPE_TUN_IPS
+ * Bit 3 3 2 2 2 2 2 2 2 2 2 2 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0
+ * -----\ 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0
+ * +---------------------------------------------------------------+
+ * 0 | Number of IP Addresses |
+ * +---------------------------------------------------------------+
+ * 1 | IP Address #1 |
+ * +---------------------------------------------------------------+
+ * 2 | IP Address #2 |
+ * +---------------------------------------------------------------+
+ * | ... |
+ * +---------------------------------------------------------------+
+ * 32 | IP Address #32 |
+ * +---------------------------------------------------------------+
+ */
+struct nfp_flower_cmsg_tun_ipv4_addr {
+ rte_be32_t count;
+ rte_be32_t ipv4_addr[NFP_FL_IPV4_ADDRS_MAX];
+};
+
/*
* NFP_FLOWER_CMSG_TYPE_FLOW_STATS
* Bit 3 3 2 2 2 2 2 2 2 2 2 2 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0
@@ -716,5 +801,14 @@ int nfp_flower_cmsg_tun_neigh_v4_rule(struct nfp_app_fw_flower *app_fw_flower,
struct nfp_flower_cmsg_tun_neigh_v4 *payload);
int nfp_flower_cmsg_tun_neigh_v6_rule(struct nfp_app_fw_flower *app_fw_flower,
struct nfp_flower_cmsg_tun_neigh_v6 *payload);
+int nfp_flower_cmsg_tun_off_v4(struct nfp_app_fw_flower *app_fw_flower);
+int nfp_flower_cmsg_pre_tunnel_rule(struct nfp_app_fw_flower *app_fw_flower,
+ struct nfp_fl_rule_metadata *nfp_flow_meta,
+ uint16_t mac_idx,
+ bool is_del);
+int nfp_flower_cmsg_tun_mac_rule(struct nfp_app_fw_flower *app_fw_flower,
+ struct rte_ether_addr *mac,
+ uint16_t mac_idx,
+ bool is_del);
#endif /* _NFP_CMSG_H_ */
@@ -47,7 +47,8 @@ struct nfp_flow_item_proc {
/* Size in bytes for @p mask_support and @p mask_default. */
const unsigned int mask_sz;
/* Merge a pattern item into a flow rule handle. */
- int (*merge)(struct rte_flow *nfp_flow,
+ int (*merge)(struct nfp_app_fw_flower *app_fw_flower,
+ struct rte_flow *nfp_flow,
char **mbuf_off,
const struct rte_flow_item *item,
const struct nfp_flow_item_proc *proc,
@@ -63,6 +64,12 @@ struct nfp_mask_id_entry {
uint8_t mask_id;
};
+struct nfp_pre_tun_entry {
+ uint16_t mac_index;
+ uint16_t ref_cnt;
+ uint8_t mac_addr[RTE_ETHER_ADDR_LEN];
+} __rte_aligned(32);
+
static inline struct nfp_flow_priv *
nfp_flow_dev_to_priv(struct rte_eth_dev *dev)
{
@@ -417,6 +424,83 @@ struct nfp_mask_id_entry {
return 0;
}
+__rte_unused static int
+nfp_tun_add_ipv4_off(struct nfp_app_fw_flower *app_fw_flower,
+ rte_be32_t ipv4)
+{
+ struct nfp_flow_priv *priv;
+ struct nfp_ipv4_addr_entry *entry;
+ struct nfp_ipv4_addr_entry *tmp_entry;
+
+ priv = app_fw_flower->flow_priv;
+
+ rte_spinlock_lock(&priv->ipv4_off_lock);
+ LIST_FOREACH(entry, &priv->ipv4_off_list, next) {
+ if (entry->ipv4_addr == ipv4) {
+ entry->ref_count++;
+ rte_spinlock_unlock(&priv->ipv4_off_lock);
+ return 0;
+ }
+ }
+ rte_spinlock_unlock(&priv->ipv4_off_lock);
+
+ tmp_entry = rte_zmalloc("nfp_ipv4_off", sizeof(struct nfp_ipv4_addr_entry), 0);
+ if (tmp_entry == NULL) {
+ PMD_DRV_LOG(ERR, "Mem error when offloading IP address.");
+ return -ENOMEM;
+ }
+
+ tmp_entry->ipv4_addr = ipv4;
+ tmp_entry->ref_count = 1;
+
+ rte_spinlock_lock(&priv->ipv4_off_lock);
+ LIST_INSERT_HEAD(&priv->ipv4_off_list, tmp_entry, next);
+ rte_spinlock_unlock(&priv->ipv4_off_lock);
+
+ return nfp_flower_cmsg_tun_off_v4(app_fw_flower);
+}
+
+static int
+nfp_tun_del_ipv4_off(struct nfp_app_fw_flower *app_fw_flower,
+ rte_be32_t ipv4)
+{
+ struct nfp_flow_priv *priv;
+ struct nfp_ipv4_addr_entry *entry;
+
+ priv = app_fw_flower->flow_priv;
+
+ rte_spinlock_lock(&priv->ipv4_off_lock);
+ LIST_FOREACH(entry, &priv->ipv4_off_list, next) {
+ if (entry->ipv4_addr == ipv4) {
+ entry->ref_count--;
+ if (entry->ref_count == 0) {
+ LIST_REMOVE(entry, next);
+ rte_free(entry);
+ rte_spinlock_unlock(&priv->ipv4_off_lock);
+ return nfp_flower_cmsg_tun_off_v4(app_fw_flower);
+ }
+ break;
+ }
+ }
+ rte_spinlock_unlock(&priv->ipv4_off_lock);
+
+ return 0;
+}
+
+static int
+nfp_tun_check_ip_off_del(struct nfp_flower_representor *repr,
+ struct rte_flow *nfp_flow)
+{
+ int ret;
+ struct nfp_flower_ipv4_udp_tun *udp4;
+
+ udp4 = (struct nfp_flower_ipv4_udp_tun *)(nfp_flow->payload.mask_data -
+ sizeof(struct nfp_flower_ipv4_udp_tun));
+ ret = nfp_tun_del_ipv4_off(repr->app_fw_flower, udp4->ipv4.dst);
+
+ return ret;
+}
+
static void
nfp_flower_compile_meta_tci(char *mbuf_off, struct nfp_fl_key_ls *key_layer)
{
@@ -653,6 +737,9 @@ struct nfp_mask_id_entry {
case RTE_FLOW_ACTION_TYPE_RSS:
PMD_DRV_LOG(DEBUG, "RTE_FLOW_ACTION_TYPE_RSS detected");
break;
+ case RTE_FLOW_ACTION_TYPE_JUMP:
+ PMD_DRV_LOG(DEBUG, "RTE_FLOW_ACTION_TYPE_JUMP detected");
+ break;
case RTE_FLOW_ACTION_TYPE_PORT_ID:
PMD_DRV_LOG(DEBUG, "RTE_FLOW_ACTION_TYPE_PORT_ID detected");
key_ls->act_size += sizeof(struct nfp_fl_act_output);
@@ -804,7 +891,8 @@ struct nfp_mask_id_entry {
}
static int
-nfp_flow_merge_eth(__rte_unused struct rte_flow *nfp_flow,
+nfp_flow_merge_eth(__rte_unused struct nfp_app_fw_flower *app_fw_flower,
+ __rte_unused struct rte_flow *nfp_flow,
char **mbuf_off,
const struct rte_flow_item *item,
const struct nfp_flow_item_proc *proc,
@@ -841,7 +929,8 @@ struct nfp_mask_id_entry {
}
static int
-nfp_flow_merge_vlan(struct rte_flow *nfp_flow,
+nfp_flow_merge_vlan(__rte_unused struct nfp_app_fw_flower *app_fw_flower,
+ struct rte_flow *nfp_flow,
__rte_unused char **mbuf_off,
const struct rte_flow_item *item,
const struct nfp_flow_item_proc *proc,
@@ -871,7 +960,8 @@ struct nfp_mask_id_entry {
}
static int
-nfp_flow_merge_ipv4(struct rte_flow *nfp_flow,
+nfp_flow_merge_ipv4(__rte_unused struct nfp_app_fw_flower *app_fw_flower,
+ struct rte_flow *nfp_flow,
char **mbuf_off,
const struct rte_flow_item *item,
const struct nfp_flow_item_proc *proc,
@@ -932,7 +1022,8 @@ struct nfp_mask_id_entry {
}
static int
-nfp_flow_merge_ipv6(struct rte_flow *nfp_flow,
+nfp_flow_merge_ipv6(__rte_unused struct nfp_app_fw_flower *app_fw_flower,
+ struct rte_flow *nfp_flow,
char **mbuf_off,
const struct rte_flow_item *item,
const struct nfp_flow_item_proc *proc,
@@ -997,7 +1088,8 @@ struct nfp_mask_id_entry {
}
static int
-nfp_flow_merge_tcp(struct rte_flow *nfp_flow,
+nfp_flow_merge_tcp(__rte_unused struct nfp_app_fw_flower *app_fw_flower,
+ struct rte_flow *nfp_flow,
char **mbuf_off,
const struct rte_flow_item *item,
const struct nfp_flow_item_proc *proc,
@@ -1070,7 +1162,8 @@ struct nfp_mask_id_entry {
}
static int
-nfp_flow_merge_udp(struct rte_flow *nfp_flow,
+nfp_flow_merge_udp(__rte_unused struct nfp_app_fw_flower *app_fw_flower,
+ struct rte_flow *nfp_flow,
char **mbuf_off,
const struct rte_flow_item *item,
const struct nfp_flow_item_proc *proc,
@@ -1118,7 +1211,8 @@ struct nfp_mask_id_entry {
}
static int
-nfp_flow_merge_sctp(struct rte_flow *nfp_flow,
+nfp_flow_merge_sctp(__rte_unused struct nfp_app_fw_flower *app_fw_flower,
+ struct rte_flow *nfp_flow,
char **mbuf_off,
const struct rte_flow_item *item,
const struct nfp_flow_item_proc *proc,
@@ -1160,7 +1254,8 @@ struct nfp_mask_id_entry {
}
static int
-nfp_flow_merge_vxlan(struct rte_flow *nfp_flow,
+nfp_flow_merge_vxlan(__rte_unused struct nfp_app_fw_flower *app_fw_flower,
+ struct rte_flow *nfp_flow,
char **mbuf_off,
const struct rte_flow_item *item,
const struct nfp_flow_item_proc *proc,
@@ -1409,7 +1504,8 @@ struct nfp_mask_id_entry {
}
static int
-nfp_flow_compile_item_proc(const struct rte_flow_item items[],
+nfp_flow_compile_item_proc(struct nfp_flower_representor *repr,
+ const struct rte_flow_item items[],
struct rte_flow *nfp_flow,
char **mbuf_off_exact,
char **mbuf_off_mask,
@@ -1420,6 +1516,7 @@ struct nfp_mask_id_entry {
bool continue_flag = true;
const struct rte_flow_item *item;
const struct nfp_flow_item_proc *proc_list;
+ struct nfp_app_fw_flower *app_fw_flower = repr->app_fw_flower;
proc_list = nfp_flow_item_proc_list;
for (item = items; item->type != RTE_FLOW_ITEM_TYPE_END && continue_flag; ++item) {
@@ -1455,14 +1552,14 @@ struct nfp_mask_id_entry {
break;
}
- ret = proc->merge(nfp_flow, mbuf_off_exact, item,
+ ret = proc->merge(app_fw_flower, nfp_flow, mbuf_off_exact, item,
proc, false, is_outer_layer);
if (ret != 0) {
PMD_DRV_LOG(ERR, "nfp flow item %d exact merge failed", item->type);
break;
}
- ret = proc->merge(nfp_flow, mbuf_off_mask, item,
+ ret = proc->merge(app_fw_flower, nfp_flow, mbuf_off_mask, item,
proc, true, is_outer_layer);
if (ret != 0) {
PMD_DRV_LOG(ERR, "nfp flow item %d mask merge failed", item->type);
@@ -1476,7 +1573,7 @@ struct nfp_mask_id_entry {
}
static int
-nfp_flow_compile_items(__rte_unused struct nfp_flower_representor *representor,
+nfp_flow_compile_items(struct nfp_flower_representor *representor,
const struct rte_flow_item items[],
struct rte_flow *nfp_flow)
{
@@ -1507,7 +1604,7 @@ struct nfp_mask_id_entry {
is_outer_layer = false;
/* Go over items */
- ret = nfp_flow_compile_item_proc(loop_item, nfp_flow,
+ ret = nfp_flow_compile_item_proc(representor, loop_item, nfp_flow,
&mbuf_off_exact, &mbuf_off_mask, is_outer_layer);
if (ret != 0) {
PMD_DRV_LOG(ERR, "nfp flow item compile failed.");
@@ -1516,7 +1613,7 @@ struct nfp_mask_id_entry {
/* Go over inner items */
if (is_tun_flow) {
- ret = nfp_flow_compile_item_proc(items, nfp_flow,
+ ret = nfp_flow_compile_item_proc(representor, items, nfp_flow,
&mbuf_off_exact, &mbuf_off_mask, true);
if (ret != 0) {
PMD_DRV_LOG(ERR, "nfp flow outer item compile failed.");
@@ -1891,6 +1988,59 @@ struct nfp_mask_id_entry {
return nfp_flower_cmsg_tun_neigh_v4_rule(app_fw_flower, &payload);
}
+__rte_unused static int
+nfp_flower_add_tun_neigh_v4_decap(struct nfp_app_fw_flower *app_fw_flower,
+ struct rte_flow *nfp_flow)
+{
+ struct nfp_fl_tun *tmp;
+ struct nfp_fl_tun *tun;
+ struct nfp_flow_priv *priv;
+ struct nfp_flower_ipv4 *ipv4;
+ struct nfp_flower_mac_mpls *eth;
+ struct nfp_flower_in_port *port;
+ struct nfp_flower_meta_tci *meta_tci;
+ struct nfp_flower_cmsg_tun_neigh_v4 payload;
+
+ meta_tci = (struct nfp_flower_meta_tci *)nfp_flow->payload.unmasked_data;
+ port = (struct nfp_flower_in_port *)(meta_tci + 1);
+ eth = (struct nfp_flower_mac_mpls *)(port + 1);
+
+ if (meta_tci->nfp_flow_key_layer & NFP_FLOWER_LAYER_TP)
+ ipv4 = (struct nfp_flower_ipv4 *)((char *)eth +
+ sizeof(struct nfp_flower_mac_mpls) +
+ sizeof(struct nfp_flower_tp_ports));
+ else
+ ipv4 = (struct nfp_flower_ipv4 *)((char *)eth +
+ sizeof(struct nfp_flower_mac_mpls));
+
+ tun = &nfp_flow->tun;
+ tun->payload.v6_flag = 0;
+ tun->payload.dst.dst_ipv4 = ipv4->ipv4_src;
+ tun->payload.src.src_ipv4 = ipv4->ipv4_dst;
+ memcpy(tun->payload.dst_addr, eth->mac_src, RTE_ETHER_ADDR_LEN);
+ memcpy(tun->payload.src_addr, eth->mac_dst, RTE_ETHER_ADDR_LEN);
+
+ tun->ref_cnt = 1;
+ priv = app_fw_flower->flow_priv;
+ LIST_FOREACH(tmp, &priv->nn_list, next) {
+ if (memcmp(&tmp->payload, &tun->payload, sizeof(struct nfp_fl_tun_entry)) == 0) {
+ tmp->ref_cnt++;
+ return 0;
+ }
+ }
+
+ LIST_INSERT_HEAD(&priv->nn_list, tun, next);
+
+ memset(&payload, 0, sizeof(struct nfp_flower_cmsg_tun_neigh_v4));
+ payload.dst_ipv4 = ipv4->ipv4_src;
+ payload.src_ipv4 = ipv4->ipv4_dst;
+ memcpy(payload.common.dst_mac, eth->mac_src, RTE_ETHER_ADDR_LEN);
+ memcpy(payload.common.src_mac, eth->mac_dst, RTE_ETHER_ADDR_LEN);
+ payload.common.port_id = port->in_port;
+
+ return nfp_flower_cmsg_tun_neigh_v4_rule(app_fw_flower, &payload);
+}
+
static int
nfp_flower_del_tun_neigh_v4(struct nfp_app_fw_flower *app_fw_flower,
rte_be32_t ipv4)
@@ -2108,6 +2258,200 @@ struct nfp_mask_id_entry {
actions, vxlan_data, nfp_flow_meta, tun);
}
+static struct nfp_pre_tun_entry *
+nfp_pre_tun_table_search(struct nfp_flow_priv *priv,
+ char *hash_data,
+ uint32_t hash_len)
+{
+ int index;
+ uint32_t hash_key;
+ struct nfp_pre_tun_entry *mac_index;
+
+ hash_key = rte_jhash(hash_data, hash_len, priv->hash_seed);
+ index = rte_hash_lookup_data(priv->pre_tun_table, &hash_key, (void **)&mac_index);
+ if (index < 0) {
+ PMD_DRV_LOG(DEBUG, "Data NOT found in the hash table");
+ return NULL;
+ }
+
+ return mac_index;
+}
+
+static bool
+nfp_pre_tun_table_add(struct nfp_flow_priv *priv,
+ char *hash_data,
+ uint32_t hash_len)
+{
+ int ret;
+ uint32_t hash_key;
+
+ hash_key = rte_jhash(hash_data, hash_len, priv->hash_seed);
+ ret = rte_hash_add_key_data(priv->pre_tun_table, &hash_key, hash_data);
+ if (ret != 0) {
+ PMD_DRV_LOG(ERR, "Add to pre tunnel table failed");
+ return false;
+ }
+
+ return true;
+}
+
+static bool
+nfp_pre_tun_table_delete(struct nfp_flow_priv *priv,
+ char *hash_data,
+ uint32_t hash_len)
+{
+ int ret;
+ uint32_t hash_key;
+
+ hash_key = rte_jhash(hash_data, hash_len, priv->hash_seed);
+ ret = rte_hash_del_key(priv->pre_tun_table, &hash_key);
+ if (ret < 0) {
+ PMD_DRV_LOG(ERR, "Delete from pre tunnel table failed");
+ return false;
+ }
+
+ return true;
+}
+
+__rte_unused static int
+nfp_pre_tun_table_check_add(struct nfp_flower_representor *repr,
+ uint16_t *index)
+{
+ uint16_t i;
+ uint32_t entry_size;
+ uint16_t mac_index = 1;
+ struct nfp_flow_priv *priv;
+ struct nfp_pre_tun_entry *entry;
+ struct nfp_pre_tun_entry *find_entry;
+
+ priv = repr->app_fw_flower->flow_priv;
+ if (priv->pre_tun_cnt >= NFP_TUN_PRE_TUN_RULE_LIMIT) {
+ PMD_DRV_LOG(ERR, "Pre tunnel table has full");
+ return -EINVAL;
+ }
+
+ entry_size = sizeof(struct nfp_pre_tun_entry);
+ entry = rte_zmalloc("nfp_pre_tun", entry_size, 0);
+ if (entry == NULL) {
+ PMD_DRV_LOG(ERR, "Memory alloc failed for pre tunnel table");
+ return -ENOMEM;
+ }
+
+ entry->ref_cnt = 1U;
+ memcpy(entry->mac_addr, repr->mac_addr.addr_bytes, RTE_ETHER_ADDR_LEN);
+
+ /* 0 is considered a failed match */
+ for (i = 1; i < NFP_TUN_PRE_TUN_RULE_LIMIT; i++) {
+ if (priv->pre_tun_bitmap[i] == 0)
+ continue;
+ entry->mac_index = i;
+ find_entry = nfp_pre_tun_table_search(priv, (char *)entry, entry_size);
+ if (find_entry != NULL) {
+ find_entry->ref_cnt++;
+ *index = find_entry->mac_index;
+ rte_free(entry);
+ return 0;
+ }
+ }
+
+ for (i = 1; i < NFP_TUN_PRE_TUN_RULE_LIMIT; i++) {
+ if (priv->pre_tun_bitmap[i] == 0) {
+ priv->pre_tun_bitmap[i] = 1U;
+ mac_index = i;
+ break;
+ }
+ }
+
+ entry->mac_index = mac_index;
+ if (!nfp_pre_tun_table_add(priv, (char *)entry, entry_size)) {
+ rte_free(entry);
+ return -EINVAL;
+ }
+
+ *index = entry->mac_index;
+ priv->pre_tun_cnt++;
+ return 0;
+}
+
+static int
+nfp_pre_tun_table_check_del(struct nfp_flower_representor *repr,
+ struct rte_flow *nfp_flow)
+{
+ uint16_t i;
+ int ret = 0;
+ uint32_t entry_size;
+ uint16_t nfp_mac_idx;
+ struct nfp_flow_priv *priv;
+ struct nfp_pre_tun_entry *entry;
+ struct nfp_pre_tun_entry *find_entry;
+ struct nfp_fl_rule_metadata *nfp_flow_meta;
+
+ priv = repr->app_fw_flower->flow_priv;
+ if (priv->pre_tun_cnt == 1)
+ return 0;
+
+ entry_size = sizeof(struct nfp_pre_tun_entry);
+ entry = rte_zmalloc("nfp_pre_tun", entry_size, 0);
+ if (entry == NULL) {
+ PMD_DRV_LOG(ERR, "Memory alloc failed for pre tunnel table");
+ return -ENOMEM;
+ }
+
+ entry->ref_cnt = 1U;
+ memcpy(entry->mac_addr, repr->mac_addr.addr_bytes, RTE_ETHER_ADDR_LEN);
+
+ /* 0 is considered a failed match */
+ for (i = 1; i < NFP_TUN_PRE_TUN_RULE_LIMIT; i++) {
+ if (priv->pre_tun_bitmap[i] == 0)
+ continue;
+ entry->mac_index = i;
+ find_entry = nfp_pre_tun_table_search(priv, (char *)entry, entry_size);
+ if (find_entry != NULL) {
+ find_entry->ref_cnt--;
+ if (find_entry->ref_cnt != 0)
+ goto free_entry;
+ priv->pre_tun_bitmap[i] = 0;
+ break;
+ }
+ }
+
+ nfp_flow_meta = nfp_flow->payload.meta;
+ nfp_mac_idx = (find_entry->mac_index << 8) |
+ NFP_FLOWER_CMSG_PORT_TYPE_OTHER_PORT |
+ NFP_TUN_PRE_TUN_IDX_BIT;
+ ret = nfp_flower_cmsg_tun_mac_rule(repr->app_fw_flower, &repr->mac_addr,
+ nfp_mac_idx, true);
+ if (ret != 0) {
+ PMD_DRV_LOG(ERR, "Send tunnel mac rule failed");
+ ret = -EINVAL;
+ goto free_entry;
+ }
+
+ ret = nfp_flower_cmsg_pre_tunnel_rule(repr->app_fw_flower, nfp_flow_meta,
+ nfp_mac_idx, true);
+ if (ret != 0) {
+ PMD_DRV_LOG(ERR, "Send pre tunnel rule failed");
+ ret = -EINVAL;
+ goto free_entry;
+ }
+
+ find_entry->ref_cnt = 1U;
+ if (!nfp_pre_tun_table_delete(priv, (char *)find_entry, entry_size)) {
+ PMD_DRV_LOG(ERR, "Delete entry from pre tunnel table failed");
+ ret = -EINVAL;
+ goto free_entry;
+ }
+
+ rte_free(entry);
+ rte_free(find_entry);
+ priv->pre_tun_cnt--;
+
+free_entry:
+ rte_free(entry);
+
+ return ret;
+}
+
static int
nfp_flow_compile_action(struct nfp_flower_representor *representor,
const struct rte_flow_action actions[],
@@ -2149,6 +2493,9 @@ struct nfp_mask_id_entry {
case RTE_FLOW_ACTION_TYPE_RSS:
PMD_DRV_LOG(DEBUG, "Process RTE_FLOW_ACTION_TYPE_RSS");
break;
+ case RTE_FLOW_ACTION_TYPE_JUMP:
+ PMD_DRV_LOG(DEBUG, "Process RTE_FLOW_ACTION_TYPE_JUMP");
+ break;
case RTE_FLOW_ACTION_TYPE_PORT_ID:
PMD_DRV_LOG(DEBUG, "Process RTE_FLOW_ACTION_TYPE_PORT_ID");
ret = nfp_flow_action_output(position, action, nfp_flow_meta);
@@ -2569,6 +2916,15 @@ struct nfp_mask_id_entry {
/* Delete the entry from nn table */
ret = nfp_flower_del_tun_neigh(app_fw_flower, nfp_flow);
break;
+ case NFP_FLOW_DECAP:
+ /* Delete the entry from nn table */
+ ret = nfp_flower_del_tun_neigh(app_fw_flower, nfp_flow);
+ if (ret != 0)
+ goto exit;
+
+ /* Delete the entry in pre tunnel table */
+ ret = nfp_pre_tun_table_check_del(representor, nfp_flow);
+ break;
default:
PMD_DRV_LOG(ERR, "Invalid nfp flow type %d.", nfp_flow->type);
ret = -EINVAL;
@@ -2578,6 +2934,10 @@ struct nfp_mask_id_entry {
if (ret != 0)
goto exit;
+ /* Delete the ip off */
+ if (nfp_flow_is_tunnel(nfp_flow))
+ nfp_tun_check_ip_off_del(representor, nfp_flow);
+
/* Delete the flow from hardware */
if (nfp_flow->install_flag) {
ret = nfp_flower_cmsg_flow_delete(app_fw_flower, nfp_flow);
@@ -2707,6 +3067,49 @@ struct nfp_mask_id_entry {
return 0;
}
+static int
+nfp_flow_tunnel_decap_set(__rte_unused struct rte_eth_dev *dev,
+ struct rte_flow_tunnel *tunnel,
+ struct rte_flow_action **pmd_actions,
+ uint32_t *num_of_actions,
+ __rte_unused struct rte_flow_error *err)
+{
+ struct rte_flow_action *nfp_action;
+
+ nfp_action = rte_zmalloc("nfp_tun_action", sizeof(struct rte_flow_action), 0);
+ if (nfp_action == NULL) {
+ PMD_DRV_LOG(ERR, "Alloc memory for nfp tunnel action failed.");
+ return -ENOMEM;
+ }
+
+ switch (tunnel->type) {
+ default:
+ *pmd_actions = NULL;
+ *num_of_actions = 0;
+ rte_free(nfp_action);
+ break;
+ }
+
+ return 0;
+}
+
+static int
+nfp_flow_tunnel_action_decap_release(__rte_unused struct rte_eth_dev *dev,
+ struct rte_flow_action *pmd_actions,
+ uint32_t num_of_actions,
+ __rte_unused struct rte_flow_error *err)
+{
+ uint32_t i;
+ struct rte_flow_action *nfp_action;
+
+ for (i = 0; i < num_of_actions; i++) {
+ nfp_action = &pmd_actions[i];
+ rte_free(nfp_action);
+ }
+
+ return 0;
+}
+
static const struct rte_flow_ops nfp_flow_ops = {
.validate = nfp_flow_validate,
.create = nfp_flow_create,
@@ -2715,6 +3118,8 @@ struct nfp_mask_id_entry {
.query = nfp_flow_query,
.tunnel_match = nfp_flow_tunnel_match,
.tunnel_item_release = nfp_flow_tunnel_item_release,
+ .tunnel_decap_set = nfp_flow_tunnel_decap_set,
+ .tunnel_action_decap_release = nfp_flow_tunnel_action_decap_release,
};
int
@@ -2759,6 +3164,15 @@ struct nfp_mask_id_entry {
.extra_flag = RTE_HASH_EXTRA_FLAGS_RW_CONCURRENCY,
};
+ struct rte_hash_parameters pre_tun_hash_params = {
+ .name = "pre_tunnel_table",
+ .entries = 32,
+ .hash_func = rte_jhash,
+ .socket_id = rte_socket_id(),
+ .key_len = sizeof(uint32_t),
+ .extra_flag = RTE_HASH_EXTRA_FLAGS_RW_CONCURRENCY,
+ };
+
ctx_count = nfp_rtsym_read_le(pf_dev->sym_tbl,
"CONFIG_FC_HOST_CTX_COUNT", &ret);
if (ret < 0) {
@@ -2839,11 +3253,27 @@ struct nfp_mask_id_entry {
goto free_mask_table;
}
+ /* pre tunnel table */
+ priv->pre_tun_cnt = 1;
+ pre_tun_hash_params.hash_func_init_val = priv->hash_seed;
+ priv->pre_tun_table = rte_hash_create(&pre_tun_hash_params);
+ if (priv->pre_tun_table == NULL) {
+ PMD_INIT_LOG(ERR, "Pre tunnel table creation failed");
+ ret = -ENOMEM;
+ goto free_flow_table;
+ }
+
+ /* ipv4 off list */
+ rte_spinlock_init(&priv->ipv4_off_lock);
+ LIST_INIT(&priv->ipv4_off_list);
+
/* neighbor next list */
LIST_INIT(&priv->nn_list);
return 0;
+free_flow_table:
+ rte_hash_free(priv->flow_table);
free_mask_table:
rte_free(priv->mask_table);
free_stats:
@@ -2867,6 +3297,7 @@ struct nfp_mask_id_entry {
app_fw_flower = NFP_PRIV_TO_APP_FW_FLOWER(pf_dev->app_fw_priv);
priv = app_fw_flower->flow_priv;
+ rte_hash_free(priv->pre_tun_table);
rte_hash_free(priv->flow_table);
rte_hash_free(priv->mask_table);
rte_free(priv->stats);
@@ -6,6 +6,7 @@
#ifndef _NFP_FLOW_H_
#define _NFP_FLOW_H_
+#include <sys/queue.h>
#include <ethdev_driver.h>
#define NFP_FLOWER_LAYER_EXT_META (1 << 0)
@@ -92,6 +93,7 @@ enum nfp_flower_tun_type {
enum nfp_flow_type {
NFP_FLOW_COMMON,
NFP_FLOW_ENCAP,
+ NFP_FLOW_DECAP,
};
struct nfp_fl_key_ls {
@@ -168,6 +170,14 @@ struct nfp_fl_stats {
uint64_t bytes;
};
+struct nfp_ipv4_addr_entry {
+ LIST_ENTRY(nfp_ipv4_addr_entry) next;
+ rte_be32_t ipv4_addr;
+ int ref_count;
+};
+
+#define NFP_TUN_PRE_TUN_RULE_LIMIT 32
+
struct nfp_flow_priv {
uint32_t hash_seed; /**< Hash seed for hash tables in this structure. */
uint64_t flower_version; /**< Flow version, always increase. */
@@ -183,6 +193,13 @@ struct nfp_flow_priv {
struct nfp_fl_stats_id stats_ids; /**< The stats id ring. */
struct nfp_fl_stats *stats; /**< Store stats of flow. */
rte_spinlock_t stats_lock; /** < Lock the update of 'stats' field. */
+ /* pre tunnel rule */
+ uint16_t pre_tun_cnt; /**< The size of pre tunnel rule */
+ uint8_t pre_tun_bitmap[NFP_TUN_PRE_TUN_RULE_LIMIT]; /**< Bitmap of pre tunnel rule */
+ struct rte_hash *pre_tun_table; /**< Hash table to store pre tunnel rule */
+ /* IPv4 off */
+ LIST_HEAD(, nfp_ipv4_addr_entry) ipv4_off_list; /**< Store ipv4 off */
+ rte_spinlock_t ipv4_off_lock; /**< Lock the ipv4 off list */
/* neighbor next */
LIST_HEAD(, nfp_fl_tun)nn_list; /**< Store nn entry */
};