#include <stdarg.h>
#include <rte_debug.h>
#include <rte_ether.h>
-#include <rte_ethdev_driver.h>
+#include <ethdev_driver.h>
#include <rte_log.h>
#include <rte_malloc.h>
#include <rte_eth_ctrl.h>
static struct
ice_pattern_match_item ice_acl_pattern[] = {
- {pattern_eth_ipv4, ICE_ACL_INSET_ETH_IPV4, ICE_INSET_NONE},
- {pattern_eth_ipv4_udp, ICE_ACL_INSET_ETH_IPV4_UDP, ICE_INSET_NONE},
- {pattern_eth_ipv4_tcp, ICE_ACL_INSET_ETH_IPV4_TCP, ICE_INSET_NONE},
- {pattern_eth_ipv4_sctp, ICE_ACL_INSET_ETH_IPV4_SCTP, ICE_INSET_NONE},
+ {pattern_eth_ipv4, ICE_ACL_INSET_ETH_IPV4, ICE_INSET_NONE, ICE_INSET_NONE},
+ {pattern_eth_ipv4_udp, ICE_ACL_INSET_ETH_IPV4_UDP, ICE_INSET_NONE, ICE_INSET_NONE},
+ {pattern_eth_ipv4_tcp, ICE_ACL_INSET_ETH_IPV4_TCP, ICE_INSET_NONE, ICE_INSET_NONE},
+ {pattern_eth_ipv4_sctp, ICE_ACL_INSET_ETH_IPV4_SCTP, ICE_INSET_NONE, ICE_INSET_NONE},
};
static int
eth_mask = item->mask;
if (eth_spec && eth_mask) {
+ if (rte_is_broadcast_ether_addr(ð_mask->src) ||
+ rte_is_broadcast_ether_addr(ð_mask->dst)) {
+ rte_flow_error_set(error, EINVAL,
+ RTE_FLOW_ERROR_TYPE_ITEM,
+ item, "Invalid mac addr mask");
+ return -rte_errno;
+ }
+
if (!rte_is_zero_ether_addr(ð_spec->src) &&
!rte_is_zero_ether_addr(ð_mask->src)) {
input_set |= ICE_INSET_SMAC;
return -rte_errno;
}
+ if (ipv4_mask->hdr.src_addr == UINT32_MAX ||
+ ipv4_mask->hdr.dst_addr == UINT32_MAX) {
+ rte_flow_error_set(error, EINVAL,
+ RTE_FLOW_ERROR_TYPE_ITEM,
+ item,
+ "Invalid IPv4 mask.");
+ return -rte_errno;
+ }
+
if (ipv4_mask->hdr.src_addr) {
filter->input.ip.v4.src_ip =
ipv4_spec->hdr.src_addr;
return -rte_errno;
}
+ if (tcp_mask->hdr.src_port == UINT16_MAX ||
+ tcp_mask->hdr.dst_port == UINT16_MAX) {
+ rte_flow_error_set(error, EINVAL,
+ RTE_FLOW_ERROR_TYPE_ITEM,
+ item,
+ "Invalid TCP mask");
+ return -rte_errno;
+ }
+
if (l3 == RTE_FLOW_ITEM_TYPE_IPV4 &&
tcp_mask->hdr.src_port) {
input_set |= ICE_INSET_TCP_SRC_PORT;
return -rte_errno;
}
+ if (udp_mask->hdr.src_port == UINT16_MAX ||
+ udp_mask->hdr.dst_port == UINT16_MAX) {
+ rte_flow_error_set(error, EINVAL,
+ RTE_FLOW_ERROR_TYPE_ITEM,
+ item,
+ "Invalid UDP mask");
+ return -rte_errno;
+ }
+
if (l3 == RTE_FLOW_ITEM_TYPE_IPV4 &&
udp_mask->hdr.src_port) {
input_set |= ICE_INSET_UDP_SRC_PORT;
flow_type = ICE_FLTR_PTYPE_NONF_IPV4_SCTP;
if (sctp_spec && sctp_mask) {
+ if (sctp_mask->hdr.src_port == UINT16_MAX ||
+ sctp_mask->hdr.dst_port == UINT16_MAX) {
+ rte_flow_error_set(error, EINVAL,
+ RTE_FLOW_ERROR_TYPE_ITEM,
+ item,
+ "Invalid SCTP mask");
+ return -rte_errno;
+ }
+
if (l3 == RTE_FLOW_ITEM_TYPE_IPV4 &&
sctp_mask->hdr.src_port) {
input_set |= ICE_INSET_SCTP_SRC_PORT;
int ret;
memset(filter, 0, sizeof(*filter));
- item = ice_search_pattern_match_item(pattern, array, array_len, error);
+ item = ice_search_pattern_match_item(ad, pattern, array, array_len,
+ error);
if (!item)
return -rte_errno;
if (ret)
goto error;
input_set = filter->input_set;
- if (!input_set || input_set & ~item->input_set_mask) {
+ if (!input_set || input_set & ~item->input_set_mask_o) {
rte_flow_error_set(error, EINVAL,
RTE_FLOW_ERROR_TYPE_ITEM_SPEC,
pattern,
struct ice_hw *hw = ICE_PF_TO_HW(pf);
struct ice_flow_parser *parser = &ice_acl_parser;
+ if (!ad->hw.dcf_enabled)
+ return 0;
+
ret = ice_acl_prof_alloc(hw);
if (ret) {
PMD_DRV_LOG(ERR, "Cannot allocate memory for "
struct ice_hw *hw = ICE_PF_TO_HW(pf);
struct ice_flow_parser *parser = &ice_acl_parser;
- ice_unregister_parser(parser, ad);
-
- ice_deinit_acl(pf);
- ice_acl_prof_free(hw);
+ if (ad->hw.dcf_enabled) {
+ ice_unregister_parser(parser, ad);
+ ice_deinit_acl(pf);
+ ice_acl_prof_free(hw);
+ }
}
static struct