examples/tep_termination/vxlan.c

   1 /*-
   2  *   BSD LICENSE
   3  *
   4  *   Copyright(c) 2010-2015 Intel Corporation. All rights reserved.
   5  *   All rights reserved.
   6  *
   7  *   Redistribution and use in source and binary forms, with or without
   8  *   modification, are permitted provided that the following conditions
   9  *   are met:
  10  *
  11  * Redistributions of source code must retain the above copyright
  12  *       notice, this list of conditions and the following disclaimer.
  13  *     * Redistributions in binary form must reproduce the above copyright
  14  *       notice, this list of conditions and the following disclaimer in
  15  *       the documentation and/or other materials provided with the
  16  *       distribution.
  17  *     * Neither the name of Intel Corporation nor the names of its
  18  *       contributors may be used to endorse or promote products derived
  19  *       from this software without specific prior written permission.
  20  *
  21  *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  22  *   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  23  *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  24  *   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  25  *   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  26  *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  27  *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  28  *   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  29  *   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  30  *   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  31  *   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  32  */
  33 #include <stdint.h>
  34 #include <rte_mbuf.h>
  35 #include <rte_hash_crc.h>
  36 #include <rte_byteorder.h>
  37 #include <rte_udp.h>
  38 #include <rte_tcp.h>
  39 #include <rte_sctp.h>
  40
  41 #include "main.h"
  42 #include "vxlan.h"
  43
  44 static uint16_t
  45 get_psd_sum(void *l3_hdr, uint16_t ethertype, uint64_t ol_flags)
  46 {
  47         if (ethertype == ETHER_TYPE_IPv4)
  48                 return rte_ipv4_phdr_cksum(l3_hdr, ol_flags);
  49         else /* assume ethertype == ETHER_TYPE_IPv6 */
  50                 return rte_ipv6_phdr_cksum(l3_hdr, ol_flags);
  51 }
  52
  53 /**
  54  * Parse an ethernet header to fill the ethertype, outer_l2_len, outer_l3_len and
  55  * ipproto. This function is able to recognize IPv4/IPv6 with one optional vlan
  56  * header.
  57  */
  58 static void
  59 parse_ethernet(struct ether_hdr *eth_hdr, union tunnel_offload_info *info,
  60                 uint8_t *l4_proto)
  61 {
  62         struct ipv4_hdr *ipv4_hdr;
  63         struct ipv6_hdr *ipv6_hdr;
  64         uint16_t ethertype;
  65
  66         info->outer_l2_len = sizeof(struct ether_hdr);
  67         ethertype = rte_be_to_cpu_16(eth_hdr->ether_type);
  68
  69         if (ethertype == ETHER_TYPE_VLAN) {
  70                 struct vlan_hdr *vlan_hdr = (struct vlan_hdr *)(eth_hdr + 1);
  71                 info->outer_l2_len  += sizeof(struct vlan_hdr);
  72                 ethertype = rte_be_to_cpu_16(vlan_hdr->eth_proto);
  73         }
  74
  75         switch (ethertype) {
  76         case ETHER_TYPE_IPv4:
  77                 ipv4_hdr = (struct ipv4_hdr *)
  78                         ((char *)eth_hdr + info->outer_l2_len);
  79                 info->outer_l3_len = sizeof(struct ipv4_hdr);
  80                 *l4_proto = ipv4_hdr->next_proto_id;
  81                 break;
  82         case ETHER_TYPE_IPv6:
  83                 ipv6_hdr = (struct ipv6_hdr *)
  84                         ((char *)eth_hdr + info->outer_l2_len);
  85                 info->outer_l3_len = sizeof(struct ipv6_hdr);
  86                 *l4_proto = ipv6_hdr->proto;
  87                 break;
  88         default:
  89                 info->outer_l3_len = 0;
  90                 *l4_proto = 0;
  91                 break;
  92         }
  93 }
  94
  95 /**
  96  * Calculate the checksum of a packet in hardware
  97  */
  98 static uint64_t
  99 process_inner_cksums(struct ether_hdr *eth_hdr, union tunnel_offload_info *info)
 100 {
 101         void *l3_hdr = NULL;
 102         uint8_t l4_proto;
 103         uint16_t ethertype;
 104         struct ipv4_hdr *ipv4_hdr;
 105         struct ipv6_hdr *ipv6_hdr;
 106         struct udp_hdr *udp_hdr;
 107         struct tcp_hdr *tcp_hdr;
 108         struct sctp_hdr *sctp_hdr;
 109         uint64_t ol_flags = 0;
 110
 111         info->l2_len = sizeof(struct ether_hdr);
 112         ethertype = rte_be_to_cpu_16(eth_hdr->ether_type);
 113
 114         if (ethertype == ETHER_TYPE_VLAN) {
 115                 struct vlan_hdr *vlan_hdr = (struct vlan_hdr *)(eth_hdr + 1);
 116                 info->l2_len  += sizeof(struct vlan_hdr);
 117                 ethertype = rte_be_to_cpu_16(vlan_hdr->eth_proto);
 118         }
 119
 120         l3_hdr = (char *)eth_hdr + info->l2_len;
 121
 122         if (ethertype == ETHER_TYPE_IPv4) {
 123                 ipv4_hdr = (struct ipv4_hdr *)l3_hdr;
 124                 ipv4_hdr->hdr_checksum = 0;
 125                 ol_flags |= PKT_TX_IPV4;
 126                 ol_flags |= PKT_TX_IP_CKSUM;
 127                 info->l3_len = sizeof(struct ipv4_hdr);
 128                 l4_proto = ipv4_hdr->next_proto_id;
 129         } else if (ethertype == ETHER_TYPE_IPv6) {
 130                 ipv6_hdr = (struct ipv6_hdr *)l3_hdr;
 131                 info->l3_len = sizeof(struct ipv6_hdr);
 132                 l4_proto = ipv6_hdr->proto;
 133                 ol_flags |= PKT_TX_IPV6;
 134         } else
 135                 return 0; /* packet type not supported, nothing to do */
 136
 137         if (l4_proto == IPPROTO_UDP) {
 138                 udp_hdr = (struct udp_hdr *)((char *)l3_hdr + info->l3_len);
 139                 ol_flags |= PKT_TX_UDP_CKSUM;
 140                 udp_hdr->dgram_cksum = get_psd_sum(l3_hdr,
 141                                 ethertype, ol_flags);
 142         } else if (l4_proto == IPPROTO_TCP) {
 143                 tcp_hdr = (struct tcp_hdr *)((char *)l3_hdr + info->l3_len);
 144                 /* Put PKT_TX_TCP_SEG bit setting before get_psd_sum(), because
 145                  * it depends on PKT_TX_TCP_SEG to calculate pseudo-header
 146                  * checksum.
 147                  */
 148                 if (tso_segsz != 0) {
 149                         ol_flags |= PKT_TX_TCP_SEG;
 150                         info->tso_segsz = tso_segsz;
 151                         info->l4_len = (tcp_hdr->data_off & 0xf0) >> 2;
 152                 }
 153                 ol_flags |= PKT_TX_TCP_CKSUM;
 154                 tcp_hdr->cksum = get_psd_sum(l3_hdr, ethertype, ol_flags);
 155
 156         } else if (l4_proto == IPPROTO_SCTP) {
 157                 sctp_hdr = (struct sctp_hdr *)((char *)l3_hdr + info->l3_len);
 158                 sctp_hdr->cksum = 0;
 159                 ol_flags |= PKT_TX_SCTP_CKSUM;
 160         }
 161
 162         return ol_flags;
 163 }
 164
 165 int
 166 decapsulation(struct rte_mbuf *pkt)
 167 {
 168         uint8_t l4_proto = 0;
 169         uint16_t outer_header_len;
 170         struct udp_hdr *udp_hdr;
 171         union tunnel_offload_info info = { .data = 0 };
 172         struct ether_hdr *phdr = rte_pktmbuf_mtod(pkt, struct ether_hdr *);
 173
 174         parse_ethernet(phdr, &info, &l4_proto);
 175
 176         if (l4_proto != IPPROTO_UDP)
 177                 return -1;
 178
 179         udp_hdr = (struct udp_hdr *)((char *)phdr +
 180                 info.outer_l2_len + info.outer_l3_len);
 181
 182         /** check udp destination port, 4789 is the default vxlan port
 183          * (rfc7348) or that the rx offload flag is set (i40e only
 184          * currently)*/
 185         if (udp_hdr->dst_port != rte_cpu_to_be_16(DEFAULT_VXLAN_PORT) &&
 186                 (pkt->packet_type & RTE_PTYPE_TUNNEL_MASK) == 0)
 187                 return -1;
 188         outer_header_len = info.outer_l2_len + info.outer_l3_len
 189                 + sizeof(struct udp_hdr) + sizeof(struct vxlan_hdr);
 190
 191         rte_pktmbuf_adj(pkt, outer_header_len);
 192
 193         return 0;
 194 }
 195
 196 void
 197 encapsulation(struct rte_mbuf *m, uint8_t queue_id)
 198 {
 199         uint vport_id;
 200         uint64_t ol_flags = 0;
 201         uint32_t old_len = m->pkt_len, hash;
 202         union tunnel_offload_info tx_offload = { .data = 0 };
 203         struct ether_hdr *phdr = rte_pktmbuf_mtod(m, struct ether_hdr *);
 204
 205         /*Allocate space for new ethernet, IPv4, UDP and VXLAN headers*/
 206         struct ether_hdr *pneth = (struct ether_hdr *) rte_pktmbuf_prepend(m,
 207                 sizeof(struct ether_hdr) + sizeof(struct ipv4_hdr)
 208                 + sizeof(struct udp_hdr) + sizeof(struct vxlan_hdr));
 209
 210         struct ipv4_hdr *ip = (struct ipv4_hdr *) &pneth[1];
 211         struct udp_hdr *udp = (struct udp_hdr *) &ip[1];
 212         struct vxlan_hdr *vxlan = (struct vxlan_hdr *) &udp[1];
 213
 214         /* convert TX queue ID to vport ID */
 215         vport_id = queue_id - 1;
 216
 217         /* replace original Ethernet header with ours */
 218         pneth = rte_memcpy(pneth, &app_l2_hdr[vport_id],
 219                 sizeof(struct ether_hdr));
 220
 221         /* copy in IP header */
 222         ip = rte_memcpy(ip, &app_ip_hdr[vport_id],
 223                 sizeof(struct ipv4_hdr));
 224         ip->total_length = rte_cpu_to_be_16(m->pkt_len
 225                                 - sizeof(struct ether_hdr));
 226
 227         /* outer IP checksum */
 228         ol_flags |= PKT_TX_OUTER_IP_CKSUM;
 229         ip->hdr_checksum = 0;
 230
 231         /* inner IP checksum offload */
 232         if (tx_checksum) {
 233                 ol_flags |= process_inner_cksums(phdr, &tx_offload);
 234                 m->l2_len = tx_offload.l2_len;
 235                 m->l3_len = tx_offload.l3_len;
 236                 m->l4_len = tx_offload.l4_len;
 237                 m->l2_len += ETHER_VXLAN_HLEN;
 238         }
 239
 240         m->outer_l2_len = sizeof(struct ether_hdr);
 241         m->outer_l3_len = sizeof(struct ipv4_hdr);
 242
 243         ol_flags |= PKT_TX_TUNNEL_VXLAN;
 244
 245         m->ol_flags |= ol_flags;
 246         m->tso_segsz = tx_offload.tso_segsz;
 247
 248         /*VXLAN HEADER*/
 249         vxlan->vx_flags = rte_cpu_to_be_32(VXLAN_HF_VNI);
 250         vxlan->vx_vni = rte_cpu_to_be_32(vxdev.out_key << 8);
 251
 252         /*UDP HEADER*/
 253         udp->dgram_cksum = 0;
 254         udp->dgram_len = rte_cpu_to_be_16(old_len
 255                                 + sizeof(struct udp_hdr)
 256                                 + sizeof(struct vxlan_hdr));
 257
 258         udp->dst_port = rte_cpu_to_be_16(vxdev.dst_port);
 259         hash = rte_hash_crc(phdr, 2 * ETHER_ADDR_LEN, phdr->ether_type);
 260         udp->src_port = rte_cpu_to_be_16((((uint64_t) hash * PORT_RANGE) >> 32)
 261                                         + PORT_MIN);
 262
 263         return;
 264 }