/*
* This function is used to find rss general action.
* 1. As we know RSS is used to spread packets among several queues, the flow
- * API provide the struct rte_flow_action_rss, user could config it's field
+ * API provide the struct rte_flow_action_rss, user could config its field
* sush as: func/level/types/key/queue to control RSS function.
- * 2. The flow API also support queue region configuration for hns3. It was
+ * 2. The flow API also supports queue region configuration for hns3. It was
* implemented by FDIR + RSS in hns3 hardware, user can create one FDIR rule
* which action is RSS queues region.
* 3. When action is RSS, we use the following rule to distinguish:
rss = act->conf;
if (have_eth && rss->conf.queue_num) {
/*
- * Patter have ETH and action's queue_num > 0, indicate this is
+ * Pattern have ETH and action's queue_num > 0, indicate this is
* queue region configuration.
* Because queue region is implemented by FDIR + RSS in hns3
- * hardware, it need enter FDIR process, so here return NULL to
- * avoid enter RSS process.
+ * hardware, it needs to enter FDIR process, so here return NULL
+ * to avoid enter RSS process.
*/
return NULL;
}
ret = hns3_get_count(&hns->hw, flow->counter_id, &value);
if (ret) {
- rte_flow_error_set(error, -ret,
- RTE_FLOW_ERROR_TYPE_HANDLE,
+ rte_flow_error_set(error, -ret, RTE_FLOW_ERROR_TYPE_HANDLE,
NULL, "Read counter fail.");
return ret;
}
queue = (const struct rte_flow_action_queue *)action->conf;
if (queue->index >= hw->used_rx_queues) {
- hns3_err(hw, "queue ID(%d) is greater than number of "
- "available queue (%d) in driver.",
+ hns3_err(hw, "queue ID(%u) is greater than number of "
+ "available queue (%u) in driver.",
queue->index, hw->used_rx_queues);
return rte_flow_error_set(error, EINVAL,
RTE_FLOW_ERROR_TYPE_ACTION_CONF,
return 0;
}
-/* Parse to get the attr and action info of flow director rule. */
static int
hns3_check_attr(const struct rte_flow_attr *attr, struct rte_flow_error *error)
{
}
static int
-hns3_parse_eth(const struct rte_flow_item *item,
- struct hns3_fdir_rule *rule, struct rte_flow_error *error)
+hns3_parse_eth(const struct rte_flow_item *item, struct hns3_fdir_rule *rule,
+ struct rte_flow_error *error __rte_unused)
{
const struct rte_flow_item_eth *eth_spec;
const struct rte_flow_item_eth *eth_mask;
- if (item->spec == NULL && item->mask)
- return rte_flow_error_set(error, EINVAL,
- RTE_FLOW_ERROR_TYPE_ITEM, item,
- "Can't configure FDIR with mask but without spec");
-
/* Only used to describe the protocol stack. */
if (item->spec == NULL && item->mask == NULL)
return 0;
const struct rte_flow_item_vlan *vlan_spec;
const struct rte_flow_item_vlan *vlan_mask;
- if (item->spec == NULL && item->mask)
- return rte_flow_error_set(error, EINVAL,
- RTE_FLOW_ERROR_TYPE_ITEM, item,
- "Can't configure FDIR with mask but without spec");
-
rule->key_conf.vlan_num++;
if (rule->key_conf.vlan_num > VLAN_TAG_NUM_MAX)
return rte_flow_error_set(error, EINVAL,
return 0;
}
+static bool
+hns3_check_ipv4_mask_supported(const struct rte_flow_item_ipv4 *ipv4_mask)
+{
+ if (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)
+ return false;
+
+ return true;
+}
+
static int
hns3_parse_ipv4(const struct rte_flow_item *item, struct hns3_fdir_rule *rule,
struct rte_flow_error *error)
const struct rte_flow_item_ipv4 *ipv4_spec;
const struct rte_flow_item_ipv4 *ipv4_mask;
- if (item->spec == NULL && item->mask)
- return rte_flow_error_set(error, EINVAL,
- RTE_FLOW_ERROR_TYPE_ITEM, item,
- "Can't configure FDIR with mask but without spec");
-
hns3_set_bit(rule->input_set, INNER_ETH_TYPE, 1);
rule->key_conf.spec.ether_type = RTE_ETHER_TYPE_IPV4;
rule->key_conf.mask.ether_type = ETHER_TYPE_MASK;
+
/* Only used to describe the protocol stack. */
if (item->spec == NULL && item->mask == NULL)
return 0;
if (item->mask) {
ipv4_mask = item->mask;
-
- if (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) {
+ if (!hns3_check_ipv4_mask_supported(ipv4_mask)) {
return rte_flow_error_set(error, EINVAL,
RTE_FLOW_ERROR_TYPE_ITEM_MASK,
item,
const struct rte_flow_item_ipv6 *ipv6_spec;
const struct rte_flow_item_ipv6 *ipv6_mask;
- if (item->spec == NULL && item->mask)
- return rte_flow_error_set(error, EINVAL,
- RTE_FLOW_ERROR_TYPE_ITEM, item,
- "Can't configure FDIR with mask but without spec");
-
hns3_set_bit(rule->input_set, INNER_ETH_TYPE, 1);
rule->key_conf.spec.ether_type = RTE_ETHER_TYPE_IPV6;
rule->key_conf.mask.ether_type = ETHER_TYPE_MASK;
if (item->mask) {
ipv6_mask = item->mask;
- if (ipv6_mask->hdr.vtc_flow ||
- ipv6_mask->hdr.payload_len || ipv6_mask->hdr.hop_limits) {
+ if (ipv6_mask->hdr.vtc_flow || ipv6_mask->hdr.payload_len ||
+ ipv6_mask->hdr.hop_limits) {
return rte_flow_error_set(error, EINVAL,
RTE_FLOW_ERROR_TYPE_ITEM_MASK,
item,
return 0;
}
+static bool
+hns3_check_tcp_mask_supported(const struct rte_flow_item_tcp *tcp_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)
+ return false;
+
+ return true;
+}
+
static int
hns3_parse_tcp(const struct rte_flow_item *item, struct hns3_fdir_rule *rule,
struct rte_flow_error *error)
const struct rte_flow_item_tcp *tcp_spec;
const struct rte_flow_item_tcp *tcp_mask;
- if (item->spec == NULL && item->mask)
- return rte_flow_error_set(error, EINVAL,
- RTE_FLOW_ERROR_TYPE_ITEM, item,
- "Can't configure FDIR with mask but without spec");
-
hns3_set_bit(rule->input_set, INNER_IP_PROTO, 1);
rule->key_conf.spec.ip_proto = IPPROTO_TCP;
rule->key_conf.mask.ip_proto = IPPROTO_MASK;
if (item->mask) {
tcp_mask = 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) {
+ if (!hns3_check_tcp_mask_supported(tcp_mask)) {
return rte_flow_error_set(error, EINVAL,
RTE_FLOW_ERROR_TYPE_ITEM_MASK,
item,
const struct rte_flow_item_udp *udp_spec;
const struct rte_flow_item_udp *udp_mask;
- if (item->spec == NULL && item->mask)
- return rte_flow_error_set(error, EINVAL,
- RTE_FLOW_ERROR_TYPE_ITEM, item,
- "Can't configure FDIR with mask but without spec");
-
hns3_set_bit(rule->input_set, INNER_IP_PROTO, 1);
rule->key_conf.spec.ip_proto = IPPROTO_UDP;
rule->key_conf.mask.ip_proto = IPPROTO_MASK;
+
/* Only used to describe the protocol stack. */
if (item->spec == NULL && item->mask == NULL)
return 0;
const struct rte_flow_item_sctp *sctp_spec;
const struct rte_flow_item_sctp *sctp_mask;
- if (item->spec == NULL && item->mask)
- return rte_flow_error_set(error, EINVAL,
- RTE_FLOW_ERROR_TYPE_ITEM, item,
- "Can't configure FDIR with mask but without spec");
-
hns3_set_bit(rule->input_set, INNER_IP_PROTO, 1);
rule->key_conf.spec.ip_proto = IPPROTO_SCTP;
rule->key_conf.mask.ip_proto = IPPROTO_MASK;
RTE_FLOW_ERROR_TYPE_ITEM_MASK,
item,
"Only support src & dst port in SCTP");
-
if (sctp_mask->hdr.src_port) {
hns3_set_bit(rule->input_set, INNER_SRC_PORT, 1);
rule->key_conf.mask.src_port =
}
/*
- * Check items before tunnel, save inner configs to outer configs,and clear
+ * Check items before tunnel, save inner configs to outer configs, and clear
* inner configs.
* The key consists of two parts: meta_data and tuple keys.
* Meta data uses 15 bits, including vlan_num(2bit), des_port(12bit) and tunnel
const struct rte_flow_item_vxlan *vxlan_spec;
const struct rte_flow_item_vxlan *vxlan_mask;
- if (item->spec == NULL && item->mask)
- return rte_flow_error_set(error, EINVAL,
- RTE_FLOW_ERROR_TYPE_ITEM, item,
- "Can't configure FDIR with mask but without spec");
- else if (item->spec && (item->mask == NULL))
- return rte_flow_error_set(error, EINVAL,
- RTE_FLOW_ERROR_TYPE_ITEM, item,
- "Tunnel packets must configure with mask");
-
hns3_set_bit(rule->input_set, OUTER_DST_PORT, 1);
rule->key_conf.mask.tunnel_type = TUNNEL_TYPE_MASK;
if (item->type == RTE_FLOW_ITEM_TYPE_VXLAN)
const struct rte_flow_item_nvgre *nvgre_spec;
const struct rte_flow_item_nvgre *nvgre_mask;
- if (item->spec == NULL && item->mask)
- return rte_flow_error_set(error, EINVAL,
- RTE_FLOW_ERROR_TYPE_ITEM, item,
- "Can't configure FDIR with mask but without spec");
- else if (item->spec && (item->mask == NULL))
- return rte_flow_error_set(error, EINVAL,
- RTE_FLOW_ERROR_TYPE_ITEM, item,
- "Tunnel packets must configure with mask");
-
hns3_set_bit(rule->input_set, OUTER_IP_PROTO, 1);
rule->key_conf.spec.outer_proto = IPPROTO_GRE;
rule->key_conf.mask.outer_proto = IPPROTO_MASK;
const struct rte_flow_item_geneve *geneve_spec;
const struct rte_flow_item_geneve *geneve_mask;
- if (item->spec == NULL && item->mask)
- return rte_flow_error_set(error, EINVAL,
- RTE_FLOW_ERROR_TYPE_ITEM, item,
- "Can't configure FDIR with mask but without spec");
- else if (item->spec && (item->mask == NULL))
- return rte_flow_error_set(error, EINVAL,
- RTE_FLOW_ERROR_TYPE_ITEM, item,
- "Tunnel packets must configure with mask");
-
hns3_set_bit(rule->input_set, OUTER_DST_PORT, 1);
rule->key_conf.spec.tunnel_type = HNS3_TUNNEL_TYPE_GENEVE;
rule->key_conf.mask.tunnel_type = TUNNEL_TYPE_MASK;
{
int ret;
+ if (item->spec == NULL && item->mask)
+ return rte_flow_error_set(error, EINVAL,
+ RTE_FLOW_ERROR_TYPE_ITEM, item,
+ "Can't configure FDIR with mask "
+ "but without spec");
+ else if (item->spec && (item->mask == NULL))
+ return rte_flow_error_set(error, EINVAL,
+ RTE_FLOW_ERROR_TYPE_ITEM, item,
+ "Tunnel packets must configure "
+ "with mask");
+
switch (item->type) {
case RTE_FLOW_ITEM_TYPE_VXLAN:
case RTE_FLOW_ITEM_TYPE_VXLAN_GPE:
}
static int
-hns3_parse_normal(const struct rte_flow_item *item,
- struct hns3_fdir_rule *rule,
+hns3_parse_normal(const struct rte_flow_item *item, struct hns3_fdir_rule *rule,
struct items_step_mngr *step_mngr,
struct rte_flow_error *error)
{
int ret;
+ if (item->spec == NULL && item->mask)
+ return rte_flow_error_set(error, EINVAL,
+ RTE_FLOW_ERROR_TYPE_ITEM, item,
+ "Can't configure FDIR with mask "
+ "but without spec");
+
switch (item->type) {
case RTE_FLOW_ITEM_TYPE_ETH:
ret = hns3_parse_eth(item, rule, error);
RTE_FLOW_ERROR_TYPE_HANDLE, NULL,
"Fdir not supported in VF");
- if (dev->data->dev_conf.fdir_conf.mode != RTE_FDIR_MODE_PERFECT)
- return rte_flow_error_set(error, ENOTSUP,
- RTE_FLOW_ERROR_TYPE_HANDLE, NULL,
- "fdir_conf.mode isn't perfect");
-
step_mngr.items = first_items;
step_mngr.count = ARRAY_SIZE(first_items);
for (item = pattern; item->type != RTE_FLOW_ITEM_TYPE_END; item++) {
if (comp->func == RTE_ETH_HASH_FUNCTION_MAX)
func_is_same = false;
else
- func_is_same = (with->func ? (comp->func == with->func) : true);
+ func_is_same = with->func ? (comp->func == with->func) : true;
return (func_is_same &&
comp->types == (with->types & HNS3_ETH_RSS_SUPPORT) &&
.key_len = in->key_len,
.queue_num = in->queue_num,
};
- out->conf.queue =
- memcpy(out->queue, in->queue,
- sizeof(*in->queue) * in->queue_num);
+ out->conf.queue = memcpy(out->queue, in->queue,
+ sizeof(*in->queue) * in->queue_num);
if (in->key)
out->conf.key = memcpy(out->key, in->key, in->key_len);
return 0;
}
+static bool
+hns3_rss_input_tuple_supported(struct hns3_hw *hw,
+ const struct rte_flow_action_rss *rss)
+{
+ /*
+ * For IP packet, it is not supported to use src/dst port fields to RSS
+ * hash for the following packet types.
+ * - IPV4 FRAG | IPV4 NONFRAG | IPV6 FRAG | IPV6 NONFRAG
+ * Besides, for Kunpeng920, the NIC HW is not supported to use src/dst
+ * port fields to RSS hash for IPV6 SCTP packet type. However, the
+ * Kunpeng930 and future kunpeng series support to use src/dst port
+ * fields to RSS hash for IPv6 SCTP packet type.
+ */
+ if (rss->types & (ETH_RSS_L4_DST_ONLY | ETH_RSS_L4_SRC_ONLY) &&
+ (rss->types & ETH_RSS_IP ||
+ (!hw->rss_info.ipv6_sctp_offload_supported &&
+ rss->types & ETH_RSS_NONFRAG_IPV6_SCTP)))
+ return false;
+
+ return true;
+}
+
/*
* This function is used to parse rss action validatation.
*/
RTE_FLOW_ERROR_TYPE_ACTION_CONF, act,
"RSS hash key must be exactly 40 bytes");
- /*
- * For Kunpeng920 and Kunpeng930 NIC hardware, it is not supported to
- * use dst port/src port fields to RSS hash for the following packet
- * types.
- * - IPV4 FRAG | IPV4 NONFRAG | IPV6 FRAG | IPV6 NONFRAG
- * Besides, for Kunpeng920, The NIC hardware is not supported to use
- * src/dst port fields to RSS hash for IPV6 SCTP packet type.
- */
- if (rss->types & (ETH_RSS_L4_DST_ONLY | ETH_RSS_L4_SRC_ONLY) &&
- (rss->types & ETH_RSS_IP ||
- (!hw->rss_info.ipv6_sctp_offload_supported &&
- rss->types & ETH_RSS_NONFRAG_IPV6_SCTP)))
+ if (!hns3_rss_input_tuple_supported(hw, rss))
return rte_flow_error_set(error, EINVAL,
RTE_FLOW_ERROR_TYPE_ACTION_CONF,
&rss->types,
*hash_algo = HNS3_RSS_HASH_ALGO_SYMMETRIC_TOEP;
break;
default:
- hns3_err(hw, "Invalid RSS algorithm configuration(%u)",
+ hns3_err(hw, "Invalid RSS algorithm configuration(%d)",
algo_func);
return -EINVAL;
}
if (ret)
return ret;
- ret = hns3_set_rss_algo_key(hw, rss_config->key);
+ ret = hns3_rss_set_algo_key(hw, rss_config->key);
if (ret)
return ret;
- /* Update algorithm of hw */
hw->rss_info.conf.func = rss_config->func;
- /* Set flow type supported */
tuple = &hw->rss_info.rss_tuple_sets;
ret = hns3_set_rss_tuple_by_rss_hf(hw, tuple, rss_config->types);
if (ret)
if (rss_flow_conf.queue_num) {
/*
* Due the content of queue pointer have been reset to
- * 0, the rss_info->conf.queue should be set NULL
+ * 0, the rss_info->conf.queue should be set to NULL
*/
rss_info->conf.queue = NULL;
rss_info->conf.queue_num = 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.
+ * We will let it use the filter which it hit first.
* So, the sequence matters.
*/
static struct rte_flow *
flow = rte_zmalloc("hns3 flow", sizeof(struct rte_flow), 0);
if (flow == NULL) {
- rte_flow_error_set(error, ENOMEM,
- RTE_FLOW_ERROR_TYPE_HANDLE, NULL,
- "Failed to allocate flow memory");
+ rte_flow_error_set(error, ENOMEM, RTE_FLOW_ERROR_TYPE_HANDLE,
+ NULL, "Failed to allocate flow memory");
return NULL;
}
flow_node = rte_zmalloc("hns3 flow node",
sizeof(struct hns3_flow_mem), 0);
if (flow_node == NULL) {
- rte_flow_error_set(error, ENOMEM,
- RTE_FLOW_ERROR_TYPE_HANDLE, NULL,
- "Failed to allocate flow list memory");
+ rte_flow_error_set(error, ENOMEM, RTE_FLOW_ERROR_TYPE_HANDLE,
+ NULL, "Failed to allocate flow list memory");
rte_free(flow);
return NULL;
}
return rte_flow_error_set(error, EINVAL,
RTE_FLOW_ERROR_TYPE_HANDLE,
flow, "Flow is NULL");
+
filter_type = flow->filter_type;
switch (filter_type) {
case RTE_ETH_FILTER_FDIR:
git.droids-corp.org / dpdk.git / blobdiff