d/numam-dpdk
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
df4867cd70
numam-dpdk/drivers/net/hinic/hinic_pmd_flow.c
Xiaoyun Wang 1742421b9e net/hinic: flush flow director filter 
Supports to flush fdir filter.
Destroy all flow rules associated with a port on hinic.

Signed-off-by: Xiaoyun Wang <cloud.wangxiaoyun@huawei.com>
2019-10-23 16:43:08 +02:00

2386 lines
66 KiB
C
Raw Blame History

/* SPDX-License-Identifier: BSD-3-Clause
* Copyright(c) 2017 Huawei Technologies Co., Ltd
*/
#include <stdio.h>
#include <errno.h>
#include <stdint.h>
#include <string.h>
#include <unistd.h>
#include <rte_byteorder.h>
#include <rte_common.h>
#include <rte_ether.h>
#include <rte_ethdev.h>
#include <rte_malloc.h>
#include <rte_flow.h>
#include <rte_flow_driver.h>
#include "base/hinic_compat.h"
#include "base/hinic_pmd_hwdev.h"
#include "base/hinic_pmd_hwif.h"
#include "base/hinic_pmd_wq.h"
#include "base/hinic_pmd_cmdq.h"
#include "base/hinic_pmd_niccfg.h"
#include "hinic_pmd_ethdev.h"
#define HINIC_MAX_RX_QUEUE_NUM 64
#ifndef UINT8_MAX
#define UINT8_MAX (u8)(~((u8)0)) /* 0xFF */
#define UINT16_MAX (u16)(~((u16)0)) /* 0xFFFF */
#define UINT32_MAX (u32)(~((u32)0)) /* 0xFFFFFFFF */
#define UINT64_MAX (u64)(~((u64)0)) /* 0xFFFFFFFFFFFFFFFF */
#define ASCII_MAX (0x7F)
#endif
/* IPSURX MACRO */
#define PA_ETH_TYPE_ROCE 0
#define PA_ETH_TYPE_IPV4 1
#define PA_ETH_TYPE_IPV6 2
#define PA_ETH_TYPE_OTHER 3
#define PA_IP_PROTOCOL_TYPE_TCP 1
#define PA_IP_PROTOCOL_TYPE_UDP 2
#define PA_IP_PROTOCOL_TYPE_ICMP 3
#define PA_IP_PROTOCOL_TYPE_IPV4_IGMP 4
#define PA_IP_PROTOCOL_TYPE_SCTP 5
#define PA_IP_PROTOCOL_TYPE_VRRP 112
#define IP_HEADER_PROTOCOL_TYPE_TCP 6
#define HINIC_MIN_N_TUPLE_PRIO 1
#define HINIC_MAX_N_TUPLE_PRIO 7
/* TCAM type mask in hardware */
#define TCAM_PKT_BGP_SPORT 1
#define TCAM_PKT_VRRP 2
#define TCAM_PKT_BGP_DPORT 3
#define TCAM_PKT_LACP 4
#define BGP_DPORT_ID 179
#define IPPROTO_VRRP 112
/* Packet type defined in hardware to perform filter */
#define PKT_IGMP_IPV4_TYPE 64
#define PKT_ICMP_IPV4_TYPE 65
#define PKT_ICMP_IPV6_TYPE 66
#define PKT_ICMP_IPV6RS_TYPE 67
#define PKT_ICMP_IPV6RA_TYPE 68
#define PKT_ICMP_IPV6NS_TYPE 69
#define PKT_ICMP_IPV6NA_TYPE 70
#define PKT_ICMP_IPV6RE_TYPE 71
#define PKT_DHCP_IPV4_TYPE 72
#define PKT_DHCP_IPV6_TYPE 73
#define PKT_LACP_TYPE 74
#define PKT_ARP_REQ_TYPE 79
#define PKT_ARP_REP_TYPE 80
#define PKT_ARP_TYPE 81
#define PKT_BGPD_DPORT_TYPE 83
#define PKT_BGPD_SPORT_TYPE 84
#define PKT_VRRP_TYPE 85
#define HINIC_DEV_PRIVATE_TO_FILTER_INFO(nic_dev) \
(&((struct hinic_nic_dev *)nic_dev)->filter)
enum hinic_atr_flow_type {
HINIC_ATR_FLOW_TYPE_IPV4_DIP = 0x1,
HINIC_ATR_FLOW_TYPE_IPV4_SIP = 0x2,
HINIC_ATR_FLOW_TYPE_DPORT = 0x3,
HINIC_ATR_FLOW_TYPE_SPORT = 0x4,
};
/* Structure to store fdir's info. */
struct hinic_fdir_info {
uint8_t fdir_flag;
uint8_t qid;
uint32_t fdir_key;
};
/**
* Endless loop will never happen with below assumption
* 1. there is at least one no-void item(END)
* 2. cur is before END.
*/
static inline const struct rte_flow_item *
next_no_void_pattern(const struct rte_flow_item pattern[],
const struct rte_flow_item *cur)
{
const struct rte_flow_item *next =
cur ? cur + 1 : &pattern[0];
while (1) {
if (next->type != RTE_FLOW_ITEM_TYPE_VOID)
return next;
next++;
}
}
static inline const struct rte_flow_action *
next_no_void_action(const struct rte_flow_action actions[],
const struct rte_flow_action *cur)
{
const struct rte_flow_action *next =
cur ? cur + 1 : &actions[0];
while (1) {
if (next->type != RTE_FLOW_ACTION_TYPE_VOID)
return next;
next++;
}
}
static int hinic_check_ethertype_attr_ele(const struct rte_flow_attr *attr,
struct rte_flow_error *error)
{
/* Must be input direction */
if (!attr->ingress) {
rte_flow_error_set(error, EINVAL,
RTE_FLOW_ERROR_TYPE_ATTR_INGRESS,
attr, "Only support ingress.");
return -rte_errno;
}
if (attr->egress) {
rte_flow_error_set(error, EINVAL,
RTE_FLOW_ERROR_TYPE_ATTR_EGRESS,
attr, "Not support egress.");
return -rte_errno;
}
if (attr->priority) {
rte_flow_error_set(error, EINVAL,
RTE_FLOW_ERROR_TYPE_ATTR_PRIORITY,
attr, "Not support priority.");
return -rte_errno;
}
if (attr->group) {
rte_flow_error_set(error, EINVAL,
RTE_FLOW_ERROR_TYPE_ATTR_GROUP,
attr, "Not support group.");
return -rte_errno;
}
return 0;
}
static int hinic_check_filter_arg(const struct rte_flow_attr *attr,
const struct rte_flow_item *pattern,
const struct rte_flow_action *actions,
struct rte_flow_error *error)
{
if (!pattern) {
rte_flow_error_set(error, EINVAL, RTE_FLOW_ERROR_TYPE_ITEM_NUM,
NULL, "NULL pattern.");
return -rte_errno;
}
if (!actions) {
rte_flow_error_set(error, EINVAL,
RTE_FLOW_ERROR_TYPE_ACTION_NUM,
NULL, "NULL action.");
return -rte_errno;
}
if (!attr) {
rte_flow_error_set(error, EINVAL, RTE_FLOW_ERROR_TYPE_ATTR,
NULL, "NULL attribute.");
return -rte_errno;
}
return 0;
}
static int hinic_check_ethertype_first_item(const struct rte_flow_item *item,
struct rte_flow_error *error)
{
/* The first non-void item should be MAC */
if (item->type != RTE_FLOW_ITEM_TYPE_ETH) {
rte_flow_error_set(error, EINVAL,
RTE_FLOW_ERROR_TYPE_ITEM,
item, "Not supported by ethertype filter");
return -rte_errno;
}
/* Not supported last point for range */
if (item->last) {
rte_flow_error_set(error, EINVAL,
RTE_FLOW_ERROR_TYPE_UNSPECIFIED,
item, "Not supported last point for range");
return -rte_errno;
}
/* Get the MAC info. */
if (!item->spec || !item->mask) {
rte_flow_error_set(error, EINVAL,
RTE_FLOW_ERROR_TYPE_ITEM,
item, "Not supported by ethertype filter");
return -rte_errno;
}
return 0;
}
static int
hinic_parse_ethertype_aciton(const struct rte_flow_action *actions,
const struct rte_flow_action *act,
const struct rte_flow_action_queue *act_q,
struct rte_eth_ethertype_filter *filter,
struct rte_flow_error *error)
{
/* Parse action */
act = next_no_void_action(actions, NULL);
if (act->type != RTE_FLOW_ACTION_TYPE_QUEUE &&
act->type != RTE_FLOW_ACTION_TYPE_DROP) {
rte_flow_error_set(error, EINVAL,
RTE_FLOW_ERROR_TYPE_ACTION,
act, "Not supported action.");
return -rte_errno;
}
if (act->type == RTE_FLOW_ACTION_TYPE_QUEUE) {
act_q = (const struct rte_flow_action_queue *)act->conf;
filter->queue = act_q->index;
} else {
filter->flags |= RTE_ETHTYPE_FLAGS_DROP;
}
/* Check if the next non-void item is END */
act = next_no_void_action(actions, act);
if (act->type != RTE_FLOW_ACTION_TYPE_END) {
rte_flow_error_set(error, EINVAL,
RTE_FLOW_ERROR_TYPE_ACTION,
act, "Not supported action.");
return -rte_errno;
}
return 0;
}
/**
* Parse the rule to see if it is a ethertype rule.
* And get the ethertype filter info BTW.
* pattern:
* The first not void item can be ETH.
* The next not void item must be END.
* action:
* The first not void action should be QUEUE.
* The next not void action should be END.
* pattern example:
* ITEM Spec Mask
* ETH type 0x0807 0xFFFF
* END
* other members in mask and spec should set to 0x00.
* item->last should be NULL.
*/
static int
cons_parse_ethertype_filter(const struct rte_flow_attr *attr,
const struct rte_flow_item *pattern,
const struct rte_flow_action *actions,
struct rte_eth_ethertype_filter *filter,
struct rte_flow_error *error)
{
const struct rte_flow_item *item;
const struct rte_flow_action *act = NULL;
const struct rte_flow_item_eth *eth_spec;
const struct rte_flow_item_eth *eth_mask;
const struct rte_flow_action_queue *act_q = NULL;
if (hinic_check_filter_arg(attr, pattern, actions, error))
return -rte_errno;
item = next_no_void_pattern(pattern, NULL);
if (hinic_check_ethertype_first_item(item, error))
return -rte_errno;
eth_spec = (const struct rte_flow_item_eth *)item->spec;
eth_mask = (const struct rte_flow_item_eth *)item->mask;
/*
* Mask bits of source MAC address must be full of 0.
* Mask bits of destination MAC address must be full
* of 1 or full of 0.
*/
if (!rte_is_zero_ether_addr(&eth_mask->src) ||
(!rte_is_zero_ether_addr(&eth_mask->dst) &&
!rte_is_broadcast_ether_addr(&eth_mask->dst))) {
rte_flow_error_set(error, EINVAL, RTE_FLOW_ERROR_TYPE_ITEM,
item, "Invalid ether address mask");
return -rte_errno;
}
if ((eth_mask->type & UINT16_MAX) != UINT16_MAX) {
rte_flow_error_set(error, EINVAL, RTE_FLOW_ERROR_TYPE_ITEM,
item, "Invalid ethertype mask");
return -rte_errno;
}
/*
* If mask bits of destination MAC address
* are full of 1, set RTE_ETHTYPE_FLAGS_MAC.
*/
if (rte_is_broadcast_ether_addr(&eth_mask->dst)) {
filter->mac_addr = eth_spec->dst;
filter->flags |= RTE_ETHTYPE_FLAGS_MAC;
} else {
filter->flags &= ~RTE_ETHTYPE_FLAGS_MAC;
}
filter->ether_type = rte_be_to_cpu_16(eth_spec->type);
/* Check if the next non-void item is END. */
item = next_no_void_pattern(pattern, item);
if (item->type != RTE_FLOW_ITEM_TYPE_END) {
rte_flow_error_set(error, EINVAL, RTE_FLOW_ERROR_TYPE_ITEM,
item, "Not supported by ethertype filter.");
return -rte_errno;
}
if (hinic_parse_ethertype_aciton(actions, act, act_q, filter, error))
return -rte_errno;
if (hinic_check_ethertype_attr_ele(attr, error))
return -rte_errno;
return 0;
}
static int
hinic_parse_ethertype_filter(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_eth_ethertype_filter *filter,
struct rte_flow_error *error)
{
if (cons_parse_ethertype_filter(attr, pattern, actions, filter, error))
return -rte_errno;
/* NIC doesn't support MAC address. */
if (filter->flags & RTE_ETHTYPE_FLAGS_MAC) {
memset(filter, 0, sizeof(struct rte_eth_ethertype_filter));
rte_flow_error_set(error, EINVAL,
RTE_FLOW_ERROR_TYPE_ITEM,
NULL, "Not supported by ethertype filter");
return -rte_errno;
}
if (filter->queue >= dev->data->nb_rx_queues) {
memset(filter, 0, sizeof(struct rte_eth_ethertype_filter));
rte_flow_error_set(error, EINVAL,
RTE_FLOW_ERROR_TYPE_ITEM,
NULL, "Queue index much too big");
return -rte_errno;
}
if (filter->ether_type == RTE_ETHER_TYPE_IPV4 ||
filter->ether_type == RTE_ETHER_TYPE_IPV6) {
memset(filter, 0, sizeof(struct rte_eth_ethertype_filter));
rte_flow_error_set(error, EINVAL,
RTE_FLOW_ERROR_TYPE_ITEM,
NULL, "IPv4/IPv6 not supported by ethertype filter");
return -rte_errno;
}
if (filter->flags & RTE_ETHTYPE_FLAGS_DROP) {
memset(filter, 0, sizeof(struct rte_eth_ethertype_filter));
rte_flow_error_set(error, EINVAL,
RTE_FLOW_ERROR_TYPE_ITEM,
NULL, "Drop option is unsupported");
return -rte_errno;
}
/* Hinic only support LACP/ARP for ether type */
if (filter->ether_type != RTE_ETHER_TYPE_SLOW &&
filter->ether_type != RTE_ETHER_TYPE_ARP) {
memset(filter, 0, sizeof(struct rte_eth_ethertype_filter));
rte_flow_error_set(error, EINVAL,
RTE_FLOW_ERROR_TYPE_ITEM, NULL,
"only lacp/arp type supported by ethertype filter");
return -rte_errno;
}
return 0;
}
static int hinic_check_ntuple_attr_ele(const struct rte_flow_attr *attr,
struct rte_eth_ntuple_filter *filter,
struct rte_flow_error *error)
{
/* Must be input direction */
if (!attr->ingress) {
memset(filter, 0, sizeof(struct rte_eth_ntuple_filter));
rte_flow_error_set(error, EINVAL,
RTE_FLOW_ERROR_TYPE_ATTR_INGRESS,
attr, "Only support ingress.");
return -rte_errno;
}
if (attr->egress) {
memset(filter, 0, sizeof(struct rte_eth_ntuple_filter));
rte_flow_error_set(error, EINVAL,
RTE_FLOW_ERROR_TYPE_ATTR_EGRESS,
attr, "Not support egress.");
return -rte_errno;
}
if (attr->priority > 0xFFFF) {
memset(filter, 0, sizeof(struct rte_eth_ntuple_filter));
rte_flow_error_set(error, EINVAL,
RTE_FLOW_ERROR_TYPE_ATTR_PRIORITY,
attr, "Error priority.");
return -rte_errno;
}
if (attr->priority < HINIC_MIN_N_TUPLE_PRIO ||
attr->priority > HINIC_MAX_N_TUPLE_PRIO)
filter->priority = 1;
else
filter->priority = (uint16_t)attr->priority;
return 0;
}
static int
hinic_check_ntuple_act_ele(__rte_unused const struct rte_flow_item *item,
const struct rte_flow_action actions[],
struct rte_eth_ntuple_filter *filter,
struct rte_flow_error *error)
{
const struct rte_flow_action *act;
/*
* n-tuple only supports forwarding,
* check if the first not void action is QUEUE.
*/
act = next_no_void_action(actions, NULL);
if (act->type != RTE_FLOW_ACTION_TYPE_QUEUE) {
memset(filter, 0, sizeof(struct rte_eth_ntuple_filter));
rte_flow_error_set(error, EINVAL,
RTE_FLOW_ERROR_TYPE_ACTION,
act, "Flow action type is not QUEUE.");
return -rte_errno;
}
filter->queue =
((const struct rte_flow_action_queue *)act->conf)->index;
/* Check if the next not void item is END */
act = next_no_void_action(actions, act);
if (act->type != RTE_FLOW_ACTION_TYPE_END) {
memset(filter, 0, sizeof(struct rte_eth_ntuple_filter));
rte_flow_error_set(error, EINVAL,
RTE_FLOW_ERROR_TYPE_ACTION,
act, "Next not void item is not END.");
return -rte_errno;
}
return 0;
}
static int hinic_ntuple_item_check_ether(const struct rte_flow_item **ipv4_item,
const struct rte_flow_item pattern[],
struct rte_flow_error *error)
{
const struct rte_flow_item *item;
/* The first not void item can be MAC or IPv4 */
item = next_no_void_pattern(pattern, NULL);
if (item->type != RTE_FLOW_ITEM_TYPE_ETH &&
item->type != RTE_FLOW_ITEM_TYPE_IPV4) {
rte_flow_error_set(error, EINVAL,
RTE_FLOW_ERROR_TYPE_ITEM,
item, "Not supported by ntuple filter");
return -rte_errno;
}
/* Skip Ethernet */
if (item->type == RTE_FLOW_ITEM_TYPE_ETH) {
/* Not supported last point for range */
if (item->last) {
rte_flow_error_set(error,
EINVAL,
RTE_FLOW_ERROR_TYPE_UNSPECIFIED,
item, "Not supported last point for range");
return -rte_errno;
}
/* if the first item is MAC, the content should be NULL */
if (item->spec || item->mask) {
rte_flow_error_set(error, EINVAL,
RTE_FLOW_ERROR_TYPE_ITEM,
item, "Not supported by ntuple filter");
return -rte_errno;
}
/* check if the next not void item is IPv4 */
item = next_no_void_pattern(pattern, item);
if (item->type != RTE_FLOW_ITEM_TYPE_IPV4) {
rte_flow_error_set(error,
EINVAL, RTE_FLOW_ERROR_TYPE_ITEM,
item, "Not supported by ntuple filter");
return -rte_errno;
}
}
*ipv4_item = item;
return 0;
}
static int
hinic_ntuple_item_check_ipv4(const struct rte_flow_item **in_out_item,
const struct rte_flow_item pattern[],
struct rte_eth_ntuple_filter *filter,
struct rte_flow_error *error)
{
const struct rte_flow_item_ipv4 *ipv4_spec;
const struct rte_flow_item_ipv4 *ipv4_mask;
const struct rte_flow_item *item = *in_out_item;
/* Get the IPv4 info */
if (!item->spec || !item->mask) {
rte_flow_error_set(error, EINVAL,
RTE_FLOW_ERROR_TYPE_ITEM,
item, "Invalid ntuple mask");
return -rte_errno;
}
/* Not supported last point for range */
if (item->last) {
rte_flow_error_set(error, EINVAL,
RTE_FLOW_ERROR_TYPE_UNSPECIFIED,
item, "Not supported last point for range");
return -rte_errno;
}
ipv4_mask = (const struct rte_flow_item_ipv4 *)item->mask;
/*
* Only support src & dst addresses, protocol,
* others should be masked.
*/
if (ipv4_mask->hdr.version_ihl ||
ipv4_mask->hdr.type_of_service ||
ipv4_mask->hdr.total_length ||
ipv4_mask->hdr.packet_id ||
ipv4_mask->hdr.fragment_offset ||
ipv4_mask->hdr.time_to_live ||
ipv4_mask->hdr.hdr_checksum ||
!ipv4_mask->hdr.next_proto_id) {
rte_flow_error_set(error,
EINVAL, RTE_FLOW_ERROR_TYPE_ITEM,
item, "Not supported by ntuple filter");
return -rte_errno;
}
filter->dst_ip_mask = ipv4_mask->hdr.dst_addr;
filter->src_ip_mask = ipv4_mask->hdr.src_addr;
filter->proto_mask = ipv4_mask->hdr.next_proto_id;
ipv4_spec = (const struct rte_flow_item_ipv4 *)item->spec;
filter->dst_ip = ipv4_spec->hdr.dst_addr;
filter->src_ip = ipv4_spec->hdr.src_addr;
filter->proto = ipv4_spec->hdr.next_proto_id;
/* Get next no void item */
*in_out_item = next_no_void_pattern(pattern, item);
return 0;
}
static int hinic_ntuple_item_check_l4(const struct rte_flow_item **in_out_item,
const struct rte_flow_item pattern[],
struct rte_eth_ntuple_filter *filter,
struct rte_flow_error *error)
{
const struct rte_flow_item_tcp *tcp_spec;
const struct rte_flow_item_tcp *tcp_mask;
const struct rte_flow_item_icmp *icmp_mask;
const struct rte_flow_item *item = *in_out_item;
u32 ntuple_filter_size = sizeof(struct rte_eth_ntuple_filter);
if (item->type == RTE_FLOW_ITEM_TYPE_END)
return 0;
/* Get TCP or UDP info */
if (item->type != RTE_FLOW_ITEM_TYPE_END &&
(!item->spec || !item->mask)) {
memset(filter, 0, ntuple_filter_size);
rte_flow_error_set(error, EINVAL,
RTE_FLOW_ERROR_TYPE_ITEM,
item, "Invalid ntuple mask");
return -rte_errno;
}
/* Not supported last point for range */
if (item->last) {
memset(filter, 0, ntuple_filter_size);
rte_flow_error_set(error, EINVAL,
RTE_FLOW_ERROR_TYPE_UNSPECIFIED,
item, "Not supported last point for range");
return -rte_errno;
}
if (item->type == RTE_FLOW_ITEM_TYPE_TCP) {
tcp_mask = (const struct rte_flow_item_tcp *)item->mask;
/*
* Only support src & dst ports, tcp flags,
* others should be masked.
*/
if (tcp_mask->hdr.sent_seq ||
tcp_mask->hdr.recv_ack ||
tcp_mask->hdr.data_off ||
tcp_mask->hdr.rx_win ||
tcp_mask->hdr.cksum ||
tcp_mask->hdr.tcp_urp) {
memset(filter, 0, ntuple_filter_size);
rte_flow_error_set(error, EINVAL,
RTE_FLOW_ERROR_TYPE_ITEM,
item, "Not supported by ntuple filter");
return -rte_errno;
}
filter->dst_port_mask = tcp_mask->hdr.dst_port;
filter->src_port_mask = tcp_mask->hdr.src_port;
if (tcp_mask->hdr.tcp_flags == 0xFF) {
filter->flags |= RTE_NTUPLE_FLAGS_TCP_FLAG;
} else if (!tcp_mask->hdr.tcp_flags) {
filter->flags &= ~RTE_NTUPLE_FLAGS_TCP_FLAG;
} else {
memset(filter, 0, ntuple_filter_size);
rte_flow_error_set(error, EINVAL,
RTE_FLOW_ERROR_TYPE_ITEM,
item, "Not supported by ntuple filter");
return -rte_errno;
}
tcp_spec = (const struct rte_flow_item_tcp *)item->spec;
filter->dst_port = tcp_spec->hdr.dst_port;
filter->src_port = tcp_spec->hdr.src_port;
filter->tcp_flags = tcp_spec->hdr.tcp_flags;
} else if (item->type == RTE_FLOW_ITEM_TYPE_ICMP) {
icmp_mask = (const struct rte_flow_item_icmp *)item->mask;
/* ICMP all should be masked. */
if (icmp_mask->hdr.icmp_cksum ||
icmp_mask->hdr.icmp_ident ||
icmp_mask->hdr.icmp_seq_nb ||
icmp_mask->hdr.icmp_type ||
icmp_mask->hdr.icmp_code) {
memset(filter, 0, ntuple_filter_size);
rte_flow_error_set(error, EINVAL,
RTE_FLOW_ERROR_TYPE_ITEM,
item, "Not supported by ntuple filter");
return -rte_errno;
}
}
/* Get next no void item */
*in_out_item = next_no_void_pattern(pattern, item);
return 0;
}
static int hinic_ntuple_item_check_end(const struct rte_flow_item *item,
struct rte_eth_ntuple_filter *filter,
struct rte_flow_error *error)
{
/* Check if the next not void item is END */
if (item->type != RTE_FLOW_ITEM_TYPE_END) {
memset(filter, 0, sizeof(struct rte_eth_ntuple_filter));
rte_flow_error_set(error, EINVAL,
RTE_FLOW_ERROR_TYPE_ITEM,
item, "Not supported by ntuple filter");
return -rte_errno;
}
return 0;
}
static int hinic_check_ntuple_item_ele(const struct rte_flow_item *item,
const struct rte_flow_item pattern[],
struct rte_eth_ntuple_filter *filter,
struct rte_flow_error *error)
{
if (hinic_ntuple_item_check_ether(&item, pattern, error) ||
hinic_ntuple_item_check_ipv4(&item, pattern, filter, error) ||
hinic_ntuple_item_check_l4(&item, pattern, filter, error) ||
hinic_ntuple_item_check_end(item, filter, error))
return -rte_errno;
return 0;
}
/**
* Parse the rule to see if it is a n-tuple rule.
* And get the n-tuple filter info BTW.
* pattern:
* The first not void item can be ETH or IPV4.
* The second not void item must be IPV4 if the first one is ETH.
* The third not void item must be UDP or TCP.
* The next not void item must be END.
* action:
* The first not void action should be QUEUE.
* The next not void action should be END.
* pattern example:
* ITEM Spec Mask
* ETH NULL NULL
* IPV4 src_addr 192.168.1.20 0xFFFFFFFF
* dst_addr 192.167.3.50 0xFFFFFFFF
* next_proto_id 17 0xFF
* UDP/TCP/ src_port 80 0xFFFF
* SCTP dst_port 80 0xFFFF
* END
* other members in mask and spec should set to 0x00.
* item->last should be NULL.
* Please aware there's an asumption for all the parsers.
* rte_flow_item is using big endian, rte_flow_attr and
* rte_flow_action are using CPU order.
* Because the pattern is used to describe the packets,
* normally the packets should use network order.
*/
static int
cons_parse_ntuple_filter(const struct rte_flow_attr *attr,
const struct rte_flow_item pattern[],
const struct rte_flow_action actions[],
struct rte_eth_ntuple_filter *filter,
struct rte_flow_error *error)
{
const struct rte_flow_item *item = NULL;
if (hinic_check_filter_arg(attr, pattern, actions, error))
return -rte_errno;
if (hinic_check_ntuple_item_ele(item, pattern, filter, error))
return -rte_errno;
if (hinic_check_ntuple_act_ele(item, actions, filter, error))
return -rte_errno;
if (hinic_check_ntuple_attr_ele(attr, filter, error))
return -rte_errno;
return 0;
}
static int
hinic_parse_ntuple_filter(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_eth_ntuple_filter *filter,
struct rte_flow_error *error)
{
int ret;
ret = cons_parse_ntuple_filter(attr, pattern, actions, filter, error);
if (ret)
return ret;
/* Hinic doesn't support tcp flags */
if (filter->flags & RTE_NTUPLE_FLAGS_TCP_FLAG) {
memset(filter, 0, sizeof(struct rte_eth_ntuple_filter));
rte_flow_error_set(error, EINVAL,
RTE_FLOW_ERROR_TYPE_ITEM,
NULL, "Not supported by ntuple filter");
return -rte_errno;
}
/* Hinic doesn't support many priorities */
if (filter->priority < HINIC_MIN_N_TUPLE_PRIO ||
filter->priority > HINIC_MAX_N_TUPLE_PRIO) {
memset(filter, 0, sizeof(struct rte_eth_ntuple_filter));
rte_flow_error_set(error, EINVAL,
RTE_FLOW_ERROR_TYPE_ITEM,
NULL, "Priority not supported by ntuple filter");
return -rte_errno;
}
if (filter->queue >= dev->data->nb_rx_queues)
return -rte_errno;
/* Fixed value for hinic */
filter->flags = RTE_5TUPLE_FLAGS;
return 0;
}
static int hinic_normal_item_check_ether(const struct rte_flow_item **ip_item,
const struct rte_flow_item pattern[],
struct rte_flow_error *error)
{
const struct rte_flow_item *item;
/* The first not void item can be MAC or IPv4 or TCP or UDP */
item = next_no_void_pattern(pattern, NULL);
if (item->type != RTE_FLOW_ITEM_TYPE_ETH &&
item->type != RTE_FLOW_ITEM_TYPE_IPV4 &&
item->type != RTE_FLOW_ITEM_TYPE_TCP &&
item->type != RTE_FLOW_ITEM_TYPE_UDP) {
rte_flow_error_set(error, EINVAL,
RTE_FLOW_ERROR_TYPE_ITEM, item,
"Not supported by fdir filter,support mac,ipv4,tcp,udp");
return -rte_errno;
}
/* Not supported last point for range */
if (item->last) {
rte_flow_error_set(error, EINVAL,
RTE_FLOW_ERROR_TYPE_UNSPECIFIED, item,
"Not supported last point for range");
return -rte_errno;
}
/* Skip Ethernet */
if (item->type == RTE_FLOW_ITEM_TYPE_ETH) {
/* All should be masked. */
if (item->spec || item->mask) {
rte_flow_error_set(error, EINVAL,
RTE_FLOW_ERROR_TYPE_ITEM,
item, "Not supported by fdir filter,support mac");
return -rte_errno;
}
/* Check if the next not void item is IPv4 */
item = next_no_void_pattern(pattern, item);
if (item->type != RTE_FLOW_ITEM_TYPE_IPV4) {
rte_flow_error_set(error, EINVAL,
RTE_FLOW_ERROR_TYPE_ITEM, item,
"Not supported by fdir filter,support mac,ipv4");
return -rte_errno;
}
}
*ip_item = item;
return 0;
}
static int hinic_normal_item_check_ip(const struct rte_flow_item **in_out_item,
const struct rte_flow_item pattern[],
struct hinic_fdir_rule *rule,
struct rte_flow_error *error)
{
const struct rte_flow_item_ipv4 *ipv4_spec;
const struct rte_flow_item_ipv4 *ipv4_mask;
const struct rte_flow_item *item = *in_out_item;
/* Get the IPv4 info */
if (item->type == RTE_FLOW_ITEM_TYPE_IPV4) {
/* Not supported last point for range */
if (item->last) {
rte_flow_error_set(error, EINVAL,
RTE_FLOW_ERROR_TYPE_UNSPECIFIED,
item, "Not supported last point for range");
return -rte_errno;
}
if (!item->mask) {
memset(rule, 0, sizeof(struct hinic_fdir_rule));
rte_flow_error_set(error, EINVAL,
RTE_FLOW_ERROR_TYPE_ITEM,
item, "Invalid fdir filter mask");
return -rte_errno;
}
ipv4_mask = (const struct rte_flow_item_ipv4 *)item->mask;
/*
* Only support src & dst addresses,
* others should be masked.
*/
if (ipv4_mask->hdr.version_ihl ||
ipv4_mask->hdr.type_of_service ||
ipv4_mask->hdr.total_length ||
ipv4_mask->hdr.packet_id ||
ipv4_mask->hdr.fragment_offset ||
ipv4_mask->hdr.time_to_live ||
ipv4_mask->hdr.next_proto_id ||
ipv4_mask->hdr.hdr_checksum) {
rte_flow_error_set(error,
EINVAL, RTE_FLOW_ERROR_TYPE_ITEM, item,
"Not supported by fdir filter, support src,dst ip");
return -rte_errno;
}
rule->mask.dst_ipv4_mask = ipv4_mask->hdr.dst_addr;
rule->mask.src_ipv4_mask = ipv4_mask->hdr.src_addr;
if (item->spec) {
ipv4_spec =
(const struct rte_flow_item_ipv4 *)item->spec;
rule->hinic_fdir.dst_ip = ipv4_spec->hdr.dst_addr;
rule->hinic_fdir.src_ip = ipv4_spec->hdr.src_addr;
}
/*
* Check if the next not void item is
* TCP or UDP or END.
*/
item = next_no_void_pattern(pattern, item);
if (item->type != RTE_FLOW_ITEM_TYPE_TCP &&
item->type != RTE_FLOW_ITEM_TYPE_UDP &&
item->type != RTE_FLOW_ITEM_TYPE_END) {
memset(rule, 0, sizeof(struct hinic_fdir_rule));
rte_flow_error_set(error, EINVAL,
RTE_FLOW_ERROR_TYPE_ITEM, item,
"Not supported by fdir filter, support tcp, udp, end");
return -rte_errno;
}
}
*in_out_item = item;
return 0;
}
static int hinic_normal_item_check_l4(const struct rte_flow_item **in_out_item,
const struct rte_flow_item pattern[],
struct hinic_fdir_rule *rule,
struct rte_flow_error *error)
{
const struct rte_flow_item_tcp *tcp_spec;
const struct rte_flow_item_tcp *tcp_mask;
const struct rte_flow_item_udp *udp_spec;
const struct rte_flow_item_udp *udp_mask;
const struct rte_flow_item *item = *in_out_item;
if (item->type != RTE_FLOW_ITEM_TYPE_END) {
/* Not supported last point for range */
if (item->last) {
rte_flow_error_set(error, EINVAL,
RTE_FLOW_ERROR_TYPE_UNSPECIFIED,
item, "Not supported last point for range");
return -rte_errno;
}
/* Get TCP/UDP info */
if (item->type == RTE_FLOW_ITEM_TYPE_TCP) {
/*
* Only care about src & dst ports,
* others should be masked.
*/
if (!item->mask) {
memset(rule, 0, sizeof(struct hinic_fdir_rule));
rte_flow_error_set(error, EINVAL,
RTE_FLOW_ERROR_TYPE_ITEM, item,
"Not supported by fdir filter,support src,dst ports");
return -rte_errno;
}
tcp_mask = (const struct rte_flow_item_tcp *)item->mask;
if (tcp_mask->hdr.sent_seq ||
tcp_mask->hdr.recv_ack ||
tcp_mask->hdr.data_off ||
tcp_mask->hdr.tcp_flags ||
tcp_mask->hdr.rx_win ||
tcp_mask->hdr.cksum ||
tcp_mask->hdr.tcp_urp) {
memset(rule, 0, sizeof(struct hinic_fdir_rule));
rte_flow_error_set(error, EINVAL,
RTE_FLOW_ERROR_TYPE_ITEM,
item, "Not supported by fdir filter,support tcp");
return -rte_errno;
}
rule->mask.src_port_mask = tcp_mask->hdr.src_port;
rule->mask.dst_port_mask = tcp_mask->hdr.dst_port;
if (item->spec) {
tcp_spec =
(const struct rte_flow_item_tcp *)
item->spec;
rule->hinic_fdir.src_port =
tcp_spec->hdr.src_port;
rule->hinic_fdir.dst_port =
tcp_spec->hdr.dst_port;
}
} else if (item->type == RTE_FLOW_ITEM_TYPE_UDP) {
/*
* Only care about src & dst ports,
* others should be masked.
*/
if (!item->mask) {
memset(rule, 0, sizeof(struct hinic_fdir_rule));
rte_flow_error_set(error, EINVAL,
RTE_FLOW_ERROR_TYPE_ITEM,
item, "Not supported by fdir filter,support src,dst ports");
return -rte_errno;
}
udp_mask = (const struct rte_flow_item_udp *)item->mask;
if (udp_mask->hdr.dgram_len ||
udp_mask->hdr.dgram_cksum) {
memset(rule, 0, sizeof(struct hinic_fdir_rule));
rte_flow_error_set(error, EINVAL,
RTE_FLOW_ERROR_TYPE_ITEM,
item, "Not supported by fdir filter,support udp");
return -rte_errno;
}
rule->mask.src_port_mask = udp_mask->hdr.src_port;
rule->mask.dst_port_mask = udp_mask->hdr.dst_port;
if (item->spec) {
udp_spec =
(const struct rte_flow_item_udp *)
item->spec;
rule->hinic_fdir.src_port =
udp_spec->hdr.src_port;
rule->hinic_fdir.dst_port =
udp_spec->hdr.dst_port;
}
} else {
memset(rule, 0, sizeof(struct hinic_fdir_rule));
rte_flow_error_set(error, EINVAL,
RTE_FLOW_ERROR_TYPE_ITEM,
item, "Not supported by fdir filter,support tcp/udp");
return -rte_errno;
}
/* Get next no void item */
*in_out_item = next_no_void_pattern(pattern, item);
}
return 0;
}
static int hinic_normal_item_check_end(const struct rte_flow_item *item,
struct hinic_fdir_rule *rule,
struct rte_flow_error *error)
{
/* Check if the next not void item is END */
if (item->type != RTE_FLOW_ITEM_TYPE_END) {
memset(rule, 0, sizeof(struct hinic_fdir_rule));
rte_flow_error_set(error, EINVAL,
RTE_FLOW_ERROR_TYPE_ITEM,
item, "Not supported by fdir filter,support end");
return -rte_errno;
}
return 0;
}
static int hinic_check_normal_item_ele(const struct rte_flow_item *item,
const struct rte_flow_item pattern[],
struct hinic_fdir_rule *rule,
struct rte_flow_error *error)
{
if (hinic_normal_item_check_ether(&item, pattern, error) ||
hinic_normal_item_check_ip(&item, pattern, rule, error) ||
hinic_normal_item_check_l4(&item, pattern, rule, error) ||
hinic_normal_item_check_end(item, rule, error))
return -rte_errno;
return 0;
}
static int hinic_check_normal_attr_ele(const struct rte_flow_attr *attr,
struct hinic_fdir_rule *rule,
struct rte_flow_error *error)
{
/* Must be input direction */
if (!attr->ingress) {
memset(rule, 0, sizeof(struct hinic_fdir_rule));
rte_flow_error_set(error, EINVAL,
RTE_FLOW_ERROR_TYPE_ATTR_INGRESS,
attr, "Only support ingress.");
return -rte_errno;
}
/* Not supported */
if (attr->egress) {
memset(rule, 0, sizeof(struct hinic_fdir_rule));
rte_flow_error_set(error, EINVAL,
RTE_FLOW_ERROR_TYPE_ATTR_EGRESS,
attr, "Not support egress.");
return -rte_errno;
}
/* Not supported */
if (attr->priority) {
memset(rule, 0, sizeof(struct hinic_fdir_rule));
rte_flow_error_set(error, EINVAL,
RTE_FLOW_ERROR_TYPE_ATTR_PRIORITY,
attr, "Not support priority.");
return -rte_errno;
}
return 0;
}
static int hinic_check_normal_act_ele(const struct rte_flow_item *item,
const struct rte_flow_action actions[],
struct hinic_fdir_rule *rule,
struct rte_flow_error *error)
{
const struct rte_flow_action *act;
/* Check if the first not void action is QUEUE */
act = next_no_void_action(actions, NULL);
if (act->type != RTE_FLOW_ACTION_TYPE_QUEUE) {
memset(rule, 0, sizeof(struct hinic_fdir_rule));
rte_flow_error_set(error, EINVAL, RTE_FLOW_ERROR_TYPE_ACTION,
item, "Not supported action.");
return -rte_errno;
}
rule->queue = ((const struct rte_flow_action_queue *)act->conf)->index;
/* Check if the next not void item is END */
act = next_no_void_action(actions, act);
if (act->type != RTE_FLOW_ACTION_TYPE_END) {
memset(rule, 0, sizeof(struct hinic_fdir_rule));
rte_flow_error_set(error, EINVAL, RTE_FLOW_ERROR_TYPE_ACTION,
act, "Not supported action.");
return -rte_errno;
}
return 0;
}
/**
* Parse the rule to see if it is a IP or MAC VLAN flow director rule.
* And get the flow director filter info BTW.
* UDP/TCP/SCTP PATTERN:
* The first not void item can be ETH or IPV4 or IPV6
* The second not void item must be IPV4 or IPV6 if the first one is ETH.
* The next not void item could be UDP or TCP(optional)
* The next not void item must be END.
* ACTION:
* The first not void action should be QUEUE.
* The second not void optional action should be MARK,
* mark_id is a uint32_t number.
* The next not void action should be END.
* UDP/TCP pattern example:
* ITEM Spec Mask
* ETH NULL NULL
* IPV4 src_addr 1.2.3.6 0xFFFFFFFF
* dst_addr 1.2.3.5 0xFFFFFFFF
* UDP/TCP src_port 80 0xFFFF
* dst_port 80 0xFFFF
* END
* Other members in mask and spec should set to 0x00.
* Item->last should be NULL.
*/
static int
hinic_parse_fdir_filter_normal(const struct rte_flow_attr *attr,
const struct rte_flow_item pattern[],
const struct rte_flow_action actions[],
struct hinic_fdir_rule *rule,
struct rte_flow_error *error)
{
const struct rte_flow_item *item = NULL;
if (hinic_check_filter_arg(attr, pattern, actions, error))
return -rte_errno;
if (hinic_check_normal_item_ele(item, pattern, rule, error))
return -rte_errno;
if (hinic_check_normal_attr_ele(attr, rule, error))
return -rte_errno;
if (hinic_check_normal_act_ele(item, actions, rule, error))
return -rte_errno;
return 0;
}
static int
hinic_parse_fdir_filter(struct rte_eth_dev *dev,
const struct rte_flow_attr *attr,
const struct rte_flow_item pattern[],
const struct rte_flow_action actions[],
struct hinic_fdir_rule *rule,
struct rte_flow_error *error)
{
int ret;
ret = hinic_parse_fdir_filter_normal(attr, pattern,
actions, rule, error);
if (ret)
return ret;
if (rule->queue >= dev->data->nb_rx_queues)
return -ENOTSUP;
return ret;
}
/**
* Check if the flow rule is supported by nic.
* It only checkes the format. Don't guarantee the rule can be programmed into
* the HW. Because there can be no enough room for the rule.
*/
static int hinic_flow_validate(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_eth_ethertype_filter ethertype_filter;
struct rte_eth_ntuple_filter ntuple_filter;
struct hinic_fdir_rule fdir_rule;
int ret;
memset(&ntuple_filter, 0, sizeof(struct rte_eth_ntuple_filter));
ret = hinic_parse_ntuple_filter(dev, attr, pattern,
actions, &ntuple_filter, error);
if (!ret)
return 0;
memset(&ethertype_filter, 0, sizeof(struct rte_eth_ethertype_filter));
ret = hinic_parse_ethertype_filter(dev, attr, pattern,
actions, &ethertype_filter, error);
if (!ret)
return 0;
memset(&fdir_rule, 0, sizeof(struct hinic_fdir_rule));
ret = hinic_parse_fdir_filter(dev, attr, pattern,
actions, &fdir_rule, error);
return ret;
}
static inline int
ntuple_ip_filter(struct rte_eth_ntuple_filter *filter,
struct hinic_5tuple_filter_info *filter_info)
{
switch (filter->dst_ip_mask) {
case UINT32_MAX:
filter_info->dst_ip_mask = 0;
filter_info->dst_ip = filter->dst_ip;
break;
case 0:
filter_info->dst_ip_mask = 1;
filter_info->dst_ip = 0;
break;
default:
PMD_DRV_LOG(ERR, "Invalid dst_ip mask.");
return -EINVAL;
}
switch (filter->src_ip_mask) {
case UINT32_MAX:
filter_info->src_ip_mask = 0;
filter_info->src_ip = filter->src_ip;
break;
case 0:
filter_info->src_ip_mask = 1;
filter_info->src_ip = 0;
break;
default:
PMD_DRV_LOG(ERR, "Invalid src_ip mask.");
return -EINVAL;
}
return 0;
}
static inline int
ntuple_port_filter(struct rte_eth_ntuple_filter *filter,
struct hinic_5tuple_filter_info *filter_info)
{
switch (filter->dst_port_mask) {
case UINT16_MAX:
filter_info->dst_port_mask = 0;
filter_info->dst_port = filter->dst_port;
break;
case 0:
filter_info->dst_port_mask = 1;
filter_info->dst_port = 0;
break;
default:
PMD_DRV_LOG(ERR, "Invalid dst_port mask.");
return -EINVAL;
}
switch (filter->src_port_mask) {
case UINT16_MAX:
filter_info->src_port_mask = 0;
filter_info->src_port = filter->src_port;
break;
case 0:
filter_info->src_port_mask = 1;
filter_info->src_port = 0;
break;
default:
PMD_DRV_LOG(ERR, "Invalid src_port mask.");
return -EINVAL;
}
return 0;
}
static inline int
ntuple_proto_filter(struct rte_eth_ntuple_filter *filter,
struct hinic_5tuple_filter_info *filter_info)
{
switch (filter->proto_mask) {
case UINT8_MAX:
filter_info->proto_mask = 0;
filter_info->proto = filter->proto;
break;
case 0:
filter_info->proto_mask = 1;
filter_info->proto = 0;
break;
default:
PMD_DRV_LOG(ERR, "Invalid protocol mask.");
return -EINVAL;
}
return 0;
}
static inline int
ntuple_filter_to_5tuple(struct rte_eth_ntuple_filter *filter,
struct hinic_5tuple_filter_info *filter_info)
{
if (filter->queue >= HINIC_MAX_RX_QUEUE_NUM ||
filter->priority > HINIC_MAX_N_TUPLE_PRIO ||
filter->priority < HINIC_MIN_N_TUPLE_PRIO)
return -EINVAL;
if (ntuple_ip_filter(filter, filter_info) ||
ntuple_port_filter(filter, filter_info) ||
ntuple_proto_filter(filter, filter_info))
return -EINVAL;
filter_info->priority = (uint8_t)filter->priority;
return 0;
}
static inline struct hinic_5tuple_filter *
hinic_5tuple_filter_lookup(struct hinic_5tuple_filter_list *filter_list,
struct hinic_5tuple_filter_info *key)
{
struct hinic_5tuple_filter *it;
TAILQ_FOREACH(it, filter_list, entries) {
if (memcmp(key, &it->filter_info,
sizeof(struct hinic_5tuple_filter_info)) == 0) {
return it;
}
}
return NULL;
}
static int hinic_set_lacp_tcam(struct hinic_nic_dev *nic_dev)
{
struct tag_pa_rule lacp_rule;
struct tag_pa_action lacp_action;
memset(&lacp_rule, 0, sizeof(lacp_rule));
memset(&lacp_action, 0, sizeof(lacp_action));
/* LACP TCAM rule */
lacp_rule.eth_type = PA_ETH_TYPE_OTHER;
lacp_rule.l2_header.eth_type.val16 = 0x8809;
lacp_rule.l2_header.eth_type.mask16 = 0xffff;
/* LACP TCAM action */
lacp_action.err_type = 0x3f; /* err from ipsu, not convert */
lacp_action.fwd_action = 0x7; /* 0x3:drop; 0x7: not convert */
lacp_action.pkt_type = PKT_LACP_TYPE;
lacp_action.pri = 0x0;
lacp_action.push_len = 0xf; /* push_len:0xf, not convert */
return hinic_set_fdir_tcam(nic_dev->hwdev, TCAM_PKT_LACP,
&lacp_rule, &lacp_action);
}
static int hinic_set_bgp_dport_tcam(struct hinic_nic_dev *nic_dev)
{
struct tag_pa_rule bgp_rule;
struct tag_pa_action bgp_action;
memset(&bgp_rule, 0, sizeof(bgp_rule));
memset(&bgp_action, 0, sizeof(bgp_action));
/* BGP TCAM rule */
bgp_rule.eth_type = PA_ETH_TYPE_IPV4; /* Eth type is IPV4 */
bgp_rule.ip_header.protocol.val8 = IP_HEADER_PROTOCOL_TYPE_TCP;
bgp_rule.ip_header.protocol.mask8 = UINT8_MAX;
bgp_rule.ip_protocol_type = PA_IP_PROTOCOL_TYPE_TCP;
bgp_rule.eth_ip_tcp.dport.val16 = BGP_DPORT_ID; /* Dport is 179 */
bgp_rule.eth_ip_tcp.dport.mask16 = UINT16_MAX;
/* BGP TCAM action */
bgp_action.err_type = 0x3f; /* err from ipsu, not convert */
bgp_action.fwd_action = 0x7; /* 0x3:drop; 0x7: not convert */
bgp_action.pkt_type = PKT_BGPD_DPORT_TYPE; /* bgp_dport: 83 */
bgp_action.pri = 0xf; /* pri of BGP is 0xf, result from ipsu parse
* results, not need to convert
*/
bgp_action.push_len = 0xf; /* push_len:0xf, not convert */
return hinic_set_fdir_tcam(nic_dev->hwdev,
TCAM_PKT_BGP_DPORT, &bgp_rule, &bgp_action);
}
static int hinic_set_bgp_sport_tcam(struct hinic_nic_dev *nic_dev)
{
struct tag_pa_rule bgp_rule;
struct tag_pa_action bgp_action;
memset(&bgp_rule, 0, sizeof(bgp_rule));
memset(&bgp_action, 0, sizeof(bgp_action));
/* BGP TCAM rule */
bgp_rule.eth_type = PA_ETH_TYPE_IPV4;
bgp_rule.ip_header.protocol.val8 = IP_HEADER_PROTOCOL_TYPE_TCP;
bgp_rule.ip_header.protocol.mask8 = UINT8_MAX;
bgp_rule.ip_protocol_type = PA_IP_PROTOCOL_TYPE_TCP;
bgp_rule.eth_ip_tcp.sport.val16 = BGP_DPORT_ID;
bgp_rule.eth_ip_tcp.sport.mask16 = UINT16_MAX;
/* BGP TCAM action */
bgp_action.err_type = 0x3f; /* err from ipsu, not convert */
bgp_action.fwd_action = 0x7; /* 0x3:drop; 0x7: not convert */
bgp_action.pkt_type = PKT_BGPD_SPORT_TYPE; /* bgp:sport: 84 */
bgp_action.pri = 0xf; /* pri of BGP is 0xf, result from ipsu parse
* results, not need to convert
*/
bgp_action.push_len = 0xf; /* push_len:0xf, not convert */
return hinic_set_fdir_tcam(nic_dev->hwdev, TCAM_PKT_BGP_SPORT,
&bgp_rule, &bgp_action);
}
static int hinic_set_vrrp_tcam(struct hinic_nic_dev *nic_dev)
{
struct tag_pa_rule vrrp_rule;
struct tag_pa_action vrrp_action;
memset(&vrrp_rule, 0, sizeof(vrrp_rule));
memset(&vrrp_action, 0, sizeof(vrrp_action));
/* VRRP TCAM rule */
vrrp_rule.eth_type = PA_ETH_TYPE_IPV4;
vrrp_rule.ip_protocol_type = PA_IP_PROTOCOL_TYPE_TCP;
vrrp_rule.ip_header.protocol.mask8 = 0xff;
vrrp_rule.ip_header.protocol.val8 = PA_IP_PROTOCOL_TYPE_VRRP;
/* VRRP TCAM action */
vrrp_action.err_type = 0x3f;
vrrp_action.fwd_action = 0x7;
vrrp_action.pkt_type = PKT_VRRP_TYPE; /* VRRP: 85 */
vrrp_action.pri = 0xf;
vrrp_action.push_len = 0xf;
return hinic_set_fdir_tcam(nic_dev->hwdev, TCAM_PKT_VRRP,
&vrrp_rule, &vrrp_action);
}
/**
* Clear all fdir configuration.
*
* @param nic_dev
* The hardware interface of a Ethernet device.
*
* @return
* 0 on success,
* negative error value otherwise.
*/
void hinic_free_fdir_filter(struct hinic_nic_dev *nic_dev)
{
struct hinic_filter_info *filter_info =
HINIC_DEV_PRIVATE_TO_FILTER_INFO(nic_dev);
if (filter_info->type_mask &
(1 << HINIC_PKT_TYPE_FIND_ID(PKT_BGPD_DPORT_TYPE)))
hinic_clear_fdir_tcam(nic_dev->hwdev, TCAM_PKT_BGP_DPORT);
if (filter_info->type_mask &
(1 << HINIC_PKT_TYPE_FIND_ID(PKT_BGPD_SPORT_TYPE)))
hinic_clear_fdir_tcam(nic_dev->hwdev, TCAM_PKT_BGP_SPORT);
if (filter_info->type_mask &
(1 << HINIC_PKT_TYPE_FIND_ID(PKT_VRRP_TYPE)))
hinic_clear_fdir_tcam(nic_dev->hwdev, TCAM_PKT_VRRP);
if (filter_info->type_mask &
(1 << HINIC_PKT_TYPE_FIND_ID(PKT_LACP_TYPE)))
hinic_clear_fdir_tcam(nic_dev->hwdev, TCAM_PKT_LACP);
hinic_set_fdir_filter(nic_dev->hwdev, 0, 0, 0, false);
}
static int
hinic_filter_info_init(struct hinic_5tuple_filter *filter,
struct hinic_filter_info *filter_info)
{
switch (filter->filter_info.proto) {
case IPPROTO_TCP:
/* Filter type is bgp type if dst_port or src_port is 179 */
if (filter->filter_info.dst_port == RTE_BE16(BGP_DPORT_ID) &&
!(filter->filter_info.dst_port_mask)) {
filter_info->pkt_type = PKT_BGPD_DPORT_TYPE;
} else if (filter->filter_info.src_port ==
RTE_BE16(BGP_DPORT_ID) &&
!(filter->filter_info.src_port_mask)) {
filter_info->pkt_type = PKT_BGPD_SPORT_TYPE;
} else {
PMD_DRV_LOG(INFO, "TCP PROTOCOL:5tuple filters"
" just support BGP now, proto:0x%x, "
"dst_port:0x%x, dst_port_mask:0x%x."
"src_port:0x%x, src_port_mask:0x%x.",
filter->filter_info.proto,
filter->filter_info.dst_port,
filter->filter_info.dst_port_mask,
filter->filter_info.src_port,
filter->filter_info.src_port_mask);
return -EINVAL;
}
break;
case IPPROTO_VRRP:
filter_info->pkt_type = PKT_VRRP_TYPE;
break;
case IPPROTO_ICMP:
filter_info->pkt_type = PKT_ICMP_IPV4_TYPE;
break;
case IPPROTO_ICMPV6:
filter_info->pkt_type = PKT_ICMP_IPV6_TYPE;
break;
default:
PMD_DRV_LOG(ERR, "5tuple filters just support BGP/VRRP/ICMP now, "
"proto: 0x%x, dst_port: 0x%x, dst_port_mask: 0x%x."
"src_port: 0x%x, src_port_mask: 0x%x.",
filter->filter_info.proto, filter->filter_info.dst_port,
filter->filter_info.dst_port_mask,
filter->filter_info.src_port,
filter->filter_info.src_port_mask);
return -EINVAL;
}
return 0;
}
static int
hinic_lookup_new_filter(struct hinic_5tuple_filter *filter,
struct hinic_filter_info *filter_info,
int *index)
{
int type_id;
type_id = HINIC_PKT_TYPE_FIND_ID(filter_info->pkt_type);
if (type_id > HINIC_MAX_Q_FILTERS - 1) {
PMD_DRV_LOG(ERR, "Pkt filters only support 64 filter type.");
return -EINVAL;
}
if (!(filter_info->type_mask & (1 << type_id))) {
filter_info->type_mask |= 1 << type_id;
filter->index = type_id;
filter_info->pkt_filters[type_id].enable = true;
filter_info->pkt_filters[type_id].pkt_proto =
filter->filter_info.proto;
TAILQ_INSERT_TAIL(&filter_info->fivetuple_list,
filter, entries);
} else {
PMD_DRV_LOG(ERR, "Filter type: %d exists.", type_id);
return -EIO;
}
*index = type_id;
return 0;
}
/*
* Add a 5tuple filter
*
* @param dev:
* Pointer to struct rte_eth_dev.
* @param filter:
* Pointer to the filter that will be added.
* @return
* - On success, zero.
* - On failure, a negative value.
*/
static int
hinic_add_5tuple_filter(struct rte_eth_dev *dev,
struct hinic_5tuple_filter *filter)
{
struct hinic_filter_info *filter_info =
HINIC_DEV_PRIVATE_TO_FILTER_INFO(dev->data->dev_private);
int i, ret_fw;
struct hinic_nic_dev *nic_dev = HINIC_ETH_DEV_TO_PRIVATE_NIC_DEV(dev);
if (hinic_filter_info_init(filter, filter_info) ||
hinic_lookup_new_filter(filter, filter_info, &i))
return -EFAULT;
ret_fw = hinic_set_fdir_filter(nic_dev->hwdev, filter_info->pkt_type,
filter_info->qid,
filter_info->pkt_filters[i].enable,
true);
if (ret_fw) {
PMD_DRV_LOG(ERR, "Set fdir filter failed, type: 0x%x, qid: 0x%x, enable: 0x%x",
filter_info->pkt_type, filter->queue,
filter_info->pkt_filters[i].enable);
return -EFAULT;
}
PMD_DRV_LOG(INFO, "Add 5tuple succeed, type: 0x%x, qid: 0x%x, enable: 0x%x",
filter_info->pkt_type, filter_info->qid,
filter_info->pkt_filters[filter->index].enable);
switch (filter->filter_info.proto) {
case IPPROTO_TCP:
if (filter->filter_info.dst_port == RTE_BE16(BGP_DPORT_ID)) {
ret_fw = hinic_set_bgp_dport_tcam(nic_dev);
if (ret_fw) {
PMD_DRV_LOG(ERR, "Set dport bgp failed, "
"type: 0x%x, qid: 0x%x, enable: 0x%x",
filter_info->pkt_type, filter->queue,
filter_info->pkt_filters[i].enable);
return -EFAULT;
}
PMD_DRV_LOG(INFO, "Set dport bgp succeed, qid: 0x%x, enable: 0x%x",
filter->queue,
filter_info->pkt_filters[i].enable);
} else if (filter->filter_info.src_port ==
RTE_BE16(BGP_DPORT_ID)) {
ret_fw = hinic_set_bgp_sport_tcam(nic_dev);
if (ret_fw) {
PMD_DRV_LOG(ERR, "Set sport bgp failed, "
"type: 0x%x, qid: 0x%x, enable: 0x%x",
filter_info->pkt_type, filter->queue,
filter_info->pkt_filters[i].enable);
return -EFAULT;
}
PMD_DRV_LOG(INFO, "Set sport bgp succeed, qid: 0x%x, enable: 0x%x",
filter->queue,
filter_info->pkt_filters[i].enable);
}
break;
case IPPROTO_VRRP:
ret_fw = hinic_set_vrrp_tcam(nic_dev);
if (ret_fw) {
PMD_DRV_LOG(ERR, "Set VRRP failed, "
"type: 0x%x, qid: 0x%x, enable: 0x%x",
filter_info->pkt_type, filter->queue,
filter_info->pkt_filters[i].enable);
return -EFAULT;
}
PMD_DRV_LOG(INFO, "Set VRRP succeed, qid: 0x%x, enable: 0x%x",
filter->queue,
filter_info->pkt_filters[i].enable);
break;
default:
break;
}
return 0;
}
/*
* Remove a 5tuple filter
*
* @param dev
* Pointer to struct rte_eth_dev.
* @param filter
* The pointer of the filter will be removed.
*/
static void
hinic_remove_5tuple_filter(struct rte_eth_dev *dev,
struct hinic_5tuple_filter *filter)
{
struct hinic_filter_info *filter_info =
HINIC_DEV_PRIVATE_TO_FILTER_INFO(dev->data->dev_private);
struct hinic_nic_dev *nic_dev = HINIC_ETH_DEV_TO_PRIVATE_NIC_DEV(dev);
switch (filter->filter_info.proto) {
case IPPROTO_VRRP:
(void)hinic_clear_fdir_tcam(nic_dev->hwdev, TCAM_PKT_VRRP);
break;
case IPPROTO_TCP:
if (filter->filter_info.dst_port == RTE_BE16(BGP_DPORT_ID))
(void)hinic_clear_fdir_tcam(nic_dev->hwdev,
TCAM_PKT_BGP_DPORT);
else if (filter->filter_info.src_port == RTE_BE16(BGP_DPORT_ID))
(void)hinic_clear_fdir_tcam(nic_dev->hwdev,
TCAM_PKT_BGP_SPORT);
break;
default:
break;
}
hinic_filter_info_init(filter, filter_info);
filter_info->pkt_filters[filter->index].enable = false;
filter_info->pkt_filters[filter->index].pkt_proto = 0;
PMD_DRV_LOG(INFO, "Del 5tuple succeed, type: 0x%x, qid: 0x%x, enable: 0x%x",
filter_info->pkt_type,
filter_info->pkt_filters[filter->index].qid,
filter_info->pkt_filters[filter->index].enable);
(void)hinic_set_fdir_filter(nic_dev->hwdev, filter_info->pkt_type,
filter_info->pkt_filters[filter->index].qid,
filter_info->pkt_filters[filter->index].enable,
true);
filter_info->pkt_type = 0;
filter_info->qid = 0;
filter_info->pkt_filters[filter->index].qid = 0;
filter_info->type_mask &= ~(1 << (filter->index));
TAILQ_REMOVE(&filter_info->fivetuple_list, filter, entries);
rte_free(filter);
}
/*
* Add or delete a ntuple filter
*
* @param dev
* Pointer to struct rte_eth_dev.
* @param ntuple_filter
* Pointer to struct rte_eth_ntuple_filter
* @param add
* If true, add filter; if false, remove filter
* @return
* - On success, zero.
* - On failure, a negative value.
*/
static int hinic_add_del_ntuple_filter(struct rte_eth_dev *dev,
struct rte_eth_ntuple_filter *ntuple_filter,
bool add)
{
struct hinic_filter_info *filter_info =
HINIC_DEV_PRIVATE_TO_FILTER_INFO(dev->data->dev_private);
struct hinic_5tuple_filter_info filter_5tuple;
struct hinic_5tuple_filter *filter;
int ret;
if (ntuple_filter->flags != RTE_5TUPLE_FLAGS) {
PMD_DRV_LOG(ERR, "Only 5tuple is supported.");
return -EINVAL;
}
memset(&filter_5tuple, 0, sizeof(struct hinic_5tuple_filter_info));
ret = ntuple_filter_to_5tuple(ntuple_filter, &filter_5tuple);
if (ret < 0)
return ret;
filter = hinic_5tuple_filter_lookup(&filter_info->fivetuple_list,
&filter_5tuple);
if (filter != NULL && add) {
PMD_DRV_LOG(ERR, "Filter exists.");
return -EEXIST;
}
if (filter == NULL && !add) {
PMD_DRV_LOG(ERR, "Filter doesn't exist.");
return -ENOENT;
}
if (add) {
filter = rte_zmalloc("hinic_5tuple_filter",
sizeof(struct hinic_5tuple_filter), 0);
if (filter == NULL)
return -ENOMEM;
rte_memcpy(&filter->filter_info, &filter_5tuple,
sizeof(struct hinic_5tuple_filter_info));
filter->queue = ntuple_filter->queue;
filter_info->qid = ntuple_filter->queue;
ret = hinic_add_5tuple_filter(dev, filter);
if (ret)
rte_free(filter);
return ret;
}
hinic_remove_5tuple_filter(dev, filter);
return 0;
}
static inline int
hinic_check_ethertype_filter(struct rte_eth_ethertype_filter *filter)
{
if (filter->queue >= HINIC_MAX_RX_QUEUE_NUM)
return -EINVAL;
if (filter->ether_type == RTE_ETHER_TYPE_IPV4 ||
filter->ether_type == RTE_ETHER_TYPE_IPV6) {
PMD_DRV_LOG(ERR, "Unsupported ether_type(0x%04x) in"
" ethertype filter", filter->ether_type);
return -EINVAL;
}
if (filter->flags & RTE_ETHTYPE_FLAGS_MAC) {
PMD_DRV_LOG(ERR, "Mac compare is not supported");
return -EINVAL;
}
if (filter->flags & RTE_ETHTYPE_FLAGS_DROP) {
PMD_DRV_LOG(ERR, "Drop option is not supported");
return -EINVAL;
}
return 0;
}
static inline int
hinic_ethertype_filter_lookup(struct hinic_filter_info *filter_info,
struct hinic_pkt_filter *ethertype_filter)
{
switch (ethertype_filter->pkt_proto) {
case RTE_ETHER_TYPE_SLOW:
filter_info->pkt_type = PKT_LACP_TYPE;
break;
case RTE_ETHER_TYPE_ARP:
filter_info->pkt_type = PKT_ARP_TYPE;
break;
default:
PMD_DRV_LOG(ERR, "Just support LACP/ARP for ethertype filters");
return -EIO;
}
return HINIC_PKT_TYPE_FIND_ID(filter_info->pkt_type);
}
static inline int
hinic_ethertype_filter_insert(struct hinic_filter_info *filter_info,
struct hinic_pkt_filter *ethertype_filter)
{
int id;
/* Find LACP or VRRP type id */
id = hinic_ethertype_filter_lookup(filter_info, ethertype_filter);
if (id < 0)
return -EINVAL;
if (!(filter_info->type_mask & (1 << id))) {
filter_info->type_mask |= 1 << id;
filter_info->pkt_filters[id].pkt_proto =
ethertype_filter->pkt_proto;
filter_info->pkt_filters[id].enable = ethertype_filter->enable;
filter_info->qid = ethertype_filter->qid;
return id;
}
PMD_DRV_LOG(ERR, "Filter type: %d exists", id);
return -EINVAL;
}
static inline void
hinic_ethertype_filter_remove(struct hinic_filter_info *filter_info,
uint8_t idx)
{
if (idx >= HINIC_MAX_Q_FILTERS)
return;
filter_info->pkt_type = 0;
filter_info->type_mask &= ~(1 << idx);
filter_info->pkt_filters[idx].pkt_proto = (uint16_t)0;
filter_info->pkt_filters[idx].enable = FALSE;
filter_info->pkt_filters[idx].qid = 0;
}
static inline int
hinic_add_del_ethertype_filter(struct rte_eth_dev *dev,
struct rte_eth_ethertype_filter *filter,
bool add)
{
struct hinic_nic_dev *nic_dev = HINIC_ETH_DEV_TO_PRIVATE_NIC_DEV(dev);
struct hinic_filter_info *filter_info =
HINIC_DEV_PRIVATE_TO_FILTER_INFO(dev->data->dev_private);
struct hinic_pkt_filter ethertype_filter;
int i;
int ret_fw;
if (hinic_check_ethertype_filter(filter))
return -EINVAL;
if (add) {
ethertype_filter.pkt_proto = filter->ether_type;
ethertype_filter.enable = TRUE;
ethertype_filter.qid = (u8)filter->queue;
i = hinic_ethertype_filter_insert(filter_info,
&ethertype_filter);
if (i < 0)
return -ENOSPC;
ret_fw = hinic_set_fdir_filter(nic_dev->hwdev,
filter_info->pkt_type, filter_info->qid,
filter_info->pkt_filters[i].enable, true);
if (ret_fw) {
PMD_DRV_LOG(ERR, "add ethertype failed, type: 0x%x, qid: 0x%x, enable: 0x%x",
filter_info->pkt_type, filter->queue,
filter_info->pkt_filters[i].enable);
hinic_ethertype_filter_remove(filter_info, i);
return -ENOENT;
}
PMD_DRV_LOG(INFO, "Add ethertype succeed, type: 0x%x, qid: 0x%x, enable: 0x%x",
filter_info->pkt_type, filter->queue,
filter_info->pkt_filters[i].enable);
switch (ethertype_filter.pkt_proto) {
case RTE_ETHER_TYPE_SLOW:
ret_fw = hinic_set_lacp_tcam(nic_dev);
if (ret_fw) {
PMD_DRV_LOG(ERR, "Add lacp tcam failed");
hinic_ethertype_filter_remove(filter_info, i);
return -ENOENT;
}
PMD_DRV_LOG(INFO, "Add lacp tcam succeed");
break;
default:
break;
}
} else {
ethertype_filter.pkt_proto = filter->ether_type;
i = hinic_ethertype_filter_lookup(filter_info,
&ethertype_filter);
if ((filter_info->type_mask & (1 << i))) {
filter_info->pkt_filters[i].enable = FALSE;
(void)hinic_set_fdir_filter(nic_dev->hwdev,
filter_info->pkt_type,
filter_info->pkt_filters[i].qid,
filter_info->pkt_filters[i].enable,
true);
PMD_DRV_LOG(INFO, "Del ethertype succeed, type: 0x%x, qid: 0x%x, enable: 0x%x",
filter_info->pkt_type,
filter_info->pkt_filters[i].qid,
filter_info->pkt_filters[i].enable);
switch (ethertype_filter.pkt_proto) {
case RTE_ETHER_TYPE_SLOW:
(void)hinic_clear_fdir_tcam(nic_dev->hwdev,
TCAM_PKT_LACP);
PMD_DRV_LOG(INFO,
"Del lacp tcam succeed");
break;
default:
break;
}
hinic_ethertype_filter_remove(filter_info, i);
} else {
PMD_DRV_LOG(ERR, "Ethertype doesn't exist, type: 0x%x, qid: 0x%x, enable: 0x%x",
filter_info->pkt_type, filter->queue,
filter_info->pkt_filters[i].enable);
return -ENOENT;
}
}
return 0;
}
static int
hinic_fdir_info_init(struct hinic_fdir_rule *rule,
struct hinic_fdir_info *fdir_info)
{
switch (rule->mask.src_ipv4_mask) {
case UINT32_MAX:
fdir_info->fdir_flag = HINIC_ATR_FLOW_TYPE_IPV4_SIP;
fdir_info->qid = rule->queue;
fdir_info->fdir_key = rule->hinic_fdir.src_ip;
return 0;
case 0:
break;
default:
PMD_DRV_LOG(ERR, "Invalid src_ip mask.");
return -EINVAL;
}
switch (rule->mask.dst_ipv4_mask) {
case UINT32_MAX:
fdir_info->fdir_flag = HINIC_ATR_FLOW_TYPE_IPV4_DIP;
fdir_info->qid = rule->queue;
fdir_info->fdir_key = rule->hinic_fdir.dst_ip;
return 0;
case 0:
break;
default:
PMD_DRV_LOG(ERR, "Invalid dst_ip mask.");
return -EINVAL;
}
if (fdir_info->fdir_flag == 0) {
PMD_DRV_LOG(ERR, "All support mask is NULL.");
return -EINVAL;
}
return 0;
}
static inline int
hinic_add_del_fdir_filter(struct rte_eth_dev *dev,
struct hinic_fdir_rule *rule,
bool add)
{
struct hinic_nic_dev *nic_dev = HINIC_ETH_DEV_TO_PRIVATE_NIC_DEV(dev);
struct hinic_fdir_info fdir_info;
int ret;
memset(&fdir_info, 0, sizeof(struct hinic_fdir_info));
ret = hinic_fdir_info_init(rule, &fdir_info);
if (ret) {
PMD_DRV_LOG(ERR, "Init hinic fdir info failed!");
return ret;
}
if (add) {
ret = hinic_set_normal_filter(nic_dev->hwdev, fdir_info.qid,
true, fdir_info.fdir_key,
true, fdir_info.fdir_flag);
if (ret) {
PMD_DRV_LOG(ERR, "Add fdir filter failed, flag: 0x%x, qid: 0x%x, key: 0x%x",
fdir_info.fdir_flag, fdir_info.qid,
fdir_info.fdir_key);
return -ENOENT;
}
PMD_DRV_LOG(INFO, "Add fdir filter succeed, flag: 0x%x, qid: 0x%x, key: 0x%x",
fdir_info.fdir_flag, fdir_info.qid,
fdir_info.fdir_key);
} else {
ret = hinic_set_normal_filter(nic_dev->hwdev, fdir_info.qid,
false, fdir_info.fdir_key, true,
fdir_info.fdir_flag);
if (ret) {
PMD_DRV_LOG(ERR, "Del fdir filter ailed, flag: 0x%x, qid: 0x%x, key: 0x%x",
fdir_info.fdir_flag, fdir_info.qid,
fdir_info.fdir_key);
return -ENOENT;
}
PMD_DRV_LOG(INFO, "Del fdir filter succeed, flag: 0x%x, qid: 0x%x, key: 0x%x",
fdir_info.fdir_flag, fdir_info.qid,
fdir_info.fdir_key);
}
return 0;
}
/**
* Create or destroy a flow rule.
* Theorically one rule can match more than one filters.
* We will let it use the filter which it hitt first.
* So, the sequence matters.
*/
static struct rte_flow *hinic_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)
{
int ret;
struct rte_eth_ntuple_filter ntuple_filter;
struct rte_eth_ethertype_filter ethertype_filter;
struct hinic_fdir_rule fdir_rule;
struct rte_flow *flow = NULL;
struct hinic_ethertype_filter_ele *ethertype_filter_ptr;
struct hinic_ntuple_filter_ele *ntuple_filter_ptr;
struct hinic_fdir_rule_ele *fdir_rule_ptr;
struct hinic_flow_mem *hinic_flow_mem_ptr;
struct hinic_nic_dev *nic_dev = HINIC_ETH_DEV_TO_PRIVATE_NIC_DEV(dev);
flow = rte_zmalloc("hinic_rte_flow", sizeof(struct rte_flow), 0);
if (!flow) {
PMD_DRV_LOG(ERR, "Failed to allocate flow memory");
return NULL;
}
hinic_flow_mem_ptr = rte_zmalloc("hinic_flow_mem",
sizeof(struct hinic_flow_mem), 0);
if (!hinic_flow_mem_ptr) {
PMD_DRV_LOG(ERR, "Failed to allocate hinic_flow_mem_ptr");
rte_free(flow);
return NULL;
}
hinic_flow_mem_ptr->flow = flow;
TAILQ_INSERT_TAIL(&nic_dev->hinic_flow_list, hinic_flow_mem_ptr,
entries);
/* Add ntuple filter */
memset(&ntuple_filter, 0, sizeof(struct rte_eth_ntuple_filter));
ret = hinic_parse_ntuple_filter(dev, attr, pattern,
actions, &ntuple_filter, error);
if (!ret) {
ret = hinic_add_del_ntuple_filter(dev, &ntuple_filter, TRUE);
if (!ret) {
ntuple_filter_ptr = rte_zmalloc("hinic_ntuple_filter",
sizeof(struct hinic_ntuple_filter_ele), 0);
rte_memcpy(&ntuple_filter_ptr->filter_info,
&ntuple_filter,
sizeof(struct rte_eth_ntuple_filter));
TAILQ_INSERT_TAIL(&nic_dev->filter_ntuple_list,
ntuple_filter_ptr, entries);
flow->rule = ntuple_filter_ptr;
flow->filter_type = RTE_ETH_FILTER_NTUPLE;
PMD_DRV_LOG(INFO, "Create flow ntuple succeed, func_id: 0x%x",
hinic_global_func_id(nic_dev->hwdev));
return flow;
}
goto out;
}
/* Add ethertype filter */
memset(&ethertype_filter, 0, sizeof(struct rte_eth_ethertype_filter));
ret = hinic_parse_ethertype_filter(dev, attr, pattern, actions,
&ethertype_filter, error);
if (!ret) {
ret = hinic_add_del_ethertype_filter(dev, &ethertype_filter,
TRUE);
if (!ret) {
ethertype_filter_ptr =
rte_zmalloc("hinic_ethertype_filter",
sizeof(struct hinic_ethertype_filter_ele), 0);
rte_memcpy(&ethertype_filter_ptr->filter_info,
&ethertype_filter,
sizeof(struct rte_eth_ethertype_filter));
TAILQ_INSERT_TAIL(&nic_dev->filter_ethertype_list,
ethertype_filter_ptr, entries);
flow->rule = ethertype_filter_ptr;
flow->filter_type = RTE_ETH_FILTER_ETHERTYPE;
PMD_DRV_LOG(INFO, "Create flow ethertype succeed, func_id: 0x%x",
hinic_global_func_id(nic_dev->hwdev));
return flow;
}
goto out;
}
/* Add fdir filter */
memset(&fdir_rule, 0, sizeof(struct hinic_fdir_rule));
ret = hinic_parse_fdir_filter(dev, attr, pattern,
actions, &fdir_rule, error);
if (!ret) {
ret = hinic_add_del_fdir_filter(dev, &fdir_rule, TRUE);
if (!ret) {
fdir_rule_ptr = rte_zmalloc("hinic_fdir_rule",
sizeof(struct hinic_fdir_rule_ele), 0);
rte_memcpy(&fdir_rule_ptr->filter_info, &fdir_rule,
sizeof(struct hinic_fdir_rule));
TAILQ_INSERT_TAIL(&nic_dev->filter_fdir_rule_list,
fdir_rule_ptr, entries);
flow->rule = fdir_rule_ptr;
flow->filter_type = RTE_ETH_FILTER_FDIR;
PMD_DRV_LOG(INFO, "Create flow fdir rule succeed, func_id : 0x%x",
hinic_global_func_id(nic_dev->hwdev));
return flow;
}
goto out;
}
out:
TAILQ_REMOVE(&nic_dev->hinic_flow_list, hinic_flow_mem_ptr, entries);
rte_flow_error_set(error, -ret,
RTE_FLOW_ERROR_TYPE_HANDLE, NULL,
"Failed to create flow.");
rte_free(hinic_flow_mem_ptr);
rte_free(flow);
return NULL;
}
/* Destroy a flow rule on hinic. */
static int hinic_flow_destroy(struct rte_eth_dev *dev,
struct rte_flow *flow,
struct rte_flow_error *error)
{
int ret;
struct rte_flow *pmd_flow = flow;
enum rte_filter_type filter_type = pmd_flow->filter_type;
struct rte_eth_ntuple_filter ntuple_filter;
struct rte_eth_ethertype_filter ethertype_filter;
struct hinic_fdir_rule fdir_rule;
struct hinic_ntuple_filter_ele *ntuple_filter_ptr;
struct hinic_ethertype_filter_ele *ethertype_filter_ptr;
struct hinic_fdir_rule_ele *fdir_rule_ptr;
struct hinic_flow_mem *hinic_flow_mem_ptr;
struct hinic_nic_dev *nic_dev = HINIC_ETH_DEV_TO_PRIVATE_NIC_DEV(dev);
switch (filter_type) {
case RTE_ETH_FILTER_NTUPLE:
ntuple_filter_ptr = (struct hinic_ntuple_filter_ele *)
pmd_flow->rule;
rte_memcpy(&ntuple_filter, &ntuple_filter_ptr->filter_info,
sizeof(struct rte_eth_ntuple_filter));
ret = hinic_add_del_ntuple_filter(dev, &ntuple_filter, FALSE);
if (!ret) {
TAILQ_REMOVE(&nic_dev->filter_ntuple_list,
ntuple_filter_ptr, entries);
rte_free(ntuple_filter_ptr);
}
break;
case RTE_ETH_FILTER_ETHERTYPE:
ethertype_filter_ptr = (struct hinic_ethertype_filter_ele *)
pmd_flow->rule;
rte_memcpy(&ethertype_filter,
&ethertype_filter_ptr->filter_info,
sizeof(struct rte_eth_ethertype_filter));
ret = hinic_add_del_ethertype_filter(dev,
&ethertype_filter, FALSE);
if (!ret) {
TAILQ_REMOVE(&nic_dev->filter_ethertype_list,
ethertype_filter_ptr, entries);
rte_free(ethertype_filter_ptr);
}
break;
case RTE_ETH_FILTER_FDIR:
fdir_rule_ptr = (struct hinic_fdir_rule_ele *)pmd_flow->rule;
rte_memcpy(&fdir_rule,
&fdir_rule_ptr->filter_info,
sizeof(struct hinic_fdir_rule));
ret = hinic_add_del_fdir_filter(dev, &fdir_rule, FALSE);
if (!ret) {
TAILQ_REMOVE(&nic_dev->filter_fdir_rule_list,
fdir_rule_ptr, entries);
rte_free(fdir_rule_ptr);
}
break;
default:
PMD_DRV_LOG(WARNING, "Filter type (%d) not supported",
filter_type);
ret = -EINVAL;
break;
}
if (ret) {
rte_flow_error_set(error, EINVAL,
RTE_FLOW_ERROR_TYPE_HANDLE,
NULL, "Failed to destroy flow");
return ret;
}
TAILQ_FOREACH(hinic_flow_mem_ptr, &nic_dev->hinic_flow_list, entries) {
if (hinic_flow_mem_ptr->flow == pmd_flow) {
TAILQ_REMOVE(&nic_dev->hinic_flow_list,
hinic_flow_mem_ptr, entries);
rte_free(hinic_flow_mem_ptr);
break;
}
}
rte_free(flow);
PMD_DRV_LOG(INFO, "Destroy flow succeed, func_id: 0x%x",
hinic_global_func_id(nic_dev->hwdev));
return ret;
}
/* Remove all the n-tuple filters */
static void hinic_clear_all_ntuple_filter(struct rte_eth_dev *dev)
{
struct hinic_filter_info *filter_info =
HINIC_DEV_PRIVATE_TO_FILTER_INFO(dev->data->dev_private);
struct hinic_5tuple_filter *p_5tuple;
while ((p_5tuple = TAILQ_FIRST(&filter_info->fivetuple_list)))
hinic_remove_5tuple_filter(dev, p_5tuple);
}
/* Remove all the ether type filters */
static void hinic_clear_all_ethertype_filter(struct rte_eth_dev *dev)
{
struct hinic_nic_dev *nic_dev = HINIC_ETH_DEV_TO_PRIVATE_NIC_DEV(dev);
struct hinic_filter_info *filter_info =
HINIC_DEV_PRIVATE_TO_FILTER_INFO(nic_dev);
int ret = 0;
if (filter_info->type_mask &
(1 << HINIC_PKT_TYPE_FIND_ID(PKT_LACP_TYPE))) {
hinic_ethertype_filter_remove(filter_info,
HINIC_PKT_TYPE_FIND_ID(PKT_LACP_TYPE));
ret = hinic_set_fdir_filter(nic_dev->hwdev, PKT_LACP_TYPE,
filter_info->qid, false, true);
(void)hinic_clear_fdir_tcam(nic_dev->hwdev, TCAM_PKT_LACP);
}
if (filter_info->type_mask &
(1 << HINIC_PKT_TYPE_FIND_ID(PKT_ARP_TYPE))) {
hinic_ethertype_filter_remove(filter_info,
HINIC_PKT_TYPE_FIND_ID(PKT_ARP_TYPE));
ret = hinic_set_fdir_filter(nic_dev->hwdev, PKT_ARP_TYPE,
filter_info->qid, false, true);
}
if (ret)
PMD_DRV_LOG(ERR, "Clear ethertype failed, filter type: 0x%x",
filter_info->pkt_type);
}
/* Remove all the ether type filters */
static void hinic_clear_all_fdir_filter(struct rte_eth_dev *dev)
{
struct hinic_nic_dev *nic_dev = HINIC_ETH_DEV_TO_PRIVATE_NIC_DEV(dev);
(void)hinic_set_fdir_filter(nic_dev->hwdev, 0, 0, 0, false);
}
static void hinic_filterlist_flush(struct rte_eth_dev *dev)
{
struct hinic_ntuple_filter_ele *ntuple_filter_ptr;
struct hinic_ethertype_filter_ele *ethertype_filter_ptr;
struct hinic_fdir_rule_ele *fdir_rule_ptr;
struct hinic_flow_mem *hinic_flow_mem_ptr;
struct hinic_nic_dev *nic_dev = HINIC_ETH_DEV_TO_PRIVATE_NIC_DEV(dev);
while ((ntuple_filter_ptr =
TAILQ_FIRST(&nic_dev->filter_ntuple_list))) {
TAILQ_REMOVE(&nic_dev->filter_ntuple_list, ntuple_filter_ptr,
entries);
rte_free(ntuple_filter_ptr);
}
while ((ethertype_filter_ptr =
TAILQ_FIRST(&nic_dev->filter_ethertype_list))) {
TAILQ_REMOVE(&nic_dev->filter_ethertype_list,
ethertype_filter_ptr,
entries);
rte_free(ethertype_filter_ptr);
}
while ((fdir_rule_ptr =
TAILQ_FIRST(&nic_dev->filter_fdir_rule_list))) {
TAILQ_REMOVE(&nic_dev->filter_fdir_rule_list, fdir_rule_ptr,
entries);
rte_free(fdir_rule_ptr);
}
while ((hinic_flow_mem_ptr =
TAILQ_FIRST(&nic_dev->hinic_flow_list))) {
TAILQ_REMOVE(&nic_dev->hinic_flow_list, hinic_flow_mem_ptr,
entries);
rte_free(hinic_flow_mem_ptr->flow);
rte_free(hinic_flow_mem_ptr);
}
}
/* Destroy all flow rules associated with a port on hinic. */
static int hinic_flow_flush(struct rte_eth_dev *dev,
__rte_unused struct rte_flow_error *error)
{
struct hinic_nic_dev *nic_dev = HINIC_ETH_DEV_TO_PRIVATE_NIC_DEV(dev);
hinic_clear_all_ntuple_filter(dev);
hinic_clear_all_ethertype_filter(dev);
hinic_clear_all_fdir_filter(dev);
hinic_filterlist_flush(dev);
PMD_DRV_LOG(INFO, "Flush flow succeed, func_id: 0x%x",
hinic_global_func_id(nic_dev->hwdev));
return 0;
}
const struct rte_flow_ops hinic_flow_ops = {
.validate = hinic_flow_validate,
.create = hinic_flow_create,
.destroy = hinic_flow_destroy,
.flush = hinic_flow_flush,
};
Reference in New Issue View Git Blame Copy Permalink