net/i40e: support ESP in flow director

add fill_ip6_head()
hardcode udp destination port to 4500
handle ESP and AH pctypes in ESP-AH profile
update the i40e user guide with ESP information.
update release notes for i40e changes

Signed-off-by: Bernard Iremonger <bernard.iremonger@intel.com>
Acked-by: Qi Zhang <qi.z.zhang@intel.com>

diff --git a/doc/guides/nics/i40e.rst b/doc/guides/nics/i40e.rst
index c7c34b6..0cd27fc 100644 (file)
--- a/doc/guides/nics/i40e.rst
+++ b/doc/guides/nics/i40e.rst
@@ -459,7 +459,7 @@ which is used to configure hardware by downloading a profile to support
 protocols/filters which are not supported by default. The DDP
 functionality requires a NIC firmware version of 6.0 or greater.
 
-Current implementation supports GTP-C/GTP-U/PPPoE/PPPoL2TP,
+Current implementation supports GTP-C/GTP-U/PPPoE/PPPoL2TP/ESP,
 steering can be used with rte_flow API.
 
 GTPv1 package is released, and it can be downloaded from
@@ -468,6 +468,8 @@ https://downloadcenter.intel.com/download/27587.
 PPPoE package is released, and it can be downloaded from
 https://downloadcenter.intel.com/download/28040.
 
+ESP-AH package is not released yet.
+
 Load a profile which supports GTP and store backup profile:
 
 .. code-block:: console

diff --git a/doc/guides/rel_notes/release_20_02.rst b/doc/guides/rel_notes/release_20_02.rst
index 17b8cdc..b6f915b 100644 (file)
--- a/doc/guides/rel_notes/release_20_02.rst
+++ b/doc/guides/rel_notes/release_20_02.rst
@@ -77,6 +77,11 @@ New Features
   Updated the i40e PMD to support L2TPv3 over IP profiles which can be
   programmed by the dynamic device personalization (DDP) process.
 
+* **Updated i40e driver to support ESP.**
+
+  Updated the i40e PMD to support ESP-AH supporting profiles which can be
+  programmed by the dynamic device personalization (DDP) process.
+
 * **Updated Mellanox mlx5 driver.**
 
   Updated Mellanox mlx5 driver with new features and improvements, including:

diff --git a/drivers/net/i40e/i40e_fdir.c b/drivers/net/i40e/i40e_fdir.c
index 2fc0995..c346073 100644 (file)
--- a/drivers/net/i40e/i40e_fdir.c
+++ b/drivers/net/i40e/i40e_fdir.c
@@ -58,6 +58,8 @@
 #define I40E_FDIR_GTP_MSG_TYPE_0X01         0x01
 #define I40E_FDIR_GTP_MSG_TYPE_0XFF         0xFF
 
+#define I40E_FDIR_ESP_DST_PORT              4500
+
 /* Wait time for fdir filter programming */
 #define I40E_FDIR_MAX_WAIT_US 10000
 
@@ -974,6 +976,37 @@ i40e_flow_fdir_find_customized_pctype(struct i40e_pf *pf, uint8_t pctype)
        return NULL;
 }
 
+static inline int
+fill_ip6_head(const struct i40e_fdir_input *fdir_input, unsigned char *raw_pkt,
+               uint8_t next_proto, uint8_t len, uint16_t *ether_type)
+{
+       struct rte_ipv6_hdr *ip6;
+
+       ip6 = (struct rte_ipv6_hdr *)raw_pkt;
+
+       *ether_type = rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV6);
+       ip6->vtc_flow = rte_cpu_to_be_32(I40E_FDIR_IPv6_DEFAULT_VTC_FLOW |
+               (fdir_input->flow.ipv6_flow.tc << I40E_FDIR_IPv6_TC_OFFSET));
+       ip6->payload_len = rte_cpu_to_be_16(I40E_FDIR_IPv6_PAYLOAD_LEN);
+       ip6->proto = fdir_input->flow.ipv6_flow.proto ?
+               fdir_input->flow.ipv6_flow.proto : next_proto;
+       ip6->hop_limits = fdir_input->flow.ipv6_flow.hop_limits ?
+               fdir_input->flow.ipv6_flow.hop_limits :
+               I40E_FDIR_IPv6_DEFAULT_HOP_LIMITS;
+       /**
+        * The source and destination fields in the transmitted packet
+        * need to be presented in a reversed order with respect
+        * to the expected received packets.
+        */
+       rte_memcpy(&ip6->src_addr, &fdir_input->flow.ipv6_flow.dst_ip,
+               IPV6_ADDR_LEN);
+       rte_memcpy(&ip6->dst_addr, &fdir_input->flow.ipv6_flow.src_ip,
+               IPV6_ADDR_LEN);
+       len += sizeof(struct rte_ipv6_hdr);
+
+       return len;
+}
+
 static inline int
 i40e_flow_fdir_fill_eth_ip_head(struct i40e_pf *pf,
                                const struct i40e_fdir_input *fdir_input,
@@ -1054,18 +1087,32 @@ i40e_flow_fdir_fill_eth_ip_head(struct i40e_pf *pf,
                ip->src_addr = fdir_input->flow.ip4_flow.dst_ip;
                ip->dst_addr = fdir_input->flow.ip4_flow.src_ip;
 
-               if (!is_customized_pctype)
+               if (!is_customized_pctype) {
                        ip->next_proto_id = fdir_input->flow.ip4_flow.proto ?
                                fdir_input->flow.ip4_flow.proto :
                                next_proto[fdir_input->pctype];
-               else if (cus_pctype->index == I40E_CUSTOMIZED_GTPC ||
+                       len += sizeof(struct rte_ipv4_hdr);
+               } else if (cus_pctype->index == I40E_CUSTOMIZED_GTPC ||
                         cus_pctype->index == I40E_CUSTOMIZED_GTPU_IPV4 ||
                         cus_pctype->index == I40E_CUSTOMIZED_GTPU_IPV6 ||
-                        cus_pctype->index == I40E_CUSTOMIZED_GTPU)
+                        cus_pctype->index == I40E_CUSTOMIZED_GTPU) {
                        ip->next_proto_id = IPPROTO_UDP;
-               else if (cus_pctype->index == I40E_CUSTOMIZED_IPV4_L2TPV3)
+                       len += sizeof(struct rte_ipv4_hdr);
+               } else if (cus_pctype->index == I40E_CUSTOMIZED_IPV4_L2TPV3) {
                        ip->next_proto_id = IPPROTO_L2TP;
-               len += sizeof(struct rte_ipv4_hdr);
+                       len += sizeof(struct rte_ipv4_hdr);
+               } else if (cus_pctype->index == I40E_CUSTOMIZED_ESP_IPV4) {
+                       ip->next_proto_id = IPPROTO_ESP;
+                       len += sizeof(struct rte_ipv4_hdr);
+               } else if (cus_pctype->index == I40E_CUSTOMIZED_ESP_IPV4_UDP) {
+                       ip->next_proto_id = IPPROTO_UDP;
+                       len += sizeof(struct rte_ipv4_hdr);
+               } else if (cus_pctype->index == I40E_CUSTOMIZED_ESP_IPV6)
+                       len = fill_ip6_head(fdir_input, raw_pkt, IPPROTO_ESP,
+                                       len, ether_type);
+               else if (cus_pctype->index == I40E_CUSTOMIZED_ESP_IPV6_UDP)
+                       len = fill_ip6_head(fdir_input, raw_pkt, IPPROTO_UDP,
+                                       len, ether_type);
        } else if (pctype == I40E_FILTER_PCTYPE_NONF_IPV6_TCP ||
                   pctype == I40E_FILTER_PCTYPE_NONF_IPV6_UDP ||
                   pctype == I40E_FILTER_PCTYPE_NONF_IPV6_SCTP ||
@@ -1104,8 +1151,7 @@ i40e_flow_fdir_fill_eth_ip_head(struct i40e_pf *pf,
                           IPV6_ADDR_LEN);
                len += sizeof(struct rte_ipv6_hdr);
        } else {
-               PMD_DRV_LOG(ERR, "unknown pctype %u.",
-                           fdir_input->pctype);
+               PMD_DRV_LOG(ERR, "unknown pctype %u.", fdir_input->pctype);
                return -1;
        }
 
@@ -1132,6 +1178,10 @@ i40e_flow_fdir_construct_pkt(struct i40e_pf *pf,
        struct rte_ipv4_hdr *gtp_ipv4;
        struct rte_ipv6_hdr *gtp_ipv6;
        struct rte_flow_item_l2tpv3oip *l2tpv3oip;
+       struct rte_flow_item_esp *esp;
+       struct rte_ipv4_hdr *esp_ipv4;
+       struct rte_ipv6_hdr *esp_ipv6;
+
        uint8_t size, dst = 0;
        uint8_t i, pit_idx, set_idx = I40E_FLXPLD_L4_IDX; /* use l4 by default*/
        int len;
@@ -1315,10 +1365,71 @@ i40e_flow_fdir_construct_pkt(struct i40e_pf *pf,
                                 fdir_input->flow.ip6_l2tpv3oip_flow.session_id;
                        payload = (unsigned char *)l2tpv3oip +
                                sizeof(struct rte_flow_item_l2tpv3oip);
+               } else if (cus_pctype->index == I40E_CUSTOMIZED_ESP_IPV4 ||
+                       cus_pctype->index == I40E_CUSTOMIZED_ESP_IPV6 ||
+                       cus_pctype->index == I40E_CUSTOMIZED_ESP_IPV4_UDP ||
+                       cus_pctype->index == I40E_CUSTOMIZED_ESP_IPV6_UDP) {
+                       if (cus_pctype->index == I40E_CUSTOMIZED_ESP_IPV4) {
+                               esp_ipv4 = (struct rte_ipv4_hdr *)
+                                       (raw_pkt + len);
+                               esp = (struct rte_flow_item_esp *)esp_ipv4;
+                               esp->hdr.spi =
+                                       fdir_input->flow.esp_ipv4_flow.spi;
+                               payload = (unsigned char *)esp +
+                                       sizeof(struct rte_esp_hdr);
+                               len += sizeof(struct rte_esp_hdr);
+                       } else if (cus_pctype->index ==
+                                       I40E_CUSTOMIZED_ESP_IPV4_UDP) {
+                               esp_ipv4 = (struct rte_ipv4_hdr *)
+                                       (raw_pkt + len);
+                               udp = (struct rte_udp_hdr *)esp_ipv4;
+                               udp->dst_port = rte_cpu_to_be_16
+                                       (I40E_FDIR_ESP_DST_PORT);
+
+                               udp->dgram_len = rte_cpu_to_be_16
+                                               (I40E_FDIR_UDP_DEFAULT_LEN);
+                               esp = (struct rte_flow_item_esp *)
+                                       ((unsigned char *)esp_ipv4 +
+                                               sizeof(struct rte_udp_hdr));
+                               esp->hdr.spi =
+                                       fdir_input->flow.esp_ipv4_udp_flow.spi;
+                               payload = (unsigned char *)esp +
+                                       sizeof(struct rte_esp_hdr);
+                               len += sizeof(struct rte_udp_hdr) +
+                                               sizeof(struct rte_esp_hdr);
+                       } else if (cus_pctype->index ==
+                                       I40E_CUSTOMIZED_ESP_IPV6) {
+                               esp_ipv6 = (struct rte_ipv6_hdr *)
+                                       (raw_pkt + len);
+                               esp = (struct rte_flow_item_esp *)esp_ipv6;
+                               esp->hdr.spi =
+                                       fdir_input->flow.esp_ipv6_flow.spi;
+                               payload = (unsigned char *)esp +
+                                       sizeof(struct rte_esp_hdr);
+                               len += sizeof(struct rte_esp_hdr);
+                       } else if (cus_pctype->index ==
+                                       I40E_CUSTOMIZED_ESP_IPV6_UDP) {
+                               esp_ipv6 = (struct rte_ipv6_hdr *)
+                                       (raw_pkt + len);
+                               udp = (struct rte_udp_hdr *)esp_ipv6;
+                               udp->dst_port = rte_cpu_to_be_16
+                                       (I40E_FDIR_ESP_DST_PORT);
+
+                               udp->dgram_len = rte_cpu_to_be_16
+                                       (I40E_FDIR_UDP_DEFAULT_LEN);
+                               esp = (struct rte_flow_item_esp *)
+                                       ((unsigned char *)esp_ipv6 +
+                                               sizeof(struct rte_udp_hdr));
+                               esp->hdr.spi =
+                                       fdir_input->flow.esp_ipv6_udp_flow.spi;
+                               payload = (unsigned char *)esp +
+                                       sizeof(struct rte_esp_hdr);
+                               len += sizeof(struct rte_udp_hdr) +
+                                               sizeof(struct rte_esp_hdr);
+                       }
                }
        } else {
-               PMD_DRV_LOG(ERR, "unknown pctype %u.",
-                           fdir_input->pctype);
+               PMD_DRV_LOG(ERR, "unknown pctype %u.", fdir_input->pctype);
                return -1;
        }