net/mlx4: merge interrupt collector function

[dpdk.git] / drivers / net / ixgbe / ixgbe_flow.c

diff --git a/drivers/net/ixgbe/ixgbe_flow.c b/drivers/net/ixgbe/ixgbe_flow.c
index 7a5c3f9..c8645f0 100644 (file)
--- a/drivers/net/ixgbe/ixgbe_flow.c
+++ b/drivers/net/ixgbe/ixgbe_flow.c
@@ -266,7 +266,8 @@ cons_parse_ntuple_filter(const struct rte_flow_attr *attr,
        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_SCTP) {
+           item->type != RTE_FLOW_ITEM_TYPE_SCTP &&
+           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,
@@ -275,7 +276,8 @@ cons_parse_ntuple_filter(const struct rte_flow_attr *attr,
        }
 
        /* get the TCP/UDP info */
-       if (!item->spec || !item->mask) {
+       if ((item->type != RTE_FLOW_ITEM_TYPE_END) &&
+               (!item->spec || !item->mask)) {
                memset(filter, 0, sizeof(struct rte_eth_ntuple_filter));
                rte_flow_error_set(error, EINVAL,
                        RTE_FLOW_ERROR_TYPE_ITEM,
@@ -355,7 +357,7 @@ cons_parse_ntuple_filter(const struct rte_flow_attr *attr,
                udp_spec = (const struct rte_flow_item_udp *)item->spec;
                filter->dst_port = udp_spec->hdr.dst_port;
                filter->src_port = udp_spec->hdr.src_port;
-       } else {
+       } else if (item->type == RTE_FLOW_ITEM_TYPE_SCTP) {
                sctp_mask = (const struct rte_flow_item_sctp *)item->mask;
 
                /**
@@ -378,6 +380,8 @@ cons_parse_ntuple_filter(const struct rte_flow_attr *attr,
                sctp_spec = (const struct rte_flow_item_sctp *)item->spec;
                filter->dst_port = sctp_spec->hdr.dst_port;
                filter->src_port = sctp_spec->hdr.src_port;
+       } else {
+               goto action;
        }
 
        /* check if the next not void item is END */
@@ -390,6 +394,8 @@ cons_parse_ntuple_filter(const struct rte_flow_attr *attr,
                return -rte_errno;
        }
 
+action:
+
        /**
         * n-tuple only supports forwarding,
         * check if the first not void action is QUEUE.
@@ -2579,8 +2585,8 @@ step_next:
 
        if (hw->mac.type == ixgbe_mac_82599EB &&
                rule->fdirflags == IXGBE_FDIRCMD_DROP &&
-               (rule->mask.src_port_mask != 0 ||
-               rule->mask.dst_port_mask != 0))
+               (rule->ixgbe_fdir.formatted.src_port != 0 ||
+               rule->ixgbe_fdir.formatted.dst_port != 0))
                return -ENOTSUP;
 
        if (fdir_mode == RTE_FDIR_MODE_NONE ||
@@ -2675,6 +2681,7 @@ ixgbe_flow_create(struct rte_eth_dev *dev,
        struct ixgbe_eth_l2_tunnel_conf_ele *l2_tn_filter_ptr;
        struct ixgbe_fdir_rule_ele *fdir_rule_ptr;
        struct ixgbe_flow_mem *ixgbe_flow_mem_ptr;
+       uint8_t first_mask = FALSE;
 
        flow = rte_zmalloc("ixgbe_rte_flow", sizeof(struct rte_flow), 0);
        if (!flow) {
@@ -2700,6 +2707,10 @@ ixgbe_flow_create(struct rte_eth_dev *dev,
                if (!ret) {
                        ntuple_filter_ptr = rte_zmalloc("ixgbe_ntuple_filter",
                                sizeof(struct ixgbe_ntuple_filter_ele), 0);
+                       if (!ntuple_filter_ptr) {
+                               PMD_DRV_LOG(ERR, "failed to allocate memory");
+                               goto out;
+                       }
                        (void)rte_memcpy(&ntuple_filter_ptr->filter_info,
                                &ntuple_filter,
                                sizeof(struct rte_eth_ntuple_filter));
@@ -2722,6 +2733,10 @@ ixgbe_flow_create(struct rte_eth_dev *dev,
                        ethertype_filter_ptr = rte_zmalloc(
                                "ixgbe_ethertype_filter",
                                sizeof(struct ixgbe_ethertype_filter_ele), 0);
+                       if (!ethertype_filter_ptr) {
+                               PMD_DRV_LOG(ERR, "failed to allocate memory");
+                               goto out;
+                       }
                        (void)rte_memcpy(&ethertype_filter_ptr->filter_info,
                                &ethertype_filter,
                                sizeof(struct rte_eth_ethertype_filter));
@@ -2742,6 +2757,10 @@ ixgbe_flow_create(struct rte_eth_dev *dev,
                if (!ret) {
                        syn_filter_ptr = rte_zmalloc("ixgbe_syn_filter",
                                sizeof(struct ixgbe_eth_syn_filter_ele), 0);
+                       if (!syn_filter_ptr) {
+                               PMD_DRV_LOG(ERR, "failed to allocate memory");
+                               goto out;
+                       }
                        (void)rte_memcpy(&syn_filter_ptr->filter_info,
                                &syn_filter,
                                sizeof(struct rte_eth_syn_filter));
@@ -2778,6 +2797,7 @@ ixgbe_flow_create(struct rte_eth_dev *dev,
                                        goto out;
 
                                fdir_info->mask_added = TRUE;
+                               first_mask = TRUE;
                        } else {
                                /**
                                 * Only support one global mask,
@@ -2801,6 +2821,10 @@ ixgbe_flow_create(struct rte_eth_dev *dev,
                        if (!ret) {
                                fdir_rule_ptr = rte_zmalloc("ixgbe_fdir_filter",
                                        sizeof(struct ixgbe_fdir_rule_ele), 0);
+                               if (!fdir_rule_ptr) {
+                                       PMD_DRV_LOG(ERR, "failed to allocate memory");
+                                       goto out;
+                               }
                                (void)rte_memcpy(&fdir_rule_ptr->filter_info,
                                        &fdir_rule,
                                        sizeof(struct ixgbe_fdir_rule));
@@ -2812,8 +2836,15 @@ ixgbe_flow_create(struct rte_eth_dev *dev,
                                return flow;
                        }
 
-                       if (ret)
+                       if (ret) {
+                               /**
+                                * clean the mask_added flag if fail to
+                                * program
+                                **/
+                               if (first_mask)
+                                       fdir_info->mask_added = FALSE;
                                goto out;
+                       }
                }
 
                goto out;
@@ -2827,6 +2858,10 @@ ixgbe_flow_create(struct rte_eth_dev *dev,
                if (!ret) {
                        l2_tn_filter_ptr = rte_zmalloc("ixgbe_l2_tn_filter",
                                sizeof(struct ixgbe_eth_l2_tunnel_conf_ele), 0);
+                       if (!l2_tn_filter_ptr) {
+                               PMD_DRV_LOG(ERR, "failed to allocate memory");
+                               goto out;
+                       }
                        (void)rte_memcpy(&l2_tn_filter_ptr->filter_info,
                                &l2_tn_filter,
                                sizeof(struct rte_eth_l2_tunnel_conf));