d/numam-dpdk
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
6ac5a55b33
numam-dpdk/drivers/net/dpaa2/dpaa2_flow.c
Josh Soref 7be78d0279 fix spelling in comments and strings 
The tool comes from https://github.com/jsoref

Signed-off-by: Josh Soref <jsoref@gmail.com>
Signed-off-by: Thomas Monjalon <thomas@monjalon.net>
2022-01-11 12:16:53 +01:00

4207 lines
105 KiB
C
Raw Blame History

/* SPDX-License-Identifier: BSD-3-Clause
* Copyright 2018-2021 NXP
*/
#include <sys/queue.h>
#include <stdio.h>
#include <errno.h>
#include <stdint.h>
#include <string.h>
#include <unistd.h>
#include <stdarg.h>
#include <rte_ethdev.h>
#include <rte_log.h>
#include <rte_malloc.h>
#include <rte_flow_driver.h>
#include <rte_tailq.h>
#include <fsl_dpni.h>
#include <fsl_dpkg.h>
#include <dpaa2_ethdev.h>
#include <dpaa2_pmd_logs.h>
/* Workaround to discriminate the UDP/TCP/SCTP
* with next protocol of l3.
* MC/WRIOP are not able to identify
* the l4 protocol with l4 ports.
*/
int mc_l4_port_identification;
static char *dpaa2_flow_control_log;
static uint16_t dpaa2_flow_miss_flow_id =
DPNI_FS_MISS_DROP;
#define FIXED_ENTRY_SIZE DPNI_MAX_KEY_SIZE
enum flow_rule_ipaddr_type {
FLOW_NONE_IPADDR,
FLOW_IPV4_ADDR,
FLOW_IPV6_ADDR
};
struct flow_rule_ipaddr {
enum flow_rule_ipaddr_type ipaddr_type;
int qos_ipsrc_offset;
int qos_ipdst_offset;
int fs_ipsrc_offset;
int fs_ipdst_offset;
};
struct rte_flow {
LIST_ENTRY(rte_flow) next; /**< Pointer to the next flow structure. */
struct dpni_rule_cfg qos_rule;
struct dpni_rule_cfg fs_rule;
uint8_t qos_real_key_size;
uint8_t fs_real_key_size;
uint8_t tc_id; /** Traffic Class ID. */
uint8_t tc_index; /** index within this Traffic Class. */
enum rte_flow_action_type action;
/* Special for IP address to specify the offset
* in key/mask.
*/
struct flow_rule_ipaddr ipaddr_rule;
struct dpni_fs_action_cfg action_cfg;
};
static const
enum rte_flow_item_type dpaa2_supported_pattern_type[] = {
RTE_FLOW_ITEM_TYPE_END,
RTE_FLOW_ITEM_TYPE_ETH,
RTE_FLOW_ITEM_TYPE_VLAN,
RTE_FLOW_ITEM_TYPE_IPV4,
RTE_FLOW_ITEM_TYPE_IPV6,
RTE_FLOW_ITEM_TYPE_ICMP,
RTE_FLOW_ITEM_TYPE_UDP,
RTE_FLOW_ITEM_TYPE_TCP,
RTE_FLOW_ITEM_TYPE_SCTP,
RTE_FLOW_ITEM_TYPE_GRE,
};
static const
enum rte_flow_action_type dpaa2_supported_action_type[] = {
RTE_FLOW_ACTION_TYPE_END,
RTE_FLOW_ACTION_TYPE_QUEUE,
RTE_FLOW_ACTION_TYPE_PHY_PORT,
RTE_FLOW_ACTION_TYPE_PORT_ID,
RTE_FLOW_ACTION_TYPE_RSS
};
static const
enum rte_flow_action_type dpaa2_supported_fs_action_type[] = {
RTE_FLOW_ACTION_TYPE_QUEUE,
RTE_FLOW_ACTION_TYPE_PHY_PORT,
RTE_FLOW_ACTION_TYPE_PORT_ID
};
/* Max of enum rte_flow_item_type + 1, for both IPv4 and IPv6*/
#define DPAA2_FLOW_ITEM_TYPE_GENERIC_IP (RTE_FLOW_ITEM_TYPE_META + 1)
#ifndef __cplusplus
static const struct rte_flow_item_eth dpaa2_flow_item_eth_mask = {
.dst.addr_bytes = "\xff\xff\xff\xff\xff\xff",
.src.addr_bytes = "\xff\xff\xff\xff\xff\xff",
.type = RTE_BE16(0xffff),
};
static const struct rte_flow_item_vlan dpaa2_flow_item_vlan_mask = {
.tci = RTE_BE16(0xffff),
};
static const struct rte_flow_item_ipv4 dpaa2_flow_item_ipv4_mask = {
.hdr.src_addr = RTE_BE32(0xffffffff),
.hdr.dst_addr = RTE_BE32(0xffffffff),
.hdr.next_proto_id = 0xff,
};
static const struct rte_flow_item_ipv6 dpaa2_flow_item_ipv6_mask = {
.hdr = {
.src_addr =
"\xff\xff\xff\xff\xff\xff\xff\xff"
"\xff\xff\xff\xff\xff\xff\xff\xff",
.dst_addr =
"\xff\xff\xff\xff\xff\xff\xff\xff"
"\xff\xff\xff\xff\xff\xff\xff\xff",
.proto = 0xff
},
};
static const struct rte_flow_item_icmp dpaa2_flow_item_icmp_mask = {
.hdr.icmp_type = 0xff,
.hdr.icmp_code = 0xff,
};
static const struct rte_flow_item_udp dpaa2_flow_item_udp_mask = {
.hdr = {
.src_port = RTE_BE16(0xffff),
.dst_port = RTE_BE16(0xffff),
},
};
static const struct rte_flow_item_tcp dpaa2_flow_item_tcp_mask = {
.hdr = {
.src_port = RTE_BE16(0xffff),
.dst_port = RTE_BE16(0xffff),
},
};
static const struct rte_flow_item_sctp dpaa2_flow_item_sctp_mask = {
.hdr = {
.src_port = RTE_BE16(0xffff),
.dst_port = RTE_BE16(0xffff),
},
};
static const struct rte_flow_item_gre dpaa2_flow_item_gre_mask = {
.protocol = RTE_BE16(0xffff),
};
#endif
static inline void dpaa2_prot_field_string(
enum net_prot prot, uint32_t field,
char *string)
{
if (!dpaa2_flow_control_log)
return;
if (prot == NET_PROT_ETH) {
strcpy(string, "eth");
if (field == NH_FLD_ETH_DA)
strcat(string, ".dst");
else if (field == NH_FLD_ETH_SA)
strcat(string, ".src");
else if (field == NH_FLD_ETH_TYPE)
strcat(string, ".type");
else
strcat(string, ".unknown field");
} else if (prot == NET_PROT_VLAN) {
strcpy(string, "vlan");
if (field == NH_FLD_VLAN_TCI)
strcat(string, ".tci");
else
strcat(string, ".unknown field");
} else if (prot == NET_PROT_IP) {
strcpy(string, "ip");
if (field == NH_FLD_IP_SRC)
strcat(string, ".src");
else if (field == NH_FLD_IP_DST)
strcat(string, ".dst");
else if (field == NH_FLD_IP_PROTO)
strcat(string, ".proto");
else
strcat(string, ".unknown field");
} else if (prot == NET_PROT_TCP) {
strcpy(string, "tcp");
if (field == NH_FLD_TCP_PORT_SRC)
strcat(string, ".src");
else if (field == NH_FLD_TCP_PORT_DST)
strcat(string, ".dst");
else
strcat(string, ".unknown field");
} else if (prot == NET_PROT_UDP) {
strcpy(string, "udp");
if (field == NH_FLD_UDP_PORT_SRC)
strcat(string, ".src");
else if (field == NH_FLD_UDP_PORT_DST)
strcat(string, ".dst");
else
strcat(string, ".unknown field");
} else if (prot == NET_PROT_ICMP) {
strcpy(string, "icmp");
if (field == NH_FLD_ICMP_TYPE)
strcat(string, ".type");
else if (field == NH_FLD_ICMP_CODE)
strcat(string, ".code");
else
strcat(string, ".unknown field");
} else if (prot == NET_PROT_SCTP) {
strcpy(string, "sctp");
if (field == NH_FLD_SCTP_PORT_SRC)
strcat(string, ".src");
else if (field == NH_FLD_SCTP_PORT_DST)
strcat(string, ".dst");
else
strcat(string, ".unknown field");
} else if (prot == NET_PROT_GRE) {
strcpy(string, "gre");
if (field == NH_FLD_GRE_TYPE)
strcat(string, ".type");
else
strcat(string, ".unknown field");
} else {
strcpy(string, "unknown protocol");
}
}
static inline void dpaa2_flow_qos_table_extracts_log(
const struct dpaa2_dev_priv *priv)
{
int idx;
char string[32];
if (!dpaa2_flow_control_log)
return;
printf("Setup QoS table: number of extracts: %d\r\n",
priv->extract.qos_key_extract.dpkg.num_extracts);
for (idx = 0; idx < priv->extract.qos_key_extract.dpkg.num_extracts;
idx++) {
dpaa2_prot_field_string(priv->extract.qos_key_extract.dpkg
.extracts[idx].extract.from_hdr.prot,
priv->extract.qos_key_extract.dpkg.extracts[idx]
.extract.from_hdr.field,
string);
printf("%s", string);
if ((idx + 1) < priv->extract.qos_key_extract.dpkg.num_extracts)
printf(" / ");
}
printf("\r\n");
}
static inline void dpaa2_flow_fs_table_extracts_log(
const struct dpaa2_dev_priv *priv, int tc_id)
{
int idx;
char string[32];
if (!dpaa2_flow_control_log)
return;
printf("Setup FS table: number of extracts of TC[%d]: %d\r\n",
tc_id, priv->extract.tc_key_extract[tc_id]
.dpkg.num_extracts);
for (idx = 0; idx < priv->extract.tc_key_extract[tc_id]
.dpkg.num_extracts; idx++) {
dpaa2_prot_field_string(priv->extract.tc_key_extract[tc_id]
.dpkg.extracts[idx].extract.from_hdr.prot,
priv->extract.tc_key_extract[tc_id].dpkg.extracts[idx]
.extract.from_hdr.field,
string);
printf("%s", string);
if ((idx + 1) < priv->extract.tc_key_extract[tc_id]
.dpkg.num_extracts)
printf(" / ");
}
printf("\r\n");
}
static inline void dpaa2_flow_qos_entry_log(
const char *log_info, const struct rte_flow *flow, int qos_index)
{
int idx;
uint8_t *key, *mask;
if (!dpaa2_flow_control_log)
return;
printf("\r\n%s QoS entry[%d] for TC[%d], extracts size is %d\r\n",
log_info, qos_index, flow->tc_id, flow->qos_real_key_size);
key = (uint8_t *)(size_t)flow->qos_rule.key_iova;
mask = (uint8_t *)(size_t)flow->qos_rule.mask_iova;
printf("key:\r\n");
for (idx = 0; idx < flow->qos_real_key_size; idx++)
printf("%02x ", key[idx]);
printf("\r\nmask:\r\n");
for (idx = 0; idx < flow->qos_real_key_size; idx++)
printf("%02x ", mask[idx]);
printf("\r\n%s QoS ipsrc: %d, ipdst: %d\r\n", log_info,
flow->ipaddr_rule.qos_ipsrc_offset,
flow->ipaddr_rule.qos_ipdst_offset);
}
static inline void dpaa2_flow_fs_entry_log(
const char *log_info, const struct rte_flow *flow)
{
int idx;
uint8_t *key, *mask;
if (!dpaa2_flow_control_log)
return;
printf("\r\n%s FS/TC entry[%d] of TC[%d], extracts size is %d\r\n",
log_info, flow->tc_index, flow->tc_id, flow->fs_real_key_size);
key = (uint8_t *)(size_t)flow->fs_rule.key_iova;
mask = (uint8_t *)(size_t)flow->fs_rule.mask_iova;
printf("key:\r\n");
for (idx = 0; idx < flow->fs_real_key_size; idx++)
printf("%02x ", key[idx]);
printf("\r\nmask:\r\n");
for (idx = 0; idx < flow->fs_real_key_size; idx++)
printf("%02x ", mask[idx]);
printf("\r\n%s FS ipsrc: %d, ipdst: %d\r\n", log_info,
flow->ipaddr_rule.fs_ipsrc_offset,
flow->ipaddr_rule.fs_ipdst_offset);
}
static inline void dpaa2_flow_extract_key_set(
struct dpaa2_key_info *key_info, int index, uint8_t size)
{
key_info->key_size[index] = size;
if (index > 0) {
key_info->key_offset[index] =
key_info->key_offset[index - 1] +
key_info->key_size[index - 1];
} else {
key_info->key_offset[index] = 0;
}
key_info->key_total_size += size;
}
static int dpaa2_flow_extract_add(
struct dpaa2_key_extract *key_extract,
enum net_prot prot,
uint32_t field, uint8_t field_size)
{
int index, ip_src = -1, ip_dst = -1;
struct dpkg_profile_cfg *dpkg = &key_extract->dpkg;
struct dpaa2_key_info *key_info = &key_extract->key_info;
if (dpkg->num_extracts >=
DPKG_MAX_NUM_OF_EXTRACTS) {
DPAA2_PMD_WARN("Number of extracts overflows");
return -1;
}
/* Before reorder, the IP SRC and IP DST are already last
* extract(s).
*/
for (index = 0; index < dpkg->num_extracts; index++) {
if (dpkg->extracts[index].extract.from_hdr.prot ==
NET_PROT_IP) {
if (dpkg->extracts[index].extract.from_hdr.field ==
NH_FLD_IP_SRC) {
ip_src = index;
}
if (dpkg->extracts[index].extract.from_hdr.field ==
NH_FLD_IP_DST) {
ip_dst = index;
}
}
}
if (ip_src >= 0)
RTE_ASSERT((ip_src + 2) >= dpkg->num_extracts);
if (ip_dst >= 0)
RTE_ASSERT((ip_dst + 2) >= dpkg->num_extracts);
if (prot == NET_PROT_IP &&
(field == NH_FLD_IP_SRC ||
field == NH_FLD_IP_DST)) {
index = dpkg->num_extracts;
} else {
if (ip_src >= 0 && ip_dst >= 0)
index = dpkg->num_extracts - 2;
else if (ip_src >= 0 || ip_dst >= 0)
index = dpkg->num_extracts - 1;
else
index = dpkg->num_extracts;
}
dpkg->extracts[index].type = DPKG_EXTRACT_FROM_HDR;
dpkg->extracts[index].extract.from_hdr.type = DPKG_FULL_FIELD;
dpkg->extracts[index].extract.from_hdr.prot = prot;
dpkg->extracts[index].extract.from_hdr.field = field;
if (prot == NET_PROT_IP &&
(field == NH_FLD_IP_SRC ||
field == NH_FLD_IP_DST)) {
dpaa2_flow_extract_key_set(key_info, index, 0);
} else {
dpaa2_flow_extract_key_set(key_info, index, field_size);
}
if (prot == NET_PROT_IP) {
if (field == NH_FLD_IP_SRC) {
if (key_info->ipv4_dst_offset >= 0) {
key_info->ipv4_src_offset =
key_info->ipv4_dst_offset +
NH_FLD_IPV4_ADDR_SIZE;
} else {
key_info->ipv4_src_offset =
key_info->key_offset[index - 1] +
key_info->key_size[index - 1];
}
if (key_info->ipv6_dst_offset >= 0) {
key_info->ipv6_src_offset =
key_info->ipv6_dst_offset +
NH_FLD_IPV6_ADDR_SIZE;
} else {
key_info->ipv6_src_offset =
key_info->key_offset[index - 1] +
key_info->key_size[index - 1];
}
} else if (field == NH_FLD_IP_DST) {
if (key_info->ipv4_src_offset >= 0) {
key_info->ipv4_dst_offset =
key_info->ipv4_src_offset +
NH_FLD_IPV4_ADDR_SIZE;
} else {
key_info->ipv4_dst_offset =
key_info->key_offset[index - 1] +
key_info->key_size[index - 1];
}
if (key_info->ipv6_src_offset >= 0) {
key_info->ipv6_dst_offset =
key_info->ipv6_src_offset +
NH_FLD_IPV6_ADDR_SIZE;
} else {
key_info->ipv6_dst_offset =
key_info->key_offset[index - 1] +
key_info->key_size[index - 1];
}
}
}
if (index == dpkg->num_extracts) {
dpkg->num_extracts++;
return 0;
}
if (ip_src >= 0) {
ip_src++;
dpkg->extracts[ip_src].type =
DPKG_EXTRACT_FROM_HDR;
dpkg->extracts[ip_src].extract.from_hdr.type =
DPKG_FULL_FIELD;
dpkg->extracts[ip_src].extract.from_hdr.prot =
NET_PROT_IP;
dpkg->extracts[ip_src].extract.from_hdr.field =
NH_FLD_IP_SRC;
dpaa2_flow_extract_key_set(key_info, ip_src, 0);
key_info->ipv4_src_offset += field_size;
key_info->ipv6_src_offset += field_size;
}
if (ip_dst >= 0) {
ip_dst++;
dpkg->extracts[ip_dst].type =
DPKG_EXTRACT_FROM_HDR;
dpkg->extracts[ip_dst].extract.from_hdr.type =
DPKG_FULL_FIELD;
dpkg->extracts[ip_dst].extract.from_hdr.prot =
NET_PROT_IP;
dpkg->extracts[ip_dst].extract.from_hdr.field =
NH_FLD_IP_DST;
dpaa2_flow_extract_key_set(key_info, ip_dst, 0);
key_info->ipv4_dst_offset += field_size;
key_info->ipv6_dst_offset += field_size;
}
dpkg->num_extracts++;
return 0;
}
static int dpaa2_flow_extract_add_raw(struct dpaa2_key_extract *key_extract,
int size)
{
struct dpkg_profile_cfg *dpkg = &key_extract->dpkg;
struct dpaa2_key_info *key_info = &key_extract->key_info;
int last_extract_size, index;
if (dpkg->num_extracts != 0 && dpkg->extracts[0].type !=
DPKG_EXTRACT_FROM_DATA) {
DPAA2_PMD_WARN("RAW extract cannot be combined with others");
return -1;
}
last_extract_size = (size % DPAA2_FLOW_MAX_KEY_SIZE);
dpkg->num_extracts = (size / DPAA2_FLOW_MAX_KEY_SIZE);
if (last_extract_size)
dpkg->num_extracts++;
else
last_extract_size = DPAA2_FLOW_MAX_KEY_SIZE;
for (index = 0; index < dpkg->num_extracts; index++) {
dpkg->extracts[index].type = DPKG_EXTRACT_FROM_DATA;
if (index == dpkg->num_extracts - 1)
dpkg->extracts[index].extract.from_data.size =
last_extract_size;
else
dpkg->extracts[index].extract.from_data.size =
DPAA2_FLOW_MAX_KEY_SIZE;
dpkg->extracts[index].extract.from_data.offset =
DPAA2_FLOW_MAX_KEY_SIZE * index;
}
key_info->key_total_size = size;
return 0;
}
/* Protocol discrimination.
* Discriminate IPv4/IPv6/vLan by Eth type.
* Discriminate UDP/TCP/ICMP by next proto of IP.
*/
static inline int
dpaa2_flow_proto_discrimination_extract(
struct dpaa2_key_extract *key_extract,
enum rte_flow_item_type type)
{
if (type == RTE_FLOW_ITEM_TYPE_ETH) {
return dpaa2_flow_extract_add(
key_extract, NET_PROT_ETH,
NH_FLD_ETH_TYPE,
sizeof(rte_be16_t));
} else if (type == (enum rte_flow_item_type)
DPAA2_FLOW_ITEM_TYPE_GENERIC_IP) {
return dpaa2_flow_extract_add(
key_extract, NET_PROT_IP,
NH_FLD_IP_PROTO,
NH_FLD_IP_PROTO_SIZE);
}
return -1;
}
static inline int dpaa2_flow_extract_search(
struct dpkg_profile_cfg *dpkg,
enum net_prot prot, uint32_t field)
{
int i;
for (i = 0; i < dpkg->num_extracts; i++) {
if (dpkg->extracts[i].extract.from_hdr.prot == prot &&
dpkg->extracts[i].extract.from_hdr.field == field) {
return i;
}
}
return -1;
}
static inline int dpaa2_flow_extract_key_offset(
struct dpaa2_key_extract *key_extract,
enum net_prot prot, uint32_t field)
{
int i;
struct dpkg_profile_cfg *dpkg = &key_extract->dpkg;
struct dpaa2_key_info *key_info = &key_extract->key_info;
if (prot == NET_PROT_IPV4 ||
prot == NET_PROT_IPV6)
i = dpaa2_flow_extract_search(dpkg, NET_PROT_IP, field);
else
i = dpaa2_flow_extract_search(dpkg, prot, field);
if (i >= 0) {
if (prot == NET_PROT_IPV4 && field == NH_FLD_IP_SRC)
return key_info->ipv4_src_offset;
else if (prot == NET_PROT_IPV4 && field == NH_FLD_IP_DST)
return key_info->ipv4_dst_offset;
else if (prot == NET_PROT_IPV6 && field == NH_FLD_IP_SRC)
return key_info->ipv6_src_offset;
else if (prot == NET_PROT_IPV6 && field == NH_FLD_IP_DST)
return key_info->ipv6_dst_offset;
else
return key_info->key_offset[i];
} else {
return -1;
}
}
struct proto_discrimination {
enum rte_flow_item_type type;
union {
rte_be16_t eth_type;
uint8_t ip_proto;
};
};
static int
dpaa2_flow_proto_discrimination_rule(
struct dpaa2_dev_priv *priv, struct rte_flow *flow,
struct proto_discrimination proto, int group)
{
enum net_prot prot;
uint32_t field;
int offset;
size_t key_iova;
size_t mask_iova;
rte_be16_t eth_type;
uint8_t ip_proto;
if (proto.type == RTE_FLOW_ITEM_TYPE_ETH) {
prot = NET_PROT_ETH;
field = NH_FLD_ETH_TYPE;
} else if (proto.type == DPAA2_FLOW_ITEM_TYPE_GENERIC_IP) {
prot = NET_PROT_IP;
field = NH_FLD_IP_PROTO;
} else {
DPAA2_PMD_ERR(
"Only Eth and IP support to discriminate next proto.");
return -1;
}
offset = dpaa2_flow_extract_key_offset(&priv->extract.qos_key_extract,
prot, field);
if (offset < 0) {
DPAA2_PMD_ERR("QoS prot %d field %d extract failed",
prot, field);
return -1;
}
key_iova = flow->qos_rule.key_iova + offset;
mask_iova = flow->qos_rule.mask_iova + offset;
if (proto.type == RTE_FLOW_ITEM_TYPE_ETH) {
eth_type = proto.eth_type;
memcpy((void *)key_iova, (const void *)(&eth_type),
sizeof(rte_be16_t));
eth_type = 0xffff;
memcpy((void *)mask_iova, (const void *)(&eth_type),
sizeof(rte_be16_t));
} else {
ip_proto = proto.ip_proto;
memcpy((void *)key_iova, (const void *)(&ip_proto),
sizeof(uint8_t));
ip_proto = 0xff;
memcpy((void *)mask_iova, (const void *)(&ip_proto),
sizeof(uint8_t));
}
offset = dpaa2_flow_extract_key_offset(
&priv->extract.tc_key_extract[group],
prot, field);
if (offset < 0) {
DPAA2_PMD_ERR("FS prot %d field %d extract failed",
prot, field);
return -1;
}
key_iova = flow->fs_rule.key_iova + offset;
mask_iova = flow->fs_rule.mask_iova + offset;
if (proto.type == RTE_FLOW_ITEM_TYPE_ETH) {
eth_type = proto.eth_type;
memcpy((void *)key_iova, (const void *)(&eth_type),
sizeof(rte_be16_t));
eth_type = 0xffff;
memcpy((void *)mask_iova, (const void *)(&eth_type),
sizeof(rte_be16_t));
} else {
ip_proto = proto.ip_proto;
memcpy((void *)key_iova, (const void *)(&ip_proto),
sizeof(uint8_t));
ip_proto = 0xff;
memcpy((void *)mask_iova, (const void *)(&ip_proto),
sizeof(uint8_t));
}
return 0;
}
static inline int
dpaa2_flow_rule_data_set(
struct dpaa2_key_extract *key_extract,
struct dpni_rule_cfg *rule,
enum net_prot prot, uint32_t field,
const void *key, const void *mask, int size)
{
int offset = dpaa2_flow_extract_key_offset(key_extract,
prot, field);
if (offset < 0) {
DPAA2_PMD_ERR("prot %d, field %d extract failed",
prot, field);
return -1;
}
memcpy((void *)(size_t)(rule->key_iova + offset), key, size);
memcpy((void *)(size_t)(rule->mask_iova + offset), mask, size);
return 0;
}
static inline int
dpaa2_flow_rule_data_set_raw(struct dpni_rule_cfg *rule,
const void *key, const void *mask, int size)
{
int offset = 0;
memcpy((void *)(size_t)(rule->key_iova + offset), key, size);
memcpy((void *)(size_t)(rule->mask_iova + offset), mask, size);
return 0;
}
static inline int
_dpaa2_flow_rule_move_ipaddr_tail(
struct dpaa2_key_extract *key_extract,
struct dpni_rule_cfg *rule, int src_offset,
uint32_t field, bool ipv4)
{
size_t key_src;
size_t mask_src;
size_t key_dst;
size_t mask_dst;
int dst_offset, len;
enum net_prot prot;
char tmp[NH_FLD_IPV6_ADDR_SIZE];
if (field != NH_FLD_IP_SRC &&
field != NH_FLD_IP_DST) {
DPAA2_PMD_ERR("Field of IP addr reorder must be IP SRC/DST");
return -1;
}
if (ipv4)
prot = NET_PROT_IPV4;
else
prot = NET_PROT_IPV6;
dst_offset = dpaa2_flow_extract_key_offset(key_extract,
prot, field);
if (dst_offset < 0) {
DPAA2_PMD_ERR("Field %d reorder extract failed", field);
return -1;
}
key_src = rule->key_iova + src_offset;
mask_src = rule->mask_iova + src_offset;
key_dst = rule->key_iova + dst_offset;
mask_dst = rule->mask_iova + dst_offset;
if (ipv4)
len = sizeof(rte_be32_t);
else
len = NH_FLD_IPV6_ADDR_SIZE;
memcpy(tmp, (char *)key_src, len);
memset((char *)key_src, 0, len);
memcpy((char *)key_dst, tmp, len);
memcpy(tmp, (char *)mask_src, len);
memset((char *)mask_src, 0, len);
memcpy((char *)mask_dst, tmp, len);
return 0;
}
static inline int
dpaa2_flow_rule_move_ipaddr_tail(
struct rte_flow *flow, struct dpaa2_dev_priv *priv,
int fs_group)
{
int ret;
enum net_prot prot;
if (flow->ipaddr_rule.ipaddr_type == FLOW_NONE_IPADDR)
return 0;
if (flow->ipaddr_rule.ipaddr_type == FLOW_IPV4_ADDR)
prot = NET_PROT_IPV4;
else
prot = NET_PROT_IPV6;
if (flow->ipaddr_rule.qos_ipsrc_offset >= 0) {
ret = _dpaa2_flow_rule_move_ipaddr_tail(
&priv->extract.qos_key_extract,
&flow->qos_rule,
flow->ipaddr_rule.qos_ipsrc_offset,
NH_FLD_IP_SRC, prot == NET_PROT_IPV4);
if (ret) {
DPAA2_PMD_ERR("QoS src address reorder failed");
return -1;
}
flow->ipaddr_rule.qos_ipsrc_offset =
dpaa2_flow_extract_key_offset(
&priv->extract.qos_key_extract,
prot, NH_FLD_IP_SRC);
}
if (flow->ipaddr_rule.qos_ipdst_offset >= 0) {
ret = _dpaa2_flow_rule_move_ipaddr_tail(
&priv->extract.qos_key_extract,
&flow->qos_rule,
flow->ipaddr_rule.qos_ipdst_offset,
NH_FLD_IP_DST, prot == NET_PROT_IPV4);
if (ret) {
DPAA2_PMD_ERR("QoS dst address reorder failed");
return -1;
}
flow->ipaddr_rule.qos_ipdst_offset =
dpaa2_flow_extract_key_offset(
&priv->extract.qos_key_extract,
prot, NH_FLD_IP_DST);
}
if (flow->ipaddr_rule.fs_ipsrc_offset >= 0) {
ret = _dpaa2_flow_rule_move_ipaddr_tail(
&priv->extract.tc_key_extract[fs_group],
&flow->fs_rule,
flow->ipaddr_rule.fs_ipsrc_offset,
NH_FLD_IP_SRC, prot == NET_PROT_IPV4);
if (ret) {
DPAA2_PMD_ERR("FS src address reorder failed");
return -1;
}
flow->ipaddr_rule.fs_ipsrc_offset =
dpaa2_flow_extract_key_offset(
&priv->extract.tc_key_extract[fs_group],
prot, NH_FLD_IP_SRC);
}
if (flow->ipaddr_rule.fs_ipdst_offset >= 0) {
ret = _dpaa2_flow_rule_move_ipaddr_tail(
&priv->extract.tc_key_extract[fs_group],
&flow->fs_rule,
flow->ipaddr_rule.fs_ipdst_offset,
NH_FLD_IP_DST, prot == NET_PROT_IPV4);
if (ret) {
DPAA2_PMD_ERR("FS dst address reorder failed");
return -1;
}
flow->ipaddr_rule.fs_ipdst_offset =
dpaa2_flow_extract_key_offset(
&priv->extract.tc_key_extract[fs_group],
prot, NH_FLD_IP_DST);
}
return 0;
}
static int
dpaa2_flow_extract_support(
const uint8_t *mask_src,
enum rte_flow_item_type type)
{
char mask[64];
int i, size = 0;
const char *mask_support = 0;
switch (type) {
case RTE_FLOW_ITEM_TYPE_ETH:
mask_support = (const char *)&dpaa2_flow_item_eth_mask;
size = sizeof(struct rte_flow_item_eth);
break;
case RTE_FLOW_ITEM_TYPE_VLAN:
mask_support = (const char *)&dpaa2_flow_item_vlan_mask;
size = sizeof(struct rte_flow_item_vlan);
break;
case RTE_FLOW_ITEM_TYPE_IPV4:
mask_support = (const char *)&dpaa2_flow_item_ipv4_mask;
size = sizeof(struct rte_flow_item_ipv4);
break;
case RTE_FLOW_ITEM_TYPE_IPV6:
mask_support = (const char *)&dpaa2_flow_item_ipv6_mask;
size = sizeof(struct rte_flow_item_ipv6);
break;
case RTE_FLOW_ITEM_TYPE_ICMP:
mask_support = (const char *)&dpaa2_flow_item_icmp_mask;
size = sizeof(struct rte_flow_item_icmp);
break;
case RTE_FLOW_ITEM_TYPE_UDP:
mask_support = (const char *)&dpaa2_flow_item_udp_mask;
size = sizeof(struct rte_flow_item_udp);
break;
case RTE_FLOW_ITEM_TYPE_TCP:
mask_support = (const char *)&dpaa2_flow_item_tcp_mask;
size = sizeof(struct rte_flow_item_tcp);
break;
case RTE_FLOW_ITEM_TYPE_SCTP:
mask_support = (const char *)&dpaa2_flow_item_sctp_mask;
size = sizeof(struct rte_flow_item_sctp);
break;
case RTE_FLOW_ITEM_TYPE_GRE:
mask_support = (const char *)&dpaa2_flow_item_gre_mask;
size = sizeof(struct rte_flow_item_gre);
break;
default:
return -1;
}
memcpy(mask, mask_support, size);
for (i = 0; i < size; i++)
mask[i] = (mask[i] | mask_src[i]);
if (memcmp(mask, mask_support, size))
return -1;
return 0;
}
static int
dpaa2_configure_flow_eth(struct rte_flow *flow,
struct rte_eth_dev *dev,
const struct rte_flow_attr *attr,
const struct rte_flow_item *pattern,
const struct rte_flow_action actions[] __rte_unused,
struct rte_flow_error *error __rte_unused,
int *device_configured)
{
int index, ret;
int local_cfg = 0;
uint32_t group;
const struct rte_flow_item_eth *spec, *mask;
/* TODO: Currently upper bound of range parameter is not implemented */
const struct rte_flow_item_eth *last __rte_unused;
struct dpaa2_dev_priv *priv = dev->data->dev_private;
const char zero_cmp[RTE_ETHER_ADDR_LEN] = {0};
group = attr->group;
/* Parse pattern list to get the matching parameters */
spec = (const struct rte_flow_item_eth *)pattern->spec;
last = (const struct rte_flow_item_eth *)pattern->last;
mask = (const struct rte_flow_item_eth *)
(pattern->mask ? pattern->mask : &dpaa2_flow_item_eth_mask);
if (!spec) {
/* Don't care any field of eth header,
* only care eth protocol.
*/
DPAA2_PMD_WARN("No pattern spec for Eth flow, just skip");
return 0;
}
/* Get traffic class index and flow id to be configured */
flow->tc_id = group;
flow->tc_index = attr->priority;
if (dpaa2_flow_extract_support((const uint8_t *)mask,
RTE_FLOW_ITEM_TYPE_ETH)) {
DPAA2_PMD_WARN("Extract field(s) of ethernet not support.");
return -1;
}
if (memcmp((const char *)&mask->src, zero_cmp, RTE_ETHER_ADDR_LEN)) {
index = dpaa2_flow_extract_search(
&priv->extract.qos_key_extract.dpkg,
NET_PROT_ETH, NH_FLD_ETH_SA);
if (index < 0) {
ret = dpaa2_flow_extract_add(
&priv->extract.qos_key_extract,
NET_PROT_ETH, NH_FLD_ETH_SA,
RTE_ETHER_ADDR_LEN);
if (ret) {
DPAA2_PMD_ERR("QoS Extract add ETH_SA failed.");
return -1;
}
local_cfg |= DPAA2_QOS_TABLE_RECONFIGURE;
}
index = dpaa2_flow_extract_search(
&priv->extract.tc_key_extract[group].dpkg,
NET_PROT_ETH, NH_FLD_ETH_SA);
if (index < 0) {
ret = dpaa2_flow_extract_add(
&priv->extract.tc_key_extract[group],
NET_PROT_ETH, NH_FLD_ETH_SA,
RTE_ETHER_ADDR_LEN);
if (ret) {
DPAA2_PMD_ERR("FS Extract add ETH_SA failed.");
return -1;
}
local_cfg |= DPAA2_FS_TABLE_RECONFIGURE;
}
ret = dpaa2_flow_rule_move_ipaddr_tail(flow, priv, group);
if (ret) {
DPAA2_PMD_ERR(
"Move ipaddr before ETH_SA rule set failed");
return -1;
}
ret = dpaa2_flow_rule_data_set(
&priv->extract.qos_key_extract,
&flow->qos_rule,
NET_PROT_ETH,
NH_FLD_ETH_SA,
&spec->src.addr_bytes,
&mask->src.addr_bytes,
sizeof(struct rte_ether_addr));
if (ret) {
DPAA2_PMD_ERR("QoS NH_FLD_ETH_SA rule data set failed");
return -1;
}
ret = dpaa2_flow_rule_data_set(
&priv->extract.tc_key_extract[group],
&flow->fs_rule,
NET_PROT_ETH,
NH_FLD_ETH_SA,
&spec->src.addr_bytes,
&mask->src.addr_bytes,
sizeof(struct rte_ether_addr));
if (ret) {
DPAA2_PMD_ERR("FS NH_FLD_ETH_SA rule data set failed");
return -1;
}
}
if (memcmp((const char *)&mask->dst, zero_cmp, RTE_ETHER_ADDR_LEN)) {
index = dpaa2_flow_extract_search(
&priv->extract.qos_key_extract.dpkg,
NET_PROT_ETH, NH_FLD_ETH_DA);
if (index < 0) {
ret = dpaa2_flow_extract_add(
&priv->extract.qos_key_extract,
NET_PROT_ETH, NH_FLD_ETH_DA,
RTE_ETHER_ADDR_LEN);
if (ret) {
DPAA2_PMD_ERR("QoS Extract add ETH_DA failed.");
return -1;
}
local_cfg |= DPAA2_QOS_TABLE_RECONFIGURE;
}
index = dpaa2_flow_extract_search(
&priv->extract.tc_key_extract[group].dpkg,
NET_PROT_ETH, NH_FLD_ETH_DA);
if (index < 0) {
ret = dpaa2_flow_extract_add(
&priv->extract.tc_key_extract[group],
NET_PROT_ETH, NH_FLD_ETH_DA,
RTE_ETHER_ADDR_LEN);
if (ret) {
DPAA2_PMD_ERR("FS Extract add ETH_DA failed.");
return -1;
}
local_cfg |= DPAA2_FS_TABLE_RECONFIGURE;
}
ret = dpaa2_flow_rule_move_ipaddr_tail(flow, priv, group);
if (ret) {
DPAA2_PMD_ERR(
"Move ipaddr before ETH DA rule set failed");
return -1;
}
ret = dpaa2_flow_rule_data_set(
&priv->extract.qos_key_extract,
&flow->qos_rule,
NET_PROT_ETH,
NH_FLD_ETH_DA,
&spec->dst.addr_bytes,
&mask->dst.addr_bytes,
sizeof(struct rte_ether_addr));
if (ret) {
DPAA2_PMD_ERR("QoS NH_FLD_ETH_DA rule data set failed");
return -1;
}
ret = dpaa2_flow_rule_data_set(
&priv->extract.tc_key_extract[group],
&flow->fs_rule,
NET_PROT_ETH,
NH_FLD_ETH_DA,
&spec->dst.addr_bytes,
&mask->dst.addr_bytes,
sizeof(struct rte_ether_addr));
if (ret) {
DPAA2_PMD_ERR("FS NH_FLD_ETH_DA rule data set failed");
return -1;
}
}
if (memcmp((const char *)&mask->type, zero_cmp, sizeof(rte_be16_t))) {
index = dpaa2_flow_extract_search(
&priv->extract.qos_key_extract.dpkg,
NET_PROT_ETH, NH_FLD_ETH_TYPE);
if (index < 0) {
ret = dpaa2_flow_extract_add(
&priv->extract.qos_key_extract,
NET_PROT_ETH, NH_FLD_ETH_TYPE,
RTE_ETHER_TYPE_LEN);
if (ret) {
DPAA2_PMD_ERR("QoS Extract add ETH_TYPE failed.");
return -1;
}
local_cfg |= DPAA2_QOS_TABLE_RECONFIGURE;
}
index = dpaa2_flow_extract_search(
&priv->extract.tc_key_extract[group].dpkg,
NET_PROT_ETH, NH_FLD_ETH_TYPE);
if (index < 0) {
ret = dpaa2_flow_extract_add(
&priv->extract.tc_key_extract[group],
NET_PROT_ETH, NH_FLD_ETH_TYPE,
RTE_ETHER_TYPE_LEN);
if (ret) {
DPAA2_PMD_ERR("FS Extract add ETH_TYPE failed.");
return -1;
}
local_cfg |= DPAA2_FS_TABLE_RECONFIGURE;
}
ret = dpaa2_flow_rule_move_ipaddr_tail(flow, priv, group);
if (ret) {
DPAA2_PMD_ERR(
"Move ipaddr before ETH TYPE rule set failed");
return -1;
}
ret = dpaa2_flow_rule_data_set(
&priv->extract.qos_key_extract,
&flow->qos_rule,
NET_PROT_ETH,
NH_FLD_ETH_TYPE,
&spec->type,
&mask->type,
sizeof(rte_be16_t));
if (ret) {
DPAA2_PMD_ERR("QoS NH_FLD_ETH_TYPE rule data set failed");
return -1;
}
ret = dpaa2_flow_rule_data_set(
&priv->extract.tc_key_extract[group],
&flow->fs_rule,
NET_PROT_ETH,
NH_FLD_ETH_TYPE,
&spec->type,
&mask->type,
sizeof(rte_be16_t));
if (ret) {
DPAA2_PMD_ERR("FS NH_FLD_ETH_TYPE rule data set failed");
return -1;
}
}
(*device_configured) |= local_cfg;
return 0;
}
static int
dpaa2_configure_flow_vlan(struct rte_flow *flow,
struct rte_eth_dev *dev,
const struct rte_flow_attr *attr,
const struct rte_flow_item *pattern,
const struct rte_flow_action actions[] __rte_unused,
struct rte_flow_error *error __rte_unused,
int *device_configured)
{
int index, ret;
int local_cfg = 0;
uint32_t group;
const struct rte_flow_item_vlan *spec, *mask;
const struct rte_flow_item_vlan *last __rte_unused;
struct dpaa2_dev_priv *priv = dev->data->dev_private;
group = attr->group;
/* Parse pattern list to get the matching parameters */
spec = (const struct rte_flow_item_vlan *)pattern->spec;
last = (const struct rte_flow_item_vlan *)pattern->last;
mask = (const struct rte_flow_item_vlan *)
(pattern->mask ? pattern->mask : &dpaa2_flow_item_vlan_mask);
/* Get traffic class index and flow id to be configured */
flow->tc_id = group;
flow->tc_index = attr->priority;
if (!spec) {
/* Don't care any field of vlan header,
* only care vlan protocol.
*/
/* Eth type is actually used for vLan classification.
*/
struct proto_discrimination proto;
index = dpaa2_flow_extract_search(
&priv->extract.qos_key_extract.dpkg,
NET_PROT_ETH, NH_FLD_ETH_TYPE);
if (index < 0) {
ret = dpaa2_flow_proto_discrimination_extract(
&priv->extract.qos_key_extract,
RTE_FLOW_ITEM_TYPE_ETH);
if (ret) {
DPAA2_PMD_ERR(
"QoS Ext ETH_TYPE to discriminate vLan failed");
return -1;
}
local_cfg |= DPAA2_QOS_TABLE_RECONFIGURE;
}
index = dpaa2_flow_extract_search(
&priv->extract.tc_key_extract[group].dpkg,
NET_PROT_ETH, NH_FLD_ETH_TYPE);
if (index < 0) {
ret = dpaa2_flow_proto_discrimination_extract(
&priv->extract.tc_key_extract[group],
RTE_FLOW_ITEM_TYPE_ETH);
if (ret) {
DPAA2_PMD_ERR(
"FS Ext ETH_TYPE to discriminate vLan failed.");
return -1;
}
local_cfg |= DPAA2_FS_TABLE_RECONFIGURE;
}
ret = dpaa2_flow_rule_move_ipaddr_tail(flow, priv, group);
if (ret) {
DPAA2_PMD_ERR(
"Move ipaddr before vLan discrimination set failed");
return -1;
}
proto.type = RTE_FLOW_ITEM_TYPE_ETH;
proto.eth_type = rte_cpu_to_be_16(RTE_ETHER_TYPE_VLAN);
ret = dpaa2_flow_proto_discrimination_rule(priv, flow,
proto, group);
if (ret) {
DPAA2_PMD_ERR("vLan discrimination rule set failed");
return -1;
}
(*device_configured) |= local_cfg;
return 0;
}
if (dpaa2_flow_extract_support((const uint8_t *)mask,
RTE_FLOW_ITEM_TYPE_VLAN)) {
DPAA2_PMD_WARN("Extract field(s) of vlan not support.");
return -1;
}
if (!mask->tci)
return 0;
index = dpaa2_flow_extract_search(
&priv->extract.qos_key_extract.dpkg,
NET_PROT_VLAN, NH_FLD_VLAN_TCI);
if (index < 0) {
ret = dpaa2_flow_extract_add(
&priv->extract.qos_key_extract,
NET_PROT_VLAN,
NH_FLD_VLAN_TCI,
sizeof(rte_be16_t));
if (ret) {
DPAA2_PMD_ERR("QoS Extract add VLAN_TCI failed.");
return -1;
}
local_cfg |= DPAA2_QOS_TABLE_RECONFIGURE;
}
index = dpaa2_flow_extract_search(
&priv->extract.tc_key_extract[group].dpkg,
NET_PROT_VLAN, NH_FLD_VLAN_TCI);
if (index < 0) {
ret = dpaa2_flow_extract_add(
&priv->extract.tc_key_extract[group],
NET_PROT_VLAN,
NH_FLD_VLAN_TCI,
sizeof(rte_be16_t));
if (ret) {
DPAA2_PMD_ERR("FS Extract add VLAN_TCI failed.");
return -1;
}
local_cfg |= DPAA2_FS_TABLE_RECONFIGURE;
}
ret = dpaa2_flow_rule_move_ipaddr_tail(flow, priv, group);
if (ret) {
DPAA2_PMD_ERR(
"Move ipaddr before VLAN TCI rule set failed");
return -1;
}
ret = dpaa2_flow_rule_data_set(&priv->extract.qos_key_extract,
&flow->qos_rule,
NET_PROT_VLAN,
NH_FLD_VLAN_TCI,
&spec->tci,
&mask->tci,
sizeof(rte_be16_t));
if (ret) {
DPAA2_PMD_ERR("QoS NH_FLD_VLAN_TCI rule data set failed");
return -1;
}
ret = dpaa2_flow_rule_data_set(
&priv->extract.tc_key_extract[group],
&flow->fs_rule,
NET_PROT_VLAN,
NH_FLD_VLAN_TCI,
&spec->tci,
&mask->tci,
sizeof(rte_be16_t));
if (ret) {
DPAA2_PMD_ERR("FS NH_FLD_VLAN_TCI rule data set failed");
return -1;
}
(*device_configured) |= local_cfg;
return 0;
}
static int
dpaa2_configure_flow_ip_discrimation(
struct dpaa2_dev_priv *priv, struct rte_flow *flow,
const struct rte_flow_item *pattern,
int *local_cfg, int *device_configured,
uint32_t group)
{
int index, ret;
struct proto_discrimination proto;
index = dpaa2_flow_extract_search(
&priv->extract.qos_key_extract.dpkg,
NET_PROT_ETH, NH_FLD_ETH_TYPE);
if (index < 0) {
ret = dpaa2_flow_proto_discrimination_extract(
&priv->extract.qos_key_extract,
RTE_FLOW_ITEM_TYPE_ETH);
if (ret) {
DPAA2_PMD_ERR(
"QoS Extract ETH_TYPE to discriminate IP failed.");
return -1;
}
(*local_cfg) |= DPAA2_QOS_TABLE_RECONFIGURE;
}
index = dpaa2_flow_extract_search(
&priv->extract.tc_key_extract[group].dpkg,
NET_PROT_ETH, NH_FLD_ETH_TYPE);
if (index < 0) {
ret = dpaa2_flow_proto_discrimination_extract(
&priv->extract.tc_key_extract[group],
RTE_FLOW_ITEM_TYPE_ETH);
if (ret) {
DPAA2_PMD_ERR(
"FS Extract ETH_TYPE to discriminate IP failed.");
return -1;
}
(*local_cfg) |= DPAA2_FS_TABLE_RECONFIGURE;
}
ret = dpaa2_flow_rule_move_ipaddr_tail(flow, priv, group);
if (ret) {
DPAA2_PMD_ERR(
"Move ipaddr before IP discrimination set failed");
return -1;
}
proto.type = RTE_FLOW_ITEM_TYPE_ETH;
if (pattern->type == RTE_FLOW_ITEM_TYPE_IPV4)
proto.eth_type = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV4);
else
proto.eth_type = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV6);
ret = dpaa2_flow_proto_discrimination_rule(priv, flow, proto, group);
if (ret) {
DPAA2_PMD_ERR("IP discrimination rule set failed");
return -1;
}
(*device_configured) |= (*local_cfg);
return 0;
}
static int
dpaa2_configure_flow_generic_ip(
struct rte_flow *flow,
struct rte_eth_dev *dev,
const struct rte_flow_attr *attr,
const struct rte_flow_item *pattern,
const struct rte_flow_action actions[] __rte_unused,
struct rte_flow_error *error __rte_unused,
int *device_configured)
{
int index, ret;
int local_cfg = 0;
uint32_t group;
const struct rte_flow_item_ipv4 *spec_ipv4 = 0,
*mask_ipv4 = 0;
const struct rte_flow_item_ipv6 *spec_ipv6 = 0,
*mask_ipv6 = 0;
const void *key, *mask;
enum net_prot prot;
struct dpaa2_dev_priv *priv = dev->data->dev_private;
const char zero_cmp[NH_FLD_IPV6_ADDR_SIZE] = {0};
int size;
group = attr->group;
/* Parse pattern list to get the matching parameters */
if (pattern->type == RTE_FLOW_ITEM_TYPE_IPV4) {
spec_ipv4 = (const struct rte_flow_item_ipv4 *)pattern->spec;
mask_ipv4 = (const struct rte_flow_item_ipv4 *)
(pattern->mask ? pattern->mask :
&dpaa2_flow_item_ipv4_mask);
} else {
spec_ipv6 = (const struct rte_flow_item_ipv6 *)pattern->spec;
mask_ipv6 = (const struct rte_flow_item_ipv6 *)
(pattern->mask ? pattern->mask :
&dpaa2_flow_item_ipv6_mask);
}
/* Get traffic class index and flow id to be configured */
flow->tc_id = group;
flow->tc_index = attr->priority;
ret = dpaa2_configure_flow_ip_discrimation(priv,
flow, pattern, &local_cfg,
device_configured, group);
if (ret) {
DPAA2_PMD_ERR("IP discrimination failed!");
return -1;
}
if (!spec_ipv4 && !spec_ipv6)
return 0;
if (mask_ipv4) {
if (dpaa2_flow_extract_support((const uint8_t *)mask_ipv4,
RTE_FLOW_ITEM_TYPE_IPV4)) {
DPAA2_PMD_WARN("Extract field(s) of IPv4 not support.");
return -1;
}
}
if (mask_ipv6) {
if (dpaa2_flow_extract_support((const uint8_t *)mask_ipv6,
RTE_FLOW_ITEM_TYPE_IPV6)) {
DPAA2_PMD_WARN("Extract field(s) of IPv6 not support.");
return -1;
}
}
if (mask_ipv4 && (mask_ipv4->hdr.src_addr ||
mask_ipv4->hdr.dst_addr)) {
flow->ipaddr_rule.ipaddr_type = FLOW_IPV4_ADDR;
} else if (mask_ipv6 &&
(memcmp((const char *)mask_ipv6->hdr.src_addr,
zero_cmp, NH_FLD_IPV6_ADDR_SIZE) ||
memcmp((const char *)mask_ipv6->hdr.dst_addr,
zero_cmp, NH_FLD_IPV6_ADDR_SIZE))) {
flow->ipaddr_rule.ipaddr_type = FLOW_IPV6_ADDR;
}
if ((mask_ipv4 && mask_ipv4->hdr.src_addr) ||
(mask_ipv6 &&
memcmp((const char *)mask_ipv6->hdr.src_addr,
zero_cmp, NH_FLD_IPV6_ADDR_SIZE))) {
index = dpaa2_flow_extract_search(
&priv->extract.qos_key_extract.dpkg,
NET_PROT_IP, NH_FLD_IP_SRC);
if (index < 0) {
ret = dpaa2_flow_extract_add(
&priv->extract.qos_key_extract,
NET_PROT_IP,
NH_FLD_IP_SRC,
0);
if (ret) {
DPAA2_PMD_ERR("QoS Extract add IP_SRC failed.");
return -1;
}
local_cfg |= DPAA2_QOS_TABLE_RECONFIGURE;
}
index = dpaa2_flow_extract_search(
&priv->extract.tc_key_extract[group].dpkg,
NET_PROT_IP, NH_FLD_IP_SRC);
if (index < 0) {
ret = dpaa2_flow_extract_add(
&priv->extract.tc_key_extract[group],
NET_PROT_IP,
NH_FLD_IP_SRC,
0);
if (ret) {
DPAA2_PMD_ERR("FS Extract add IP_SRC failed.");
return -1;
}
local_cfg |= DPAA2_FS_TABLE_RECONFIGURE;
}
if (spec_ipv4)
key = &spec_ipv4->hdr.src_addr;
else
key = &spec_ipv6->hdr.src_addr[0];
if (mask_ipv4) {
mask = &mask_ipv4->hdr.src_addr;
size = NH_FLD_IPV4_ADDR_SIZE;
prot = NET_PROT_IPV4;
} else {
mask = &mask_ipv6->hdr.src_addr[0];
size = NH_FLD_IPV6_ADDR_SIZE;
prot = NET_PROT_IPV6;
}
ret = dpaa2_flow_rule_data_set(
&priv->extract.qos_key_extract,
&flow->qos_rule,
prot, NH_FLD_IP_SRC,
key, mask, size);
if (ret) {
DPAA2_PMD_ERR("QoS NH_FLD_IP_SRC rule data set failed");
return -1;
}
ret = dpaa2_flow_rule_data_set(
&priv->extract.tc_key_extract[group],
&flow->fs_rule,
prot, NH_FLD_IP_SRC,
key, mask, size);
if (ret) {
DPAA2_PMD_ERR("FS NH_FLD_IP_SRC rule data set failed");
return -1;
}
flow->ipaddr_rule.qos_ipsrc_offset =
dpaa2_flow_extract_key_offset(
&priv->extract.qos_key_extract,
prot, NH_FLD_IP_SRC);
flow->ipaddr_rule.fs_ipsrc_offset =
dpaa2_flow_extract_key_offset(
&priv->extract.tc_key_extract[group],
prot, NH_FLD_IP_SRC);
}
if ((mask_ipv4 && mask_ipv4->hdr.dst_addr) ||
(mask_ipv6 &&
memcmp((const char *)mask_ipv6->hdr.dst_addr,
zero_cmp, NH_FLD_IPV6_ADDR_SIZE))) {
index = dpaa2_flow_extract_search(
&priv->extract.qos_key_extract.dpkg,
NET_PROT_IP, NH_FLD_IP_DST);
if (index < 0) {
if (mask_ipv4)
size = NH_FLD_IPV4_ADDR_SIZE;
else
size = NH_FLD_IPV6_ADDR_SIZE;
ret = dpaa2_flow_extract_add(
&priv->extract.qos_key_extract,
NET_PROT_IP,
NH_FLD_IP_DST,
size);
if (ret) {
DPAA2_PMD_ERR("QoS Extract add IP_DST failed.");
return -1;
}
local_cfg |= DPAA2_QOS_TABLE_RECONFIGURE;
}
index = dpaa2_flow_extract_search(
&priv->extract.tc_key_extract[group].dpkg,
NET_PROT_IP, NH_FLD_IP_DST);
if (index < 0) {
if (mask_ipv4)
size = NH_FLD_IPV4_ADDR_SIZE;
else
size = NH_FLD_IPV6_ADDR_SIZE;
ret = dpaa2_flow_extract_add(
&priv->extract.tc_key_extract[group],
NET_PROT_IP,
NH_FLD_IP_DST,
size);
if (ret) {
DPAA2_PMD_ERR("FS Extract add IP_DST failed.");
return -1;
}
local_cfg |= DPAA2_FS_TABLE_RECONFIGURE;
}
if (spec_ipv4)
key = &spec_ipv4->hdr.dst_addr;
else
key = spec_ipv6->hdr.dst_addr;
if (mask_ipv4) {
mask = &mask_ipv4->hdr.dst_addr;
size = NH_FLD_IPV4_ADDR_SIZE;
prot = NET_PROT_IPV4;
} else {
mask = &mask_ipv6->hdr.dst_addr[0];
size = NH_FLD_IPV6_ADDR_SIZE;
prot = NET_PROT_IPV6;
}
ret = dpaa2_flow_rule_data_set(
&priv->extract.qos_key_extract,
&flow->qos_rule,
prot, NH_FLD_IP_DST,
key, mask, size);
if (ret) {
DPAA2_PMD_ERR("QoS NH_FLD_IP_DST rule data set failed");
return -1;
}
ret = dpaa2_flow_rule_data_set(
&priv->extract.tc_key_extract[group],
&flow->fs_rule,
prot, NH_FLD_IP_DST,
key, mask, size);
if (ret) {
DPAA2_PMD_ERR("FS NH_FLD_IP_DST rule data set failed");
return -1;
}
flow->ipaddr_rule.qos_ipdst_offset =
dpaa2_flow_extract_key_offset(
&priv->extract.qos_key_extract,
prot, NH_FLD_IP_DST);
flow->ipaddr_rule.fs_ipdst_offset =
dpaa2_flow_extract_key_offset(
&priv->extract.tc_key_extract[group],
prot, NH_FLD_IP_DST);
}
if ((mask_ipv4 && mask_ipv4->hdr.next_proto_id) ||
(mask_ipv6 && mask_ipv6->hdr.proto)) {
index = dpaa2_flow_extract_search(
&priv->extract.qos_key_extract.dpkg,
NET_PROT_IP, NH_FLD_IP_PROTO);
if (index < 0) {
ret = dpaa2_flow_extract_add(
&priv->extract.qos_key_extract,
NET_PROT_IP,
NH_FLD_IP_PROTO,
NH_FLD_IP_PROTO_SIZE);
if (ret) {
DPAA2_PMD_ERR("QoS Extract add IP_DST failed.");
return -1;
}
local_cfg |= DPAA2_QOS_TABLE_RECONFIGURE;
}
index = dpaa2_flow_extract_search(
&priv->extract.tc_key_extract[group].dpkg,
NET_PROT_IP, NH_FLD_IP_PROTO);
if (index < 0) {
ret = dpaa2_flow_extract_add(
&priv->extract.tc_key_extract[group],
NET_PROT_IP,
NH_FLD_IP_PROTO,
NH_FLD_IP_PROTO_SIZE);
if (ret) {
DPAA2_PMD_ERR("FS Extract add IP_DST failed.");
return -1;
}
local_cfg |= DPAA2_FS_TABLE_RECONFIGURE;
}
ret = dpaa2_flow_rule_move_ipaddr_tail(flow, priv, group);
if (ret) {
DPAA2_PMD_ERR(
"Move ipaddr after NH_FLD_IP_PROTO rule set failed");
return -1;
}
if (spec_ipv4)
key = &spec_ipv4->hdr.next_proto_id;
else
key = &spec_ipv6->hdr.proto;
if (mask_ipv4)
mask = &mask_ipv4->hdr.next_proto_id;
else
mask = &mask_ipv6->hdr.proto;
ret = dpaa2_flow_rule_data_set(
&priv->extract.qos_key_extract,
&flow->qos_rule,
NET_PROT_IP,
NH_FLD_IP_PROTO,
key, mask, NH_FLD_IP_PROTO_SIZE);
if (ret) {
DPAA2_PMD_ERR("QoS NH_FLD_IP_PROTO rule data set failed");
return -1;
}
ret = dpaa2_flow_rule_data_set(
&priv->extract.tc_key_extract[group],
&flow->fs_rule,
NET_PROT_IP,
NH_FLD_IP_PROTO,
key, mask, NH_FLD_IP_PROTO_SIZE);
if (ret) {
DPAA2_PMD_ERR("FS NH_FLD_IP_PROTO rule data set failed");
return -1;
}
}
(*device_configured) |= local_cfg;
return 0;
}
static int
dpaa2_configure_flow_icmp(struct rte_flow *flow,
struct rte_eth_dev *dev,
const struct rte_flow_attr *attr,
const struct rte_flow_item *pattern,
const struct rte_flow_action actions[] __rte_unused,
struct rte_flow_error *error __rte_unused,
int *device_configured)
{
int index, ret;
int local_cfg = 0;
uint32_t group;
const struct rte_flow_item_icmp *spec, *mask;
const struct rte_flow_item_icmp *last __rte_unused;
struct dpaa2_dev_priv *priv = dev->data->dev_private;
group = attr->group;
/* Parse pattern list to get the matching parameters */
spec = (const struct rte_flow_item_icmp *)pattern->spec;
last = (const struct rte_flow_item_icmp *)pattern->last;
mask = (const struct rte_flow_item_icmp *)
(pattern->mask ? pattern->mask : &dpaa2_flow_item_icmp_mask);
/* Get traffic class index and flow id to be configured */
flow->tc_id = group;
flow->tc_index = attr->priority;
if (!spec) {
/* Don't care any field of ICMP header,
* only care ICMP protocol.
* Example: flow create 0 ingress pattern icmp /
*/
/* Next proto of Generical IP is actually used
* for ICMP identification.
*/
struct proto_discrimination proto;
index = dpaa2_flow_extract_search(
&priv->extract.qos_key_extract.dpkg,
NET_PROT_IP, NH_FLD_IP_PROTO);
if (index < 0) {
ret = dpaa2_flow_proto_discrimination_extract(
&priv->extract.qos_key_extract,
DPAA2_FLOW_ITEM_TYPE_GENERIC_IP);
if (ret) {
DPAA2_PMD_ERR(
"QoS Extract IP protocol to discriminate ICMP failed.");
return -1;
}
local_cfg |= DPAA2_QOS_TABLE_RECONFIGURE;
}
index = dpaa2_flow_extract_search(
&priv->extract.tc_key_extract[group].dpkg,
NET_PROT_IP, NH_FLD_IP_PROTO);
if (index < 0) {
ret = dpaa2_flow_proto_discrimination_extract(
&priv->extract.tc_key_extract[group],
DPAA2_FLOW_ITEM_TYPE_GENERIC_IP);
if (ret) {
DPAA2_PMD_ERR(
"FS Extract IP protocol to discriminate ICMP failed.");
return -1;
}
local_cfg |= DPAA2_FS_TABLE_RECONFIGURE;
}
ret = dpaa2_flow_rule_move_ipaddr_tail(flow, priv, group);
if (ret) {
DPAA2_PMD_ERR(
"Move IP addr before ICMP discrimination set failed");
return -1;
}
proto.type = DPAA2_FLOW_ITEM_TYPE_GENERIC_IP;
proto.ip_proto = IPPROTO_ICMP;
ret = dpaa2_flow_proto_discrimination_rule(priv, flow,
proto, group);
if (ret) {
DPAA2_PMD_ERR("ICMP discrimination rule set failed");
return -1;
}
(*device_configured) |= local_cfg;
return 0;
}
if (dpaa2_flow_extract_support((const uint8_t *)mask,
RTE_FLOW_ITEM_TYPE_ICMP)) {
DPAA2_PMD_WARN("Extract field(s) of ICMP not support.");
return -1;
}
if (mask->hdr.icmp_type) {
index = dpaa2_flow_extract_search(
&priv->extract.qos_key_extract.dpkg,
NET_PROT_ICMP, NH_FLD_ICMP_TYPE);
if (index < 0) {
ret = dpaa2_flow_extract_add(
&priv->extract.qos_key_extract,
NET_PROT_ICMP,
NH_FLD_ICMP_TYPE,
NH_FLD_ICMP_TYPE_SIZE);
if (ret) {
DPAA2_PMD_ERR("QoS Extract add ICMP_TYPE failed.");
return -1;
}
local_cfg |= DPAA2_QOS_TABLE_RECONFIGURE;
}
index = dpaa2_flow_extract_search(
&priv->extract.tc_key_extract[group].dpkg,
NET_PROT_ICMP, NH_FLD_ICMP_TYPE);
if (index < 0) {
ret = dpaa2_flow_extract_add(
&priv->extract.tc_key_extract[group],
NET_PROT_ICMP,
NH_FLD_ICMP_TYPE,
NH_FLD_ICMP_TYPE_SIZE);
if (ret) {
DPAA2_PMD_ERR("FS Extract add ICMP_TYPE failed.");
return -1;
}
local_cfg |= DPAA2_FS_TABLE_RECONFIGURE;
}
ret = dpaa2_flow_rule_move_ipaddr_tail(flow, priv, group);
if (ret) {
DPAA2_PMD_ERR(
"Move ipaddr before ICMP TYPE set failed");
return -1;
}
ret = dpaa2_flow_rule_data_set(
&priv->extract.qos_key_extract,
&flow->qos_rule,
NET_PROT_ICMP,
NH_FLD_ICMP_TYPE,
&spec->hdr.icmp_type,
&mask->hdr.icmp_type,
NH_FLD_ICMP_TYPE_SIZE);
if (ret) {
DPAA2_PMD_ERR("QoS NH_FLD_ICMP_TYPE rule data set failed");
return -1;
}
ret = dpaa2_flow_rule_data_set(
&priv->extract.tc_key_extract[group],
&flow->fs_rule,
NET_PROT_ICMP,
NH_FLD_ICMP_TYPE,
&spec->hdr.icmp_type,
&mask->hdr.icmp_type,
NH_FLD_ICMP_TYPE_SIZE);
if (ret) {
DPAA2_PMD_ERR("FS NH_FLD_ICMP_TYPE rule data set failed");
return -1;
}
}
if (mask->hdr.icmp_code) {
index = dpaa2_flow_extract_search(
&priv->extract.qos_key_extract.dpkg,
NET_PROT_ICMP, NH_FLD_ICMP_CODE);
if (index < 0) {
ret = dpaa2_flow_extract_add(
&priv->extract.qos_key_extract,
NET_PROT_ICMP,
NH_FLD_ICMP_CODE,
NH_FLD_ICMP_CODE_SIZE);
if (ret) {
DPAA2_PMD_ERR("QoS Extract add ICMP_CODE failed.");
return -1;
}
local_cfg |= DPAA2_QOS_TABLE_RECONFIGURE;
}
index = dpaa2_flow_extract_search(
&priv->extract.tc_key_extract[group].dpkg,
NET_PROT_ICMP, NH_FLD_ICMP_CODE);
if (index < 0) {
ret = dpaa2_flow_extract_add(
&priv->extract.tc_key_extract[group],
NET_PROT_ICMP,
NH_FLD_ICMP_CODE,
NH_FLD_ICMP_CODE_SIZE);
if (ret) {
DPAA2_PMD_ERR("FS Extract add ICMP_CODE failed.");
return -1;
}
local_cfg |= DPAA2_FS_TABLE_RECONFIGURE;
}
ret = dpaa2_flow_rule_move_ipaddr_tail(flow, priv, group);
if (ret) {
DPAA2_PMD_ERR(
"Move ipaddr after ICMP CODE set failed");
return -1;
}
ret = dpaa2_flow_rule_data_set(
&priv->extract.qos_key_extract,
&flow->qos_rule,
NET_PROT_ICMP,
NH_FLD_ICMP_CODE,
&spec->hdr.icmp_code,
&mask->hdr.icmp_code,
NH_FLD_ICMP_CODE_SIZE);
if (ret) {
DPAA2_PMD_ERR("QoS NH_FLD_ICMP_CODE rule data set failed");
return -1;
}
ret = dpaa2_flow_rule_data_set(
&priv->extract.tc_key_extract[group],
&flow->fs_rule,
NET_PROT_ICMP,
NH_FLD_ICMP_CODE,
&spec->hdr.icmp_code,
&mask->hdr.icmp_code,
NH_FLD_ICMP_CODE_SIZE);
if (ret) {
DPAA2_PMD_ERR("FS NH_FLD_ICMP_CODE rule data set failed");
return -1;
}
}
(*device_configured) |= local_cfg;
return 0;
}
static int
dpaa2_configure_flow_udp(struct rte_flow *flow,
struct rte_eth_dev *dev,
const struct rte_flow_attr *attr,
const struct rte_flow_item *pattern,
const struct rte_flow_action actions[] __rte_unused,
struct rte_flow_error *error __rte_unused,
int *device_configured)
{
int index, ret;
int local_cfg = 0;
uint32_t group;
const struct rte_flow_item_udp *spec, *mask;
const struct rte_flow_item_udp *last __rte_unused;
struct dpaa2_dev_priv *priv = dev->data->dev_private;
group = attr->group;
/* Parse pattern list to get the matching parameters */
spec = (const struct rte_flow_item_udp *)pattern->spec;
last = (const struct rte_flow_item_udp *)pattern->last;
mask = (const struct rte_flow_item_udp *)
(pattern->mask ? pattern->mask : &dpaa2_flow_item_udp_mask);
/* Get traffic class index and flow id to be configured */
flow->tc_id = group;
flow->tc_index = attr->priority;
if (!spec || !mc_l4_port_identification) {
struct proto_discrimination proto;
index = dpaa2_flow_extract_search(
&priv->extract.qos_key_extract.dpkg,
NET_PROT_IP, NH_FLD_IP_PROTO);
if (index < 0) {
ret = dpaa2_flow_proto_discrimination_extract(
&priv->extract.qos_key_extract,
DPAA2_FLOW_ITEM_TYPE_GENERIC_IP);
if (ret) {
DPAA2_PMD_ERR(
"QoS Extract IP protocol to discriminate UDP failed.");
return -1;
}
local_cfg |= DPAA2_QOS_TABLE_RECONFIGURE;
}
index = dpaa2_flow_extract_search(
&priv->extract.tc_key_extract[group].dpkg,
NET_PROT_IP, NH_FLD_IP_PROTO);
if (index < 0) {
ret = dpaa2_flow_proto_discrimination_extract(
&priv->extract.tc_key_extract[group],
DPAA2_FLOW_ITEM_TYPE_GENERIC_IP);
if (ret) {
DPAA2_PMD_ERR(
"FS Extract IP protocol to discriminate UDP failed.");
return -1;
}
local_cfg |= DPAA2_FS_TABLE_RECONFIGURE;
}
ret = dpaa2_flow_rule_move_ipaddr_tail(flow, priv, group);
if (ret) {
DPAA2_PMD_ERR(
"Move IP addr before UDP discrimination set failed");
return -1;
}
proto.type = DPAA2_FLOW_ITEM_TYPE_GENERIC_IP;
proto.ip_proto = IPPROTO_UDP;
ret = dpaa2_flow_proto_discrimination_rule(priv, flow,
proto, group);
if (ret) {
DPAA2_PMD_ERR("UDP discrimination rule set failed");
return -1;
}
(*device_configured) |= local_cfg;
if (!spec)
return 0;
}
if (dpaa2_flow_extract_support((const uint8_t *)mask,
RTE_FLOW_ITEM_TYPE_UDP)) {
DPAA2_PMD_WARN("Extract field(s) of UDP not support.");
return -1;
}
if (mask->hdr.src_port) {
index = dpaa2_flow_extract_search(
&priv->extract.qos_key_extract.dpkg,
NET_PROT_UDP, NH_FLD_UDP_PORT_SRC);
if (index < 0) {
ret = dpaa2_flow_extract_add(
&priv->extract.qos_key_extract,
NET_PROT_UDP,
NH_FLD_UDP_PORT_SRC,
NH_FLD_UDP_PORT_SIZE);
if (ret) {
DPAA2_PMD_ERR("QoS Extract add UDP_SRC failed.");
return -1;
}
local_cfg |= DPAA2_QOS_TABLE_RECONFIGURE;
}
index = dpaa2_flow_extract_search(
&priv->extract.tc_key_extract[group].dpkg,
NET_PROT_UDP, NH_FLD_UDP_PORT_SRC);
if (index < 0) {
ret = dpaa2_flow_extract_add(
&priv->extract.tc_key_extract[group],
NET_PROT_UDP,
NH_FLD_UDP_PORT_SRC,
NH_FLD_UDP_PORT_SIZE);
if (ret) {
DPAA2_PMD_ERR("FS Extract add UDP_SRC failed.");
return -1;
}
local_cfg |= DPAA2_FS_TABLE_RECONFIGURE;
}
ret = dpaa2_flow_rule_move_ipaddr_tail(flow, priv, group);
if (ret) {
DPAA2_PMD_ERR(
"Move ipaddr before UDP_PORT_SRC set failed");
return -1;
}
ret = dpaa2_flow_rule_data_set(&priv->extract.qos_key_extract,
&flow->qos_rule,
NET_PROT_UDP,
NH_FLD_UDP_PORT_SRC,
&spec->hdr.src_port,
&mask->hdr.src_port,
NH_FLD_UDP_PORT_SIZE);
if (ret) {
DPAA2_PMD_ERR(
"QoS NH_FLD_UDP_PORT_SRC rule data set failed");
return -1;
}
ret = dpaa2_flow_rule_data_set(
&priv->extract.tc_key_extract[group],
&flow->fs_rule,
NET_PROT_UDP,
NH_FLD_UDP_PORT_SRC,
&spec->hdr.src_port,
&mask->hdr.src_port,
NH_FLD_UDP_PORT_SIZE);
if (ret) {
DPAA2_PMD_ERR(
"FS NH_FLD_UDP_PORT_SRC rule data set failed");
return -1;
}
}
if (mask->hdr.dst_port) {
index = dpaa2_flow_extract_search(
&priv->extract.qos_key_extract.dpkg,
NET_PROT_UDP, NH_FLD_UDP_PORT_DST);
if (index < 0) {
ret = dpaa2_flow_extract_add(
&priv->extract.qos_key_extract,
NET_PROT_UDP,
NH_FLD_UDP_PORT_DST,
NH_FLD_UDP_PORT_SIZE);
if (ret) {
DPAA2_PMD_ERR("QoS Extract add UDP_DST failed.");
return -1;
}
local_cfg |= DPAA2_QOS_TABLE_RECONFIGURE;
}
index = dpaa2_flow_extract_search(
&priv->extract.tc_key_extract[group].dpkg,
NET_PROT_UDP, NH_FLD_UDP_PORT_DST);
if (index < 0) {
ret = dpaa2_flow_extract_add(
&priv->extract.tc_key_extract[group],
NET_PROT_UDP,
NH_FLD_UDP_PORT_DST,
NH_FLD_UDP_PORT_SIZE);
if (ret) {
DPAA2_PMD_ERR("FS Extract add UDP_DST failed.");
return -1;
}
local_cfg |= DPAA2_FS_TABLE_RECONFIGURE;
}
ret = dpaa2_flow_rule_move_ipaddr_tail(flow, priv, group);
if (ret) {
DPAA2_PMD_ERR(
"Move ipaddr before UDP_PORT_DST set failed");
return -1;
}
ret = dpaa2_flow_rule_data_set(
&priv->extract.qos_key_extract,
&flow->qos_rule,
NET_PROT_UDP,
NH_FLD_UDP_PORT_DST,
&spec->hdr.dst_port,
&mask->hdr.dst_port,
NH_FLD_UDP_PORT_SIZE);
if (ret) {
DPAA2_PMD_ERR(
"QoS NH_FLD_UDP_PORT_DST rule data set failed");
return -1;
}
ret = dpaa2_flow_rule_data_set(
&priv->extract.tc_key_extract[group],
&flow->fs_rule,
NET_PROT_UDP,
NH_FLD_UDP_PORT_DST,
&spec->hdr.dst_port,
&mask->hdr.dst_port,
NH_FLD_UDP_PORT_SIZE);
if (ret) {
DPAA2_PMD_ERR(
"FS NH_FLD_UDP_PORT_DST rule data set failed");
return -1;
}
}
(*device_configured) |= local_cfg;
return 0;
}
static int
dpaa2_configure_flow_tcp(struct rte_flow *flow,
struct rte_eth_dev *dev,
const struct rte_flow_attr *attr,
const struct rte_flow_item *pattern,
const struct rte_flow_action actions[] __rte_unused,
struct rte_flow_error *error __rte_unused,
int *device_configured)
{
int index, ret;
int local_cfg = 0;
uint32_t group;
const struct rte_flow_item_tcp *spec, *mask;
const struct rte_flow_item_tcp *last __rte_unused;
struct dpaa2_dev_priv *priv = dev->data->dev_private;
group = attr->group;
/* Parse pattern list to get the matching parameters */
spec = (const struct rte_flow_item_tcp *)pattern->spec;
last = (const struct rte_flow_item_tcp *)pattern->last;
mask = (const struct rte_flow_item_tcp *)
(pattern->mask ? pattern->mask : &dpaa2_flow_item_tcp_mask);
/* Get traffic class index and flow id to be configured */
flow->tc_id = group;
flow->tc_index = attr->priority;
if (!spec || !mc_l4_port_identification) {
struct proto_discrimination proto;
index = dpaa2_flow_extract_search(
&priv->extract.qos_key_extract.dpkg,
NET_PROT_IP, NH_FLD_IP_PROTO);
if (index < 0) {
ret = dpaa2_flow_proto_discrimination_extract(
&priv->extract.qos_key_extract,
DPAA2_FLOW_ITEM_TYPE_GENERIC_IP);
if (ret) {
DPAA2_PMD_ERR(
"QoS Extract IP protocol to discriminate TCP failed.");
return -1;
}
local_cfg |= DPAA2_QOS_TABLE_RECONFIGURE;
}
index = dpaa2_flow_extract_search(
&priv->extract.tc_key_extract[group].dpkg,
NET_PROT_IP, NH_FLD_IP_PROTO);
if (index < 0) {
ret = dpaa2_flow_proto_discrimination_extract(
&priv->extract.tc_key_extract[group],
DPAA2_FLOW_ITEM_TYPE_GENERIC_IP);
if (ret) {
DPAA2_PMD_ERR(
"FS Extract IP protocol to discriminate TCP failed.");
return -1;
}
local_cfg |= DPAA2_FS_TABLE_RECONFIGURE;
}
ret = dpaa2_flow_rule_move_ipaddr_tail(flow, priv, group);
if (ret) {
DPAA2_PMD_ERR(
"Move IP addr before TCP discrimination set failed");
return -1;
}
proto.type = DPAA2_FLOW_ITEM_TYPE_GENERIC_IP;
proto.ip_proto = IPPROTO_TCP;
ret = dpaa2_flow_proto_discrimination_rule(priv, flow,
proto, group);
if (ret) {
DPAA2_PMD_ERR("TCP discrimination rule set failed");
return -1;
}
(*device_configured) |= local_cfg;
if (!spec)
return 0;
}
if (dpaa2_flow_extract_support((const uint8_t *)mask,
RTE_FLOW_ITEM_TYPE_TCP)) {
DPAA2_PMD_WARN("Extract field(s) of TCP not support.");
return -1;
}
if (mask->hdr.src_port) {
index = dpaa2_flow_extract_search(
&priv->extract.qos_key_extract.dpkg,
NET_PROT_TCP, NH_FLD_TCP_PORT_SRC);
if (index < 0) {
ret = dpaa2_flow_extract_add(
&priv->extract.qos_key_extract,
NET_PROT_TCP,
NH_FLD_TCP_PORT_SRC,
NH_FLD_TCP_PORT_SIZE);
if (ret) {
DPAA2_PMD_ERR("QoS Extract add TCP_SRC failed.");
return -1;
}
local_cfg |= DPAA2_QOS_TABLE_RECONFIGURE;
}
index = dpaa2_flow_extract_search(
&priv->extract.tc_key_extract[group].dpkg,
NET_PROT_TCP, NH_FLD_TCP_PORT_SRC);
if (index < 0) {
ret = dpaa2_flow_extract_add(
&priv->extract.tc_key_extract[group],
NET_PROT_TCP,
NH_FLD_TCP_PORT_SRC,
NH_FLD_TCP_PORT_SIZE);
if (ret) {
DPAA2_PMD_ERR("FS Extract add TCP_SRC failed.");
return -1;
}
local_cfg |= DPAA2_FS_TABLE_RECONFIGURE;
}
ret = dpaa2_flow_rule_move_ipaddr_tail(flow, priv, group);
if (ret) {
DPAA2_PMD_ERR(
"Move ipaddr before TCP_PORT_SRC set failed");
return -1;
}
ret = dpaa2_flow_rule_data_set(
&priv->extract.qos_key_extract,
&flow->qos_rule,
NET_PROT_TCP,
NH_FLD_TCP_PORT_SRC,
&spec->hdr.src_port,
&mask->hdr.src_port,
NH_FLD_TCP_PORT_SIZE);
if (ret) {
DPAA2_PMD_ERR(
"QoS NH_FLD_TCP_PORT_SRC rule data set failed");
return -1;
}
ret = dpaa2_flow_rule_data_set(
&priv->extract.tc_key_extract[group],
&flow->fs_rule,
NET_PROT_TCP,
NH_FLD_TCP_PORT_SRC,
&spec->hdr.src_port,
&mask->hdr.src_port,
NH_FLD_TCP_PORT_SIZE);
if (ret) {
DPAA2_PMD_ERR(
"FS NH_FLD_TCP_PORT_SRC rule data set failed");
return -1;
}
}
if (mask->hdr.dst_port) {
index = dpaa2_flow_extract_search(
&priv->extract.qos_key_extract.dpkg,
NET_PROT_TCP, NH_FLD_TCP_PORT_DST);
if (index < 0) {
ret = dpaa2_flow_extract_add(
&priv->extract.qos_key_extract,
NET_PROT_TCP,
NH_FLD_TCP_PORT_DST,
NH_FLD_TCP_PORT_SIZE);
if (ret) {
DPAA2_PMD_ERR("QoS Extract add TCP_DST failed.");
return -1;
}
local_cfg |= DPAA2_QOS_TABLE_RECONFIGURE;
}
index = dpaa2_flow_extract_search(
&priv->extract.tc_key_extract[group].dpkg,
NET_PROT_TCP, NH_FLD_TCP_PORT_DST);
if (index < 0) {
ret = dpaa2_flow_extract_add(
&priv->extract.tc_key_extract[group],
NET_PROT_TCP,
NH_FLD_TCP_PORT_DST,
NH_FLD_TCP_PORT_SIZE);
if (ret) {
DPAA2_PMD_ERR("FS Extract add TCP_DST failed.");
return -1;
}
local_cfg |= DPAA2_FS_TABLE_RECONFIGURE;
}
ret = dpaa2_flow_rule_move_ipaddr_tail(flow, priv, group);
if (ret) {
DPAA2_PMD_ERR(
"Move ipaddr before TCP_PORT_DST set failed");
return -1;
}
ret = dpaa2_flow_rule_data_set(
&priv->extract.qos_key_extract,
&flow->qos_rule,
NET_PROT_TCP,
NH_FLD_TCP_PORT_DST,
&spec->hdr.dst_port,
&mask->hdr.dst_port,
NH_FLD_TCP_PORT_SIZE);
if (ret) {
DPAA2_PMD_ERR(
"QoS NH_FLD_TCP_PORT_DST rule data set failed");
return -1;
}
ret = dpaa2_flow_rule_data_set(
&priv->extract.tc_key_extract[group],
&flow->fs_rule,
NET_PROT_TCP,
NH_FLD_TCP_PORT_DST,
&spec->hdr.dst_port,
&mask->hdr.dst_port,
NH_FLD_TCP_PORT_SIZE);
if (ret) {
DPAA2_PMD_ERR(
"FS NH_FLD_TCP_PORT_DST rule data set failed");
return -1;
}
}
(*device_configured) |= local_cfg;
return 0;
}
static int
dpaa2_configure_flow_sctp(struct rte_flow *flow,
struct rte_eth_dev *dev,
const struct rte_flow_attr *attr,
const struct rte_flow_item *pattern,
const struct rte_flow_action actions[] __rte_unused,
struct rte_flow_error *error __rte_unused,
int *device_configured)
{
int index, ret;
int local_cfg = 0;
uint32_t group;
const struct rte_flow_item_sctp *spec, *mask;
const struct rte_flow_item_sctp *last __rte_unused;
struct dpaa2_dev_priv *priv = dev->data->dev_private;
group = attr->group;
/* Parse pattern list to get the matching parameters */
spec = (const struct rte_flow_item_sctp *)pattern->spec;
last = (const struct rte_flow_item_sctp *)pattern->last;
mask = (const struct rte_flow_item_sctp *)
(pattern->mask ? pattern->mask :
&dpaa2_flow_item_sctp_mask);
/* Get traffic class index and flow id to be configured */
flow->tc_id = group;
flow->tc_index = attr->priority;
if (!spec || !mc_l4_port_identification) {
struct proto_discrimination proto;
index = dpaa2_flow_extract_search(
&priv->extract.qos_key_extract.dpkg,
NET_PROT_IP, NH_FLD_IP_PROTO);
if (index < 0) {
ret = dpaa2_flow_proto_discrimination_extract(
&priv->extract.qos_key_extract,
DPAA2_FLOW_ITEM_TYPE_GENERIC_IP);
if (ret) {
DPAA2_PMD_ERR(
"QoS Extract IP protocol to discriminate SCTP failed.");
return -1;
}
local_cfg |= DPAA2_QOS_TABLE_RECONFIGURE;
}
index = dpaa2_flow_extract_search(
&priv->extract.tc_key_extract[group].dpkg,
NET_PROT_IP, NH_FLD_IP_PROTO);
if (index < 0) {
ret = dpaa2_flow_proto_discrimination_extract(
&priv->extract.tc_key_extract[group],
DPAA2_FLOW_ITEM_TYPE_GENERIC_IP);
if (ret) {
DPAA2_PMD_ERR(
"FS Extract IP protocol to discriminate SCTP failed.");
return -1;
}
local_cfg |= DPAA2_FS_TABLE_RECONFIGURE;
}
ret = dpaa2_flow_rule_move_ipaddr_tail(flow, priv, group);
if (ret) {
DPAA2_PMD_ERR(
"Move ipaddr before SCTP discrimination set failed");
return -1;
}
proto.type = DPAA2_FLOW_ITEM_TYPE_GENERIC_IP;
proto.ip_proto = IPPROTO_SCTP;
ret = dpaa2_flow_proto_discrimination_rule(priv, flow,
proto, group);
if (ret) {
DPAA2_PMD_ERR("SCTP discrimination rule set failed");
return -1;
}
(*device_configured) |= local_cfg;
if (!spec)
return 0;
}
if (dpaa2_flow_extract_support((const uint8_t *)mask,
RTE_FLOW_ITEM_TYPE_SCTP)) {
DPAA2_PMD_WARN("Extract field(s) of SCTP not support.");
return -1;
}
if (mask->hdr.src_port) {
index = dpaa2_flow_extract_search(
&priv->extract.qos_key_extract.dpkg,
NET_PROT_SCTP, NH_FLD_SCTP_PORT_SRC);
if (index < 0) {
ret = dpaa2_flow_extract_add(
&priv->extract.qos_key_extract,
NET_PROT_SCTP,
NH_FLD_SCTP_PORT_SRC,
NH_FLD_SCTP_PORT_SIZE);
if (ret) {
DPAA2_PMD_ERR("QoS Extract add SCTP_SRC failed.");
return -1;
}
local_cfg |= DPAA2_QOS_TABLE_RECONFIGURE;
}
index = dpaa2_flow_extract_search(
&priv->extract.tc_key_extract[group].dpkg,
NET_PROT_SCTP, NH_FLD_SCTP_PORT_SRC);
if (index < 0) {
ret = dpaa2_flow_extract_add(
&priv->extract.tc_key_extract[group],
NET_PROT_SCTP,
NH_FLD_SCTP_PORT_SRC,
NH_FLD_SCTP_PORT_SIZE);
if (ret) {
DPAA2_PMD_ERR("FS Extract add SCTP_SRC failed.");
return -1;
}
local_cfg |= DPAA2_FS_TABLE_RECONFIGURE;
}
ret = dpaa2_flow_rule_move_ipaddr_tail(flow, priv, group);
if (ret) {
DPAA2_PMD_ERR(
"Move ipaddr before SCTP_PORT_SRC set failed");
return -1;
}
ret = dpaa2_flow_rule_data_set(
&priv->extract.qos_key_extract,
&flow->qos_rule,
NET_PROT_SCTP,
NH_FLD_SCTP_PORT_SRC,
&spec->hdr.src_port,
&mask->hdr.src_port,
NH_FLD_SCTP_PORT_SIZE);
if (ret) {
DPAA2_PMD_ERR(
"QoS NH_FLD_SCTP_PORT_SRC rule data set failed");
return -1;
}
ret = dpaa2_flow_rule_data_set(
&priv->extract.tc_key_extract[group],
&flow->fs_rule,
NET_PROT_SCTP,
NH_FLD_SCTP_PORT_SRC,
&spec->hdr.src_port,
&mask->hdr.src_port,
NH_FLD_SCTP_PORT_SIZE);
if (ret) {
DPAA2_PMD_ERR(
"FS NH_FLD_SCTP_PORT_SRC rule data set failed");
return -1;
}
}
if (mask->hdr.dst_port) {
index = dpaa2_flow_extract_search(
&priv->extract.qos_key_extract.dpkg,
NET_PROT_SCTP, NH_FLD_SCTP_PORT_DST);
if (index < 0) {
ret = dpaa2_flow_extract_add(
&priv->extract.qos_key_extract,
NET_PROT_SCTP,
NH_FLD_SCTP_PORT_DST,
NH_FLD_SCTP_PORT_SIZE);
if (ret) {
DPAA2_PMD_ERR("QoS Extract add SCTP_DST failed.");
return -1;
}
local_cfg |= DPAA2_QOS_TABLE_RECONFIGURE;
}
index = dpaa2_flow_extract_search(
&priv->extract.tc_key_extract[group].dpkg,
NET_PROT_SCTP, NH_FLD_SCTP_PORT_DST);
if (index < 0) {
ret = dpaa2_flow_extract_add(
&priv->extract.tc_key_extract[group],
NET_PROT_SCTP,
NH_FLD_SCTP_PORT_DST,
NH_FLD_SCTP_PORT_SIZE);
if (ret) {
DPAA2_PMD_ERR("FS Extract add SCTP_DST failed.");
return -1;
}
local_cfg |= DPAA2_FS_TABLE_RECONFIGURE;
}
ret = dpaa2_flow_rule_move_ipaddr_tail(flow, priv, group);
if (ret) {
DPAA2_PMD_ERR(
"Move ipaddr before SCTP_PORT_DST set failed");
return -1;
}
ret = dpaa2_flow_rule_data_set(
&priv->extract.qos_key_extract,
&flow->qos_rule,
NET_PROT_SCTP,
NH_FLD_SCTP_PORT_DST,
&spec->hdr.dst_port,
&mask->hdr.dst_port,
NH_FLD_SCTP_PORT_SIZE);
if (ret) {
DPAA2_PMD_ERR(
"QoS NH_FLD_SCTP_PORT_DST rule data set failed");
return -1;
}
ret = dpaa2_flow_rule_data_set(
&priv->extract.tc_key_extract[group],
&flow->fs_rule,
NET_PROT_SCTP,
NH_FLD_SCTP_PORT_DST,
&spec->hdr.dst_port,
&mask->hdr.dst_port,
NH_FLD_SCTP_PORT_SIZE);
if (ret) {
DPAA2_PMD_ERR(
"FS NH_FLD_SCTP_PORT_DST rule data set failed");
return -1;
}
}
(*device_configured) |= local_cfg;
return 0;
}
static int
dpaa2_configure_flow_gre(struct rte_flow *flow,
struct rte_eth_dev *dev,
const struct rte_flow_attr *attr,
const struct rte_flow_item *pattern,
const struct rte_flow_action actions[] __rte_unused,
struct rte_flow_error *error __rte_unused,
int *device_configured)
{
int index, ret;
int local_cfg = 0;
uint32_t group;
const struct rte_flow_item_gre *spec, *mask;
const struct rte_flow_item_gre *last __rte_unused;
struct dpaa2_dev_priv *priv = dev->data->dev_private;
group = attr->group;
/* Parse pattern list to get the matching parameters */
spec = (const struct rte_flow_item_gre *)pattern->spec;
last = (const struct rte_flow_item_gre *)pattern->last;
mask = (const struct rte_flow_item_gre *)
(pattern->mask ? pattern->mask : &dpaa2_flow_item_gre_mask);
/* Get traffic class index and flow id to be configured */
flow->tc_id = group;
flow->tc_index = attr->priority;
if (!spec) {
struct proto_discrimination proto;
index = dpaa2_flow_extract_search(
&priv->extract.qos_key_extract.dpkg,
NET_PROT_IP, NH_FLD_IP_PROTO);
if (index < 0) {
ret = dpaa2_flow_proto_discrimination_extract(
&priv->extract.qos_key_extract,
DPAA2_FLOW_ITEM_TYPE_GENERIC_IP);
if (ret) {
DPAA2_PMD_ERR(
"QoS Extract IP protocol to discriminate GRE failed.");
return -1;
}
local_cfg |= DPAA2_QOS_TABLE_RECONFIGURE;
}
index = dpaa2_flow_extract_search(
&priv->extract.tc_key_extract[group].dpkg,
NET_PROT_IP, NH_FLD_IP_PROTO);
if (index < 0) {
ret = dpaa2_flow_proto_discrimination_extract(
&priv->extract.tc_key_extract[group],
DPAA2_FLOW_ITEM_TYPE_GENERIC_IP);
if (ret) {
DPAA2_PMD_ERR(
"FS Extract IP protocol to discriminate GRE failed.");
return -1;
}
local_cfg |= DPAA2_FS_TABLE_RECONFIGURE;
}
ret = dpaa2_flow_rule_move_ipaddr_tail(flow, priv, group);
if (ret) {
DPAA2_PMD_ERR(
"Move IP addr before GRE discrimination set failed");
return -1;
}
proto.type = DPAA2_FLOW_ITEM_TYPE_GENERIC_IP;
proto.ip_proto = IPPROTO_GRE;
ret = dpaa2_flow_proto_discrimination_rule(priv, flow,
proto, group);
if (ret) {
DPAA2_PMD_ERR("GRE discrimination rule set failed");
return -1;
}
(*device_configured) |= local_cfg;
return 0;
}
if (dpaa2_flow_extract_support((const uint8_t *)mask,
RTE_FLOW_ITEM_TYPE_GRE)) {
DPAA2_PMD_WARN("Extract field(s) of GRE not support.");
return -1;
}
if (!mask->protocol)
return 0;
index = dpaa2_flow_extract_search(
&priv->extract.qos_key_extract.dpkg,
NET_PROT_GRE, NH_FLD_GRE_TYPE);
if (index < 0) {
ret = dpaa2_flow_extract_add(
&priv->extract.qos_key_extract,
NET_PROT_GRE,
NH_FLD_GRE_TYPE,
sizeof(rte_be16_t));
if (ret) {
DPAA2_PMD_ERR("QoS Extract add GRE_TYPE failed.");
return -1;
}
local_cfg |= DPAA2_QOS_TABLE_RECONFIGURE;
}
index = dpaa2_flow_extract_search(
&priv->extract.tc_key_extract[group].dpkg,
NET_PROT_GRE, NH_FLD_GRE_TYPE);
if (index < 0) {
ret = dpaa2_flow_extract_add(
&priv->extract.tc_key_extract[group],
NET_PROT_GRE,
NH_FLD_GRE_TYPE,
sizeof(rte_be16_t));
if (ret) {
DPAA2_PMD_ERR("FS Extract add GRE_TYPE failed.");
return -1;
}
local_cfg |= DPAA2_FS_TABLE_RECONFIGURE;
}
ret = dpaa2_flow_rule_move_ipaddr_tail(flow, priv, group);
if (ret) {
DPAA2_PMD_ERR(
"Move ipaddr before GRE_TYPE set failed");
return -1;
}
ret = dpaa2_flow_rule_data_set(
&priv->extract.qos_key_extract,
&flow->qos_rule,
NET_PROT_GRE,
NH_FLD_GRE_TYPE,
&spec->protocol,
&mask->protocol,
sizeof(rte_be16_t));
if (ret) {
DPAA2_PMD_ERR(
"QoS NH_FLD_GRE_TYPE rule data set failed");
return -1;
}
ret = dpaa2_flow_rule_data_set(
&priv->extract.tc_key_extract[group],
&flow->fs_rule,
NET_PROT_GRE,
NH_FLD_GRE_TYPE,
&spec->protocol,
&mask->protocol,
sizeof(rte_be16_t));
if (ret) {
DPAA2_PMD_ERR(
"FS NH_FLD_GRE_TYPE rule data set failed");
return -1;
}
(*device_configured) |= local_cfg;
return 0;
}
static int
dpaa2_configure_flow_raw(struct rte_flow *flow,
struct rte_eth_dev *dev,
const struct rte_flow_attr *attr,
const struct rte_flow_item *pattern,
const struct rte_flow_action actions[] __rte_unused,
struct rte_flow_error *error __rte_unused,
int *device_configured)
{
struct dpaa2_dev_priv *priv = dev->data->dev_private;
const struct rte_flow_item_raw *spec = pattern->spec;
const struct rte_flow_item_raw *mask = pattern->mask;
int prev_key_size =
priv->extract.qos_key_extract.key_info.key_total_size;
int local_cfg = 0, ret;
uint32_t group;
/* Need both spec and mask */
if (!spec || !mask) {
DPAA2_PMD_ERR("spec or mask not present.");
return -EINVAL;
}
/* Only supports non-relative with offset 0 */
if (spec->relative || spec->offset != 0 ||
spec->search || spec->limit) {
DPAA2_PMD_ERR("relative and non zero offset not supported.");
return -EINVAL;
}
/* Spec len and mask len should be same */
if (spec->length != mask->length) {
DPAA2_PMD_ERR("Spec len and mask len mismatch.");
return -EINVAL;
}
/* Get traffic class index and flow id to be configured */
group = attr->group;
flow->tc_id = group;
flow->tc_index = attr->priority;
if (prev_key_size <= spec->length) {
ret = dpaa2_flow_extract_add_raw(&priv->extract.qos_key_extract,
spec->length);
if (ret) {
DPAA2_PMD_ERR("QoS Extract RAW add failed.");
return -1;
}
local_cfg |= DPAA2_QOS_TABLE_RECONFIGURE;
ret = dpaa2_flow_extract_add_raw(
&priv->extract.tc_key_extract[group],
spec->length);
if (ret) {
DPAA2_PMD_ERR("FS Extract RAW add failed.");
return -1;
}
local_cfg |= DPAA2_FS_TABLE_RECONFIGURE;
}
ret = dpaa2_flow_rule_data_set_raw(&flow->qos_rule, spec->pattern,
mask->pattern, spec->length);
if (ret) {
DPAA2_PMD_ERR("QoS RAW rule data set failed");
return -1;
}
ret = dpaa2_flow_rule_data_set_raw(&flow->fs_rule, spec->pattern,
mask->pattern, spec->length);
if (ret) {
DPAA2_PMD_ERR("FS RAW rule data set failed");
return -1;
}
(*device_configured) |= local_cfg;
return 0;
}
static inline int
dpaa2_fs_action_supported(enum rte_flow_action_type action)
{
int i;
for (i = 0; i < (int)(sizeof(dpaa2_supported_fs_action_type) /
sizeof(enum rte_flow_action_type)); i++) {
if (action == dpaa2_supported_fs_action_type[i])
return 1;
}
return 0;
}
/* The existing QoS/FS entry with IP address(es)
* needs update after
* new extract(s) are inserted before IP
* address(es) extract(s).
*/
static int
dpaa2_flow_entry_update(
struct dpaa2_dev_priv *priv, uint8_t tc_id)
{
struct rte_flow *curr = LIST_FIRST(&priv->flows);
struct fsl_mc_io *dpni = (struct fsl_mc_io *)priv->hw;
int ret;
int qos_ipsrc_offset = -1, qos_ipdst_offset = -1;
int fs_ipsrc_offset = -1, fs_ipdst_offset = -1;
struct dpaa2_key_extract *qos_key_extract =
&priv->extract.qos_key_extract;
struct dpaa2_key_extract *tc_key_extract =
&priv->extract.tc_key_extract[tc_id];
char ipsrc_key[NH_FLD_IPV6_ADDR_SIZE];
char ipdst_key[NH_FLD_IPV6_ADDR_SIZE];
char ipsrc_mask[NH_FLD_IPV6_ADDR_SIZE];
char ipdst_mask[NH_FLD_IPV6_ADDR_SIZE];
int extend = -1, extend1, size = -1;
uint16_t qos_index;
while (curr) {
if (curr->ipaddr_rule.ipaddr_type ==
FLOW_NONE_IPADDR) {
curr = LIST_NEXT(curr, next);
continue;
}
if (curr->ipaddr_rule.ipaddr_type ==
FLOW_IPV4_ADDR) {
qos_ipsrc_offset =
qos_key_extract->key_info.ipv4_src_offset;
qos_ipdst_offset =
qos_key_extract->key_info.ipv4_dst_offset;
fs_ipsrc_offset =
tc_key_extract->key_info.ipv4_src_offset;
fs_ipdst_offset =
tc_key_extract->key_info.ipv4_dst_offset;
size = NH_FLD_IPV4_ADDR_SIZE;
} else {
qos_ipsrc_offset =
qos_key_extract->key_info.ipv6_src_offset;
qos_ipdst_offset =
qos_key_extract->key_info.ipv6_dst_offset;
fs_ipsrc_offset =
tc_key_extract->key_info.ipv6_src_offset;
fs_ipdst_offset =
tc_key_extract->key_info.ipv6_dst_offset;
size = NH_FLD_IPV6_ADDR_SIZE;
}
qos_index = curr->tc_id * priv->fs_entries +
curr->tc_index;
dpaa2_flow_qos_entry_log("Before update", curr, qos_index);
if (priv->num_rx_tc > 1) {
ret = dpni_remove_qos_entry(dpni, CMD_PRI_LOW,
priv->token, &curr->qos_rule);
if (ret) {
DPAA2_PMD_ERR("Qos entry remove failed.");
return -1;
}
}
extend = -1;
if (curr->ipaddr_rule.qos_ipsrc_offset >= 0) {
RTE_ASSERT(qos_ipsrc_offset >=
curr->ipaddr_rule.qos_ipsrc_offset);
extend1 = qos_ipsrc_offset -
curr->ipaddr_rule.qos_ipsrc_offset;
if (extend >= 0)
RTE_ASSERT(extend == extend1);
else
extend = extend1;
RTE_ASSERT((size == NH_FLD_IPV4_ADDR_SIZE) ||
(size == NH_FLD_IPV6_ADDR_SIZE));
memcpy(ipsrc_key,
(char *)(size_t)curr->qos_rule.key_iova +
curr->ipaddr_rule.qos_ipsrc_offset,
size);
memset((char *)(size_t)curr->qos_rule.key_iova +
curr->ipaddr_rule.qos_ipsrc_offset,
0, size);
memcpy(ipsrc_mask,
(char *)(size_t)curr->qos_rule.mask_iova +
curr->ipaddr_rule.qos_ipsrc_offset,
size);
memset((char *)(size_t)curr->qos_rule.mask_iova +
curr->ipaddr_rule.qos_ipsrc_offset,
0, size);
curr->ipaddr_rule.qos_ipsrc_offset = qos_ipsrc_offset;
}
if (curr->ipaddr_rule.qos_ipdst_offset >= 0) {
RTE_ASSERT(qos_ipdst_offset >=
curr->ipaddr_rule.qos_ipdst_offset);
extend1 = qos_ipdst_offset -
curr->ipaddr_rule.qos_ipdst_offset;
if (extend >= 0)
RTE_ASSERT(extend == extend1);
else
extend = extend1;
RTE_ASSERT((size == NH_FLD_IPV4_ADDR_SIZE) ||
(size == NH_FLD_IPV6_ADDR_SIZE));
memcpy(ipdst_key,
(char *)(size_t)curr->qos_rule.key_iova +
curr->ipaddr_rule.qos_ipdst_offset,
size);
memset((char *)(size_t)curr->qos_rule.key_iova +
curr->ipaddr_rule.qos_ipdst_offset,
0, size);
memcpy(ipdst_mask,
(char *)(size_t)curr->qos_rule.mask_iova +
curr->ipaddr_rule.qos_ipdst_offset,
size);
memset((char *)(size_t)curr->qos_rule.mask_iova +
curr->ipaddr_rule.qos_ipdst_offset,
0, size);
curr->ipaddr_rule.qos_ipdst_offset = qos_ipdst_offset;
}
if (curr->ipaddr_rule.qos_ipsrc_offset >= 0) {
RTE_ASSERT((size == NH_FLD_IPV4_ADDR_SIZE) ||
(size == NH_FLD_IPV6_ADDR_SIZE));
memcpy((char *)(size_t)curr->qos_rule.key_iova +
curr->ipaddr_rule.qos_ipsrc_offset,
ipsrc_key,
size);
memcpy((char *)(size_t)curr->qos_rule.mask_iova +
curr->ipaddr_rule.qos_ipsrc_offset,
ipsrc_mask,
size);
}
if (curr->ipaddr_rule.qos_ipdst_offset >= 0) {
RTE_ASSERT((size == NH_FLD_IPV4_ADDR_SIZE) ||
(size == NH_FLD_IPV6_ADDR_SIZE));
memcpy((char *)(size_t)curr->qos_rule.key_iova +
curr->ipaddr_rule.qos_ipdst_offset,
ipdst_key,
size);
memcpy((char *)(size_t)curr->qos_rule.mask_iova +
curr->ipaddr_rule.qos_ipdst_offset,
ipdst_mask,
size);
}
if (extend >= 0)
curr->qos_real_key_size += extend;
curr->qos_rule.key_size = FIXED_ENTRY_SIZE;
dpaa2_flow_qos_entry_log("Start update", curr, qos_index);
if (priv->num_rx_tc > 1) {
ret = dpni_add_qos_entry(dpni, CMD_PRI_LOW,
priv->token, &curr->qos_rule,
curr->tc_id, qos_index,
0, 0);
if (ret) {
DPAA2_PMD_ERR("Qos entry update failed.");
return -1;
}
}
if (!dpaa2_fs_action_supported(curr->action)) {
curr = LIST_NEXT(curr, next);
continue;
}
dpaa2_flow_fs_entry_log("Before update", curr);
extend = -1;
ret = dpni_remove_fs_entry(dpni, CMD_PRI_LOW,
priv->token, curr->tc_id, &curr->fs_rule);
if (ret) {
DPAA2_PMD_ERR("FS entry remove failed.");
return -1;
}
if (curr->ipaddr_rule.fs_ipsrc_offset >= 0 &&
tc_id == curr->tc_id) {
RTE_ASSERT(fs_ipsrc_offset >=
curr->ipaddr_rule.fs_ipsrc_offset);
extend1 = fs_ipsrc_offset -
curr->ipaddr_rule.fs_ipsrc_offset;
if (extend >= 0)
RTE_ASSERT(extend == extend1);
else
extend = extend1;
memcpy(ipsrc_key,
(char *)(size_t)curr->fs_rule.key_iova +
curr->ipaddr_rule.fs_ipsrc_offset,
size);
memset((char *)(size_t)curr->fs_rule.key_iova +
curr->ipaddr_rule.fs_ipsrc_offset,
0, size);
memcpy(ipsrc_mask,
(char *)(size_t)curr->fs_rule.mask_iova +
curr->ipaddr_rule.fs_ipsrc_offset,
size);
memset((char *)(size_t)curr->fs_rule.mask_iova +
curr->ipaddr_rule.fs_ipsrc_offset,
0, size);
curr->ipaddr_rule.fs_ipsrc_offset = fs_ipsrc_offset;
}
if (curr->ipaddr_rule.fs_ipdst_offset >= 0 &&
tc_id == curr->tc_id) {
RTE_ASSERT(fs_ipdst_offset >=
curr->ipaddr_rule.fs_ipdst_offset);
extend1 = fs_ipdst_offset -
curr->ipaddr_rule.fs_ipdst_offset;
if (extend >= 0)
RTE_ASSERT(extend == extend1);
else
extend = extend1;
memcpy(ipdst_key,
(char *)(size_t)curr->fs_rule.key_iova +
curr->ipaddr_rule.fs_ipdst_offset,
size);
memset((char *)(size_t)curr->fs_rule.key_iova +
curr->ipaddr_rule.fs_ipdst_offset,
0, size);
memcpy(ipdst_mask,
(char *)(size_t)curr->fs_rule.mask_iova +
curr->ipaddr_rule.fs_ipdst_offset,
size);
memset((char *)(size_t)curr->fs_rule.mask_iova +
curr->ipaddr_rule.fs_ipdst_offset,
0, size);
curr->ipaddr_rule.fs_ipdst_offset = fs_ipdst_offset;
}
if (curr->ipaddr_rule.fs_ipsrc_offset >= 0) {
memcpy((char *)(size_t)curr->fs_rule.key_iova +
curr->ipaddr_rule.fs_ipsrc_offset,
ipsrc_key,
size);
memcpy((char *)(size_t)curr->fs_rule.mask_iova +
curr->ipaddr_rule.fs_ipsrc_offset,
ipsrc_mask,
size);
}
if (curr->ipaddr_rule.fs_ipdst_offset >= 0) {
memcpy((char *)(size_t)curr->fs_rule.key_iova +
curr->ipaddr_rule.fs_ipdst_offset,
ipdst_key,
size);
memcpy((char *)(size_t)curr->fs_rule.mask_iova +
curr->ipaddr_rule.fs_ipdst_offset,
ipdst_mask,
size);
}
if (extend >= 0)
curr->fs_real_key_size += extend;
curr->fs_rule.key_size = FIXED_ENTRY_SIZE;
dpaa2_flow_fs_entry_log("Start update", curr);
ret = dpni_add_fs_entry(dpni, CMD_PRI_LOW,
priv->token, curr->tc_id, curr->tc_index,
&curr->fs_rule, &curr->action_cfg);
if (ret) {
DPAA2_PMD_ERR("FS entry update failed.");
return -1;
}
curr = LIST_NEXT(curr, next);
}
return 0;
}
static inline int
dpaa2_flow_verify_attr(
struct dpaa2_dev_priv *priv,
const struct rte_flow_attr *attr)
{
struct rte_flow *curr = LIST_FIRST(&priv->flows);
while (curr) {
if (curr->tc_id == attr->group &&
curr->tc_index == attr->priority) {
DPAA2_PMD_ERR(
"Flow with group %d and priority %d already exists.",
attr->group, attr->priority);
return -1;
}
curr = LIST_NEXT(curr, next);
}
return 0;
}
static inline struct rte_eth_dev *
dpaa2_flow_redirect_dev(struct dpaa2_dev_priv *priv,
const struct rte_flow_action *action)
{
const struct rte_flow_action_phy_port *phy_port;
const struct rte_flow_action_port_id *port_id;
int idx = -1;
struct rte_eth_dev *dest_dev;
if (action->type == RTE_FLOW_ACTION_TYPE_PHY_PORT) {
phy_port = (const struct rte_flow_action_phy_port *)
action->conf;
if (!phy_port->original)
idx = phy_port->index;
} else if (action->type == RTE_FLOW_ACTION_TYPE_PORT_ID) {
port_id = (const struct rte_flow_action_port_id *)
action->conf;
if (!port_id->original)
idx = port_id->id;
} else {
return NULL;
}
if (idx >= 0) {
if (!rte_eth_dev_is_valid_port(idx))
return NULL;
dest_dev = &rte_eth_devices[idx];
} else {
dest_dev = priv->eth_dev;
}
if (!dpaa2_dev_is_dpaa2(dest_dev))
return NULL;
return dest_dev;
}
static inline int
dpaa2_flow_verify_action(
struct dpaa2_dev_priv *priv,
const struct rte_flow_attr *attr,
const struct rte_flow_action actions[])
{
int end_of_list = 0, i, j = 0;
const struct rte_flow_action_queue *dest_queue;
const struct rte_flow_action_rss *rss_conf;
struct dpaa2_queue *rxq;
while (!end_of_list) {
switch (actions[j].type) {
case RTE_FLOW_ACTION_TYPE_QUEUE:
dest_queue = (const struct rte_flow_action_queue *)
(actions[j].conf);
rxq = priv->rx_vq[dest_queue->index];
if (attr->group != rxq->tc_index) {
DPAA2_PMD_ERR(
"RXQ[%d] does not belong to the group %d",
dest_queue->index, attr->group);
return -1;
}
break;
case RTE_FLOW_ACTION_TYPE_PHY_PORT:
case RTE_FLOW_ACTION_TYPE_PORT_ID:
if (!dpaa2_flow_redirect_dev(priv, &actions[j])) {
DPAA2_PMD_ERR("Invalid port id of action");
return -ENOTSUP;
}
break;
case RTE_FLOW_ACTION_TYPE_RSS:
rss_conf = (const struct rte_flow_action_rss *)
(actions[j].conf);
if (rss_conf->queue_num > priv->dist_queues) {
DPAA2_PMD_ERR(
"RSS number exceeds the distribution size");
return -ENOTSUP;
}
for (i = 0; i < (int)rss_conf->queue_num; i++) {
if (rss_conf->queue[i] >= priv->nb_rx_queues) {
DPAA2_PMD_ERR(
"RSS queue index exceeds the number of RXQs");
return -ENOTSUP;
}
rxq = priv->rx_vq[rss_conf->queue[i]];
if (rxq->tc_index != attr->group) {
DPAA2_PMD_ERR(
"Queue/Group combination are not supported\n");
return -ENOTSUP;
}
}
break;
case RTE_FLOW_ACTION_TYPE_END:
end_of_list = 1;
break;
default:
DPAA2_PMD_ERR("Invalid action type");
return -ENOTSUP;
}
j++;
}
return 0;
}
static int
dpaa2_generic_flow_set(struct rte_flow *flow,
struct rte_eth_dev *dev,
const struct rte_flow_attr *attr,
const struct rte_flow_item pattern[],
const struct rte_flow_action actions[],
struct rte_flow_error *error)
{
const struct rte_flow_action_queue *dest_queue;
const struct rte_flow_action_rss *rss_conf;
int is_keycfg_configured = 0, end_of_list = 0;
int ret = 0, i = 0, j = 0;
struct dpni_rx_dist_cfg tc_cfg;
struct dpni_qos_tbl_cfg qos_cfg;
struct dpni_fs_action_cfg action;
struct dpaa2_dev_priv *priv = dev->data->dev_private;
struct dpaa2_queue *dest_q;
struct fsl_mc_io *dpni = (struct fsl_mc_io *)priv->hw;
size_t param;
struct rte_flow *curr = LIST_FIRST(&priv->flows);
uint16_t qos_index;
struct rte_eth_dev *dest_dev;
struct dpaa2_dev_priv *dest_priv;
ret = dpaa2_flow_verify_attr(priv, attr);
if (ret)
return ret;
ret = dpaa2_flow_verify_action(priv, attr, actions);
if (ret)
return ret;
/* Parse pattern list to get the matching parameters */
while (!end_of_list) {
switch (pattern[i].type) {
case RTE_FLOW_ITEM_TYPE_ETH:
ret = dpaa2_configure_flow_eth(flow,
dev, attr, &pattern[i], actions, error,
&is_keycfg_configured);
if (ret) {
DPAA2_PMD_ERR("ETH flow configuration failed!");
return ret;
}
break;
case RTE_FLOW_ITEM_TYPE_VLAN:
ret = dpaa2_configure_flow_vlan(flow,
dev, attr, &pattern[i], actions, error,
&is_keycfg_configured);
if (ret) {
DPAA2_PMD_ERR("vLan flow configuration failed!");
return ret;
}
break;
case RTE_FLOW_ITEM_TYPE_IPV4:
case RTE_FLOW_ITEM_TYPE_IPV6:
ret = dpaa2_configure_flow_generic_ip(flow,
dev, attr, &pattern[i], actions, error,
&is_keycfg_configured);
if (ret) {
DPAA2_PMD_ERR("IP flow configuration failed!");
return ret;
}
break;
case RTE_FLOW_ITEM_TYPE_ICMP:
ret = dpaa2_configure_flow_icmp(flow,
dev, attr, &pattern[i], actions, error,
&is_keycfg_configured);
if (ret) {
DPAA2_PMD_ERR("ICMP flow configuration failed!");
return ret;
}
break;
case RTE_FLOW_ITEM_TYPE_UDP:
ret = dpaa2_configure_flow_udp(flow,
dev, attr, &pattern[i], actions, error,
&is_keycfg_configured);
if (ret) {
DPAA2_PMD_ERR("UDP flow configuration failed!");
return ret;
}
break;
case RTE_FLOW_ITEM_TYPE_TCP:
ret = dpaa2_configure_flow_tcp(flow,
dev, attr, &pattern[i], actions, error,
&is_keycfg_configured);
if (ret) {
DPAA2_PMD_ERR("TCP flow configuration failed!");
return ret;
}
break;
case RTE_FLOW_ITEM_TYPE_SCTP:
ret = dpaa2_configure_flow_sctp(flow,
dev, attr, &pattern[i], actions, error,
&is_keycfg_configured);
if (ret) {
DPAA2_PMD_ERR("SCTP flow configuration failed!");
return ret;
}
break;
case RTE_FLOW_ITEM_TYPE_GRE:
ret = dpaa2_configure_flow_gre(flow,
dev, attr, &pattern[i], actions, error,
&is_keycfg_configured);
if (ret) {
DPAA2_PMD_ERR("GRE flow configuration failed!");
return ret;
}
break;
case RTE_FLOW_ITEM_TYPE_RAW:
ret = dpaa2_configure_flow_raw(flow,
dev, attr, &pattern[i],
actions, error,
&is_keycfg_configured);
if (ret) {
DPAA2_PMD_ERR("RAW flow configuration failed!");
return ret;
}
break;
case RTE_FLOW_ITEM_TYPE_END:
end_of_list = 1;
break; /*End of List*/
default:
DPAA2_PMD_ERR("Invalid action type");
ret = -ENOTSUP;
break;
}
i++;
}
/* Let's parse action on matching traffic */
end_of_list = 0;
while (!end_of_list) {
switch (actions[j].type) {
case RTE_FLOW_ACTION_TYPE_QUEUE:
case RTE_FLOW_ACTION_TYPE_PHY_PORT:
case RTE_FLOW_ACTION_TYPE_PORT_ID:
memset(&action, 0, sizeof(struct dpni_fs_action_cfg));
flow->action = actions[j].type;
if (actions[j].type == RTE_FLOW_ACTION_TYPE_QUEUE) {
dest_queue = (const struct rte_flow_action_queue *)
(actions[j].conf);
dest_q = priv->rx_vq[dest_queue->index];
action.flow_id = dest_q->flow_id;
} else {
dest_dev = dpaa2_flow_redirect_dev(priv,
&actions[j]);
if (!dest_dev) {
DPAA2_PMD_ERR("Invalid destination device to redirect!");
return -1;
}
dest_priv = dest_dev->data->dev_private;
dest_q = dest_priv->tx_vq[0];
action.options =
DPNI_FS_OPT_REDIRECT_TO_DPNI_TX;
action.redirect_obj_token = dest_priv->token;
action.flow_id = dest_q->flow_id;
}
/* Configure FS table first*/
if (is_keycfg_configured & DPAA2_FS_TABLE_RECONFIGURE) {
dpaa2_flow_fs_table_extracts_log(priv, flow->tc_id);
if (dpkg_prepare_key_cfg(
&priv->extract.tc_key_extract[flow->tc_id].dpkg,
(uint8_t *)(size_t)priv->extract
.tc_extract_param[flow->tc_id]) < 0) {
DPAA2_PMD_ERR(
"Unable to prepare extract parameters");
return -1;
}
memset(&tc_cfg, 0,
sizeof(struct dpni_rx_dist_cfg));
tc_cfg.dist_size = priv->nb_rx_queues / priv->num_rx_tc;
tc_cfg.key_cfg_iova =
(uint64_t)priv->extract.tc_extract_param[flow->tc_id];
tc_cfg.tc = flow->tc_id;
tc_cfg.enable = false;
ret = dpni_set_rx_hash_dist(dpni, CMD_PRI_LOW,
priv->token, &tc_cfg);
if (ret < 0) {
DPAA2_PMD_ERR(
"TC hash cannot be disabled.(%d)",
ret);
return -1;
}
tc_cfg.enable = true;
tc_cfg.fs_miss_flow_id = dpaa2_flow_miss_flow_id;
ret = dpni_set_rx_fs_dist(dpni, CMD_PRI_LOW,
priv->token, &tc_cfg);
if (ret < 0) {
DPAA2_PMD_ERR(
"TC distribution cannot be configured.(%d)",
ret);
return -1;
}
}
/* Configure QoS table then.*/
if (is_keycfg_configured & DPAA2_QOS_TABLE_RECONFIGURE) {
dpaa2_flow_qos_table_extracts_log(priv);
if (dpkg_prepare_key_cfg(
&priv->extract.qos_key_extract.dpkg,
(uint8_t *)(size_t)priv->extract.qos_extract_param) < 0) {
DPAA2_PMD_ERR(
"Unable to prepare extract parameters");
return -1;
}
memset(&qos_cfg, 0, sizeof(struct dpni_qos_tbl_cfg));
qos_cfg.discard_on_miss = false;
qos_cfg.default_tc = 0;
qos_cfg.keep_entries = true;
qos_cfg.key_cfg_iova =
(size_t)priv->extract.qos_extract_param;
/* QoS table is effective for multiple TCs. */
if (priv->num_rx_tc > 1) {
ret = dpni_set_qos_table(dpni, CMD_PRI_LOW,
priv->token, &qos_cfg);
if (ret < 0) {
DPAA2_PMD_ERR(
"RSS QoS table can not be configured(%d)\n",
ret);
return -1;
}
}
}
flow->qos_real_key_size = priv->extract
.qos_key_extract.key_info.key_total_size;
if (flow->ipaddr_rule.ipaddr_type == FLOW_IPV4_ADDR) {
if (flow->ipaddr_rule.qos_ipdst_offset >=
flow->ipaddr_rule.qos_ipsrc_offset) {
flow->qos_real_key_size =
flow->ipaddr_rule.qos_ipdst_offset +
NH_FLD_IPV4_ADDR_SIZE;
} else {
flow->qos_real_key_size =
flow->ipaddr_rule.qos_ipsrc_offset +
NH_FLD_IPV4_ADDR_SIZE;
}
} else if (flow->ipaddr_rule.ipaddr_type ==
FLOW_IPV6_ADDR) {
if (flow->ipaddr_rule.qos_ipdst_offset >=
flow->ipaddr_rule.qos_ipsrc_offset) {
flow->qos_real_key_size =
flow->ipaddr_rule.qos_ipdst_offset +
NH_FLD_IPV6_ADDR_SIZE;
} else {
flow->qos_real_key_size =
flow->ipaddr_rule.qos_ipsrc_offset +
NH_FLD_IPV6_ADDR_SIZE;
}
}
/* QoS entry added is only effective for multiple TCs.*/
if (priv->num_rx_tc > 1) {
qos_index = flow->tc_id * priv->fs_entries +
flow->tc_index;
if (qos_index >= priv->qos_entries) {
DPAA2_PMD_ERR("QoS table with %d entries full",
priv->qos_entries);
return -1;
}
flow->qos_rule.key_size = FIXED_ENTRY_SIZE;
dpaa2_flow_qos_entry_log("Start add", flow, qos_index);
ret = dpni_add_qos_entry(dpni, CMD_PRI_LOW,
priv->token, &flow->qos_rule,
flow->tc_id, qos_index,
0, 0);
if (ret < 0) {
DPAA2_PMD_ERR(
"Error in adding entry to QoS table(%d)", ret);
return ret;
}
}
if (flow->tc_index >= priv->fs_entries) {
DPAA2_PMD_ERR("FS table with %d entries full",
priv->fs_entries);
return -1;
}
flow->fs_real_key_size =
priv->extract.tc_key_extract[flow->tc_id]
.key_info.key_total_size;
if (flow->ipaddr_rule.ipaddr_type ==
FLOW_IPV4_ADDR) {
if (flow->ipaddr_rule.fs_ipdst_offset >=
flow->ipaddr_rule.fs_ipsrc_offset) {
flow->fs_real_key_size =
flow->ipaddr_rule.fs_ipdst_offset +
NH_FLD_IPV4_ADDR_SIZE;
} else {
flow->fs_real_key_size =
flow->ipaddr_rule.fs_ipsrc_offset +
NH_FLD_IPV4_ADDR_SIZE;
}
} else if (flow->ipaddr_rule.ipaddr_type ==
FLOW_IPV6_ADDR) {
if (flow->ipaddr_rule.fs_ipdst_offset >=
flow->ipaddr_rule.fs_ipsrc_offset) {
flow->fs_real_key_size =
flow->ipaddr_rule.fs_ipdst_offset +
NH_FLD_IPV6_ADDR_SIZE;
} else {
flow->fs_real_key_size =
flow->ipaddr_rule.fs_ipsrc_offset +
NH_FLD_IPV6_ADDR_SIZE;
}
}
flow->fs_rule.key_size = FIXED_ENTRY_SIZE;
dpaa2_flow_fs_entry_log("Start add", flow);
ret = dpni_add_fs_entry(dpni, CMD_PRI_LOW, priv->token,
flow->tc_id, flow->tc_index,
&flow->fs_rule, &action);
if (ret < 0) {
DPAA2_PMD_ERR(
"Error in adding entry to FS table(%d)", ret);
return ret;
}
memcpy(&flow->action_cfg, &action,
sizeof(struct dpni_fs_action_cfg));
break;
case RTE_FLOW_ACTION_TYPE_RSS:
rss_conf = (const struct rte_flow_action_rss *)(actions[j].conf);
flow->action = RTE_FLOW_ACTION_TYPE_RSS;
ret = dpaa2_distset_to_dpkg_profile_cfg(rss_conf->types,
&priv->extract.tc_key_extract[flow->tc_id].dpkg);
if (ret < 0) {
DPAA2_PMD_ERR(
"unable to set flow distribution.please check queue config\n");
return ret;
}
/* Allocate DMA'ble memory to write the rules */
param = (size_t)rte_malloc(NULL, 256, 64);
if (!param) {
DPAA2_PMD_ERR("Memory allocation failure\n");
return -1;
}
if (dpkg_prepare_key_cfg(
&priv->extract.tc_key_extract[flow->tc_id].dpkg,
(uint8_t *)param) < 0) {
DPAA2_PMD_ERR(
"Unable to prepare extract parameters");
rte_free((void *)param);
return -1;
}
memset(&tc_cfg, 0, sizeof(struct dpni_rx_dist_cfg));
tc_cfg.dist_size = rss_conf->queue_num;
tc_cfg.key_cfg_iova = (size_t)param;
tc_cfg.enable = true;
tc_cfg.tc = flow->tc_id;
ret = dpni_set_rx_hash_dist(dpni, CMD_PRI_LOW,
priv->token, &tc_cfg);
if (ret < 0) {
DPAA2_PMD_ERR(
"RSS TC table cannot be configured: %d\n",
ret);
rte_free((void *)param);
return -1;
}
rte_free((void *)param);
if (is_keycfg_configured & DPAA2_QOS_TABLE_RECONFIGURE) {
if (dpkg_prepare_key_cfg(
&priv->extract.qos_key_extract.dpkg,
(uint8_t *)(size_t)priv->extract.qos_extract_param) < 0) {
DPAA2_PMD_ERR(
"Unable to prepare extract parameters");
return -1;
}
memset(&qos_cfg, 0,
sizeof(struct dpni_qos_tbl_cfg));
qos_cfg.discard_on_miss = true;
qos_cfg.keep_entries = true;
qos_cfg.key_cfg_iova =
(size_t)priv->extract.qos_extract_param;
ret = dpni_set_qos_table(dpni, CMD_PRI_LOW,
priv->token, &qos_cfg);
if (ret < 0) {
DPAA2_PMD_ERR(
"RSS QoS dist can't be configured-%d\n",
ret);
return -1;
}
}
/* Add Rule into QoS table */
qos_index = flow->tc_id * priv->fs_entries +
flow->tc_index;
if (qos_index >= priv->qos_entries) {
DPAA2_PMD_ERR("QoS table with %d entries full",
priv->qos_entries);
return -1;
}
flow->qos_real_key_size =
priv->extract.qos_key_extract.key_info.key_total_size;
flow->qos_rule.key_size = FIXED_ENTRY_SIZE;
ret = dpni_add_qos_entry(dpni, CMD_PRI_LOW, priv->token,
&flow->qos_rule, flow->tc_id,
qos_index, 0, 0);
if (ret < 0) {
DPAA2_PMD_ERR(
"Error in entry addition in QoS table(%d)",
ret);
return ret;
}
break;
case RTE_FLOW_ACTION_TYPE_END:
end_of_list = 1;
break;
default:
DPAA2_PMD_ERR("Invalid action type");
ret = -ENOTSUP;
break;
}
j++;
}
if (!ret) {
if (is_keycfg_configured &
(DPAA2_QOS_TABLE_RECONFIGURE |
DPAA2_FS_TABLE_RECONFIGURE)) {
ret = dpaa2_flow_entry_update(priv, flow->tc_id);
if (ret) {
DPAA2_PMD_ERR("Flow entry update failed.");
return -1;
}
}
/* New rules are inserted. */
if (!curr) {
LIST_INSERT_HEAD(&priv->flows, flow, next);
} else {
while (LIST_NEXT(curr, next))
curr = LIST_NEXT(curr, next);
LIST_INSERT_AFTER(curr, flow, next);
}
}
return ret;
}
static inline int
dpaa2_dev_verify_attr(struct dpni_attr *dpni_attr,
const struct rte_flow_attr *attr)
{
int ret = 0;
if (unlikely(attr->group >= dpni_attr->num_rx_tcs)) {
DPAA2_PMD_ERR("Priority group is out of range\n");
ret = -ENOTSUP;
}
if (unlikely(attr->priority >= dpni_attr->fs_entries)) {
DPAA2_PMD_ERR("Priority within the group is out of range\n");
ret = -ENOTSUP;
}
if (unlikely(attr->egress)) {
DPAA2_PMD_ERR(
"Flow configuration is not supported on egress side\n");
ret = -ENOTSUP;
}
if (unlikely(!attr->ingress)) {
DPAA2_PMD_ERR("Ingress flag must be configured\n");
ret = -EINVAL;
}
return ret;
}
static inline int
dpaa2_dev_verify_patterns(const struct rte_flow_item pattern[])
{
unsigned int i, j, is_found = 0;
int ret = 0;
for (j = 0; pattern[j].type != RTE_FLOW_ITEM_TYPE_END; j++) {
for (i = 0; i < RTE_DIM(dpaa2_supported_pattern_type); i++) {
if (dpaa2_supported_pattern_type[i]
== pattern[j].type) {
is_found = 1;
break;
}
}
if (!is_found) {
ret = -ENOTSUP;
break;
}
}
/* Lets verify other combinations of given pattern rules */
for (j = 0; pattern[j].type != RTE_FLOW_ITEM_TYPE_END; j++) {
if (!pattern[j].spec) {
ret = -EINVAL;
break;
}
}
return ret;
}
static inline int
dpaa2_dev_verify_actions(const struct rte_flow_action actions[])
{
unsigned int i, j, is_found = 0;
int ret = 0;
for (j = 0; actions[j].type != RTE_FLOW_ACTION_TYPE_END; j++) {
for (i = 0; i < RTE_DIM(dpaa2_supported_action_type); i++) {
if (dpaa2_supported_action_type[i] == actions[j].type) {
is_found = 1;
break;
}
}
if (!is_found) {
ret = -ENOTSUP;
break;
}
}
for (j = 0; actions[j].type != RTE_FLOW_ACTION_TYPE_END; j++) {
if (actions[j].type != RTE_FLOW_ACTION_TYPE_DROP &&
!actions[j].conf)
ret = -EINVAL;
}
return ret;
}
static
int dpaa2_flow_validate(struct rte_eth_dev *dev,
const struct rte_flow_attr *flow_attr,
const struct rte_flow_item pattern[],
const struct rte_flow_action actions[],
struct rte_flow_error *error)
{
struct dpaa2_dev_priv *priv = dev->data->dev_private;
struct dpni_attr dpni_attr;
struct fsl_mc_io *dpni = (struct fsl_mc_io *)priv->hw;
uint16_t token = priv->token;
int ret = 0;
memset(&dpni_attr, 0, sizeof(struct dpni_attr));
ret = dpni_get_attributes(dpni, CMD_PRI_LOW, token, &dpni_attr);
if (ret < 0) {
DPAA2_PMD_ERR(
"Failure to get dpni@%p attribute, err code %d\n",
dpni, ret);
rte_flow_error_set(error, EPERM,
RTE_FLOW_ERROR_TYPE_ATTR,
flow_attr, "invalid");
return ret;
}
/* Verify input attributes */
ret = dpaa2_dev_verify_attr(&dpni_attr, flow_attr);
if (ret < 0) {
DPAA2_PMD_ERR(
"Invalid attributes are given\n");
rte_flow_error_set(error, EPERM,
RTE_FLOW_ERROR_TYPE_ATTR,
flow_attr, "invalid");
goto not_valid_params;
}
/* Verify input pattern list */
ret = dpaa2_dev_verify_patterns(pattern);
if (ret < 0) {
DPAA2_PMD_ERR(
"Invalid pattern list is given\n");
rte_flow_error_set(error, EPERM,
RTE_FLOW_ERROR_TYPE_ITEM,
pattern, "invalid");
goto not_valid_params;
}
/* Verify input action list */
ret = dpaa2_dev_verify_actions(actions);
if (ret < 0) {
DPAA2_PMD_ERR(
"Invalid action list is given\n");
rte_flow_error_set(error, EPERM,
RTE_FLOW_ERROR_TYPE_ACTION,
actions, "invalid");
goto not_valid_params;
}
not_valid_params:
return ret;
}
static
struct rte_flow *dpaa2_flow_create(struct rte_eth_dev *dev,
const struct rte_flow_attr *attr,
const struct rte_flow_item pattern[],
const struct rte_flow_action actions[],
struct rte_flow_error *error)
{
struct rte_flow *flow = NULL;
size_t key_iova = 0, mask_iova = 0;
int ret;
dpaa2_flow_control_log =
getenv("DPAA2_FLOW_CONTROL_LOG");
if (getenv("DPAA2_FLOW_CONTROL_MISS_FLOW")) {
struct dpaa2_dev_priv *priv = dev->data->dev_private;
dpaa2_flow_miss_flow_id =
atoi(getenv("DPAA2_FLOW_CONTROL_MISS_FLOW"));
if (dpaa2_flow_miss_flow_id >= priv->dist_queues) {
DPAA2_PMD_ERR(
"The missed flow ID %d exceeds the max flow ID %d",
dpaa2_flow_miss_flow_id,
priv->dist_queues - 1);
return NULL;
}
}
flow = rte_zmalloc(NULL, sizeof(struct rte_flow), RTE_CACHE_LINE_SIZE);
if (!flow) {
DPAA2_PMD_ERR("Failure to allocate memory for flow");
goto mem_failure;
}
/* Allocate DMA'ble memory to write the rules */
key_iova = (size_t)rte_zmalloc(NULL, 256, 64);
if (!key_iova) {
DPAA2_PMD_ERR(
"Memory allocation failure for rule configuration\n");
goto mem_failure;
}
mask_iova = (size_t)rte_zmalloc(NULL, 256, 64);
if (!mask_iova) {
DPAA2_PMD_ERR(
"Memory allocation failure for rule configuration\n");
goto mem_failure;
}
flow->qos_rule.key_iova = key_iova;
flow->qos_rule.mask_iova = mask_iova;
/* Allocate DMA'ble memory to write the rules */
key_iova = (size_t)rte_zmalloc(NULL, 256, 64);
if (!key_iova) {
DPAA2_PMD_ERR(
"Memory allocation failure for rule configuration\n");
goto mem_failure;
}
mask_iova = (size_t)rte_zmalloc(NULL, 256, 64);
if (!mask_iova) {
DPAA2_PMD_ERR(
"Memory allocation failure for rule configuration\n");
goto mem_failure;
}
flow->fs_rule.key_iova = key_iova;
flow->fs_rule.mask_iova = mask_iova;
flow->ipaddr_rule.ipaddr_type = FLOW_NONE_IPADDR;
flow->ipaddr_rule.qos_ipsrc_offset =
IP_ADDRESS_OFFSET_INVALID;
flow->ipaddr_rule.qos_ipdst_offset =
IP_ADDRESS_OFFSET_INVALID;
flow->ipaddr_rule.fs_ipsrc_offset =
IP_ADDRESS_OFFSET_INVALID;
flow->ipaddr_rule.fs_ipdst_offset =
IP_ADDRESS_OFFSET_INVALID;
ret = dpaa2_generic_flow_set(flow, dev, attr, pattern,
actions, error);
if (ret < 0) {
if (error && error->type > RTE_FLOW_ERROR_TYPE_ACTION)
rte_flow_error_set(error, EPERM,
RTE_FLOW_ERROR_TYPE_UNSPECIFIED,
attr, "unknown");
DPAA2_PMD_ERR("Failure to create flow, return code (%d)", ret);
goto creation_error;
}
return flow;
mem_failure:
rte_flow_error_set(error, EPERM,
RTE_FLOW_ERROR_TYPE_UNSPECIFIED,
NULL, "memory alloc");
creation_error:
rte_free((void *)flow);
rte_free((void *)key_iova);
rte_free((void *)mask_iova);
return NULL;
}
static
int dpaa2_flow_destroy(struct rte_eth_dev *dev,
struct rte_flow *flow,
struct rte_flow_error *error)
{
int ret = 0;
struct dpaa2_dev_priv *priv = dev->data->dev_private;
struct fsl_mc_io *dpni = (struct fsl_mc_io *)priv->hw;
switch (flow->action) {
case RTE_FLOW_ACTION_TYPE_QUEUE:
case RTE_FLOW_ACTION_TYPE_PHY_PORT:
case RTE_FLOW_ACTION_TYPE_PORT_ID:
if (priv->num_rx_tc > 1) {
/* Remove entry from QoS table first */
ret = dpni_remove_qos_entry(dpni, CMD_PRI_LOW, priv->token,
&flow->qos_rule);
if (ret < 0) {
DPAA2_PMD_ERR(
"Error in removing entry from QoS table(%d)", ret);
goto error;
}
}
/* Then remove entry from FS table */
ret = dpni_remove_fs_entry(dpni, CMD_PRI_LOW, priv->token,
flow->tc_id, &flow->fs_rule);
if (ret < 0) {
DPAA2_PMD_ERR(
"Error in removing entry from FS table(%d)", ret);
goto error;
}
break;
case RTE_FLOW_ACTION_TYPE_RSS:
if (priv->num_rx_tc > 1) {
ret = dpni_remove_qos_entry(dpni, CMD_PRI_LOW, priv->token,
&flow->qos_rule);
if (ret < 0) {
DPAA2_PMD_ERR(
"Error in entry addition in QoS table(%d)", ret);
goto error;
}
}
break;
default:
DPAA2_PMD_ERR(
"Action type (%d) is not supported", flow->action);
ret = -ENOTSUP;
break;
}
LIST_REMOVE(flow, next);
rte_free((void *)(size_t)flow->qos_rule.key_iova);
rte_free((void *)(size_t)flow->qos_rule.mask_iova);
rte_free((void *)(size_t)flow->fs_rule.key_iova);
rte_free((void *)(size_t)flow->fs_rule.mask_iova);
/* Now free the flow */
rte_free(flow);
error:
if (ret)
rte_flow_error_set(error, EPERM,
RTE_FLOW_ERROR_TYPE_UNSPECIFIED,
NULL, "unknown");
return ret;
}
/**
* Destroy user-configured flow rules.
*
* This function skips internal flows rules.
*
* @see rte_flow_flush()
* @see rte_flow_ops
*/
static int
dpaa2_flow_flush(struct rte_eth_dev *dev,
struct rte_flow_error *error)
{
struct dpaa2_dev_priv *priv = dev->data->dev_private;
struct rte_flow *flow = LIST_FIRST(&priv->flows);
while (flow) {
struct rte_flow *next = LIST_NEXT(flow, next);
dpaa2_flow_destroy(dev, flow, error);
flow = next;
}
return 0;
}
static int
dpaa2_flow_query(struct rte_eth_dev *dev __rte_unused,
struct rte_flow *flow __rte_unused,
const struct rte_flow_action *actions __rte_unused,
void *data __rte_unused,
struct rte_flow_error *error __rte_unused)
{
return 0;
}
/**
* Clean up all flow rules.
*
* Unlike dpaa2_flow_flush(), this function takes care of all remaining flow
* rules regardless of whether they are internal or user-configured.
*
* @param priv
* Pointer to private structure.
*/
void
dpaa2_flow_clean(struct rte_eth_dev *dev)
{
struct rte_flow *flow;
struct dpaa2_dev_priv *priv = dev->data->dev_private;
while ((flow = LIST_FIRST(&priv->flows)))
dpaa2_flow_destroy(dev, flow, NULL);
}
const struct rte_flow_ops dpaa2_flow_ops = {
.create = dpaa2_flow_create,
.validate = dpaa2_flow_validate,
.destroy = dpaa2_flow_destroy,
.flush = dpaa2_flow_flush,
.query = dpaa2_flow_query,
};
Reference in New Issue View Git Blame Copy Permalink