4 * Copyright(c) 2010-2015 Intel Corporation. All rights reserved.
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
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
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.
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.
35 #include <linux/if_ether.h>
36 #include <linux/if_vlan.h>
37 #include <linux/virtio_net.h>
38 #include <linux/virtio_ring.h>
39 #include <sys/param.h>
42 #include <rte_ethdev.h>
44 #include <rte_string_fns.h>
46 #include <rte_malloc.h>
52 #include "rte_virtio_net.h"
54 #include "vxlan_setup.h"
56 #define IPV4_HEADER_LEN 20
57 #define UDP_HEADER_LEN 8
58 #define VXLAN_HEADER_LEN 8
60 #define IP_VERSION 0x40
61 #define IP_HDRLEN 0x05 /* default IP header length == five 32-bits words. */
62 #define IP_DEFTTL 64 /* from RFC 1340. */
63 #define IP_VHL_DEF (IP_VERSION | IP_HDRLEN)
65 #define IP_DN_FRAGMENT_FLAG 0x0040
67 /* Used to compare MAC addresses. */
68 #define MAC_ADDR_CMP 0xFFFFFFFFFFFFULL
70 /* Configurable number of RX/TX ring descriptors */
71 #define RTE_TEST_RX_DESC_DEFAULT 1024
72 #define RTE_TEST_TX_DESC_DEFAULT 512
74 /* Default inner VLAN ID */
75 #define INNER_VLAN_ID 100
78 struct vxlan_conf vxdev;
80 struct ipv4_hdr app_ip_hdr[VXLAN_N_PORTS];
81 struct ether_hdr app_l2_hdr[VXLAN_N_PORTS];
83 /* local VTEP IP address */
84 uint8_t vxlan_multicast_ips[2][4] = { {239, 1, 1, 1 }, {239, 1, 2, 1 } };
86 /* Remote VTEP IP address */
87 uint8_t vxlan_overlay_ips[2][4] = { {192, 168, 10, 1}, {192, 168, 30, 1} };
89 /* Remote VTEP MAC address */
90 uint8_t peer_mac[6] = {0x00, 0x11, 0x01, 0x00, 0x00, 0x01};
92 /* VXLAN RX filter type */
93 uint8_t tep_filter_type[] = {RTE_TUNNEL_FILTER_IMAC_TENID,
94 RTE_TUNNEL_FILTER_IMAC_IVLAN_TENID,
95 RTE_TUNNEL_FILTER_OMAC_TENID_IMAC,};
97 /* Options for configuring ethernet port */
98 static const struct rte_eth_conf port_conf = {
101 .header_split = 0, /**< Header Split disabled */
102 .hw_ip_checksum = 0, /**< IP checksum offload disabled */
103 .hw_vlan_filter = 0, /**< VLAN filtering disabled */
104 .jumbo_frame = 0, /**< Jumbo Frame Support disabled */
105 .hw_strip_crc = 0, /**< CRC stripped by hardware */
108 .mq_mode = ETH_MQ_TX_NONE,
113 * The one or two device(s) that belongs to the same tenant ID can
114 * be assigned in a VM.
116 const uint16_t tenant_id_conf[] = {
117 1000, 1000, 1001, 1001, 1002, 1002, 1003, 1003,
118 1004, 1004, 1005, 1005, 1006, 1006, 1007, 1007,
119 1008, 1008, 1009, 1009, 1010, 1010, 1011, 1011,
120 1012, 1012, 1013, 1013, 1014, 1014, 1015, 1015,
121 1016, 1016, 1017, 1017, 1018, 1018, 1019, 1019,
122 1020, 1020, 1021, 1021, 1022, 1022, 1023, 1023,
123 1024, 1024, 1025, 1025, 1026, 1026, 1027, 1027,
124 1028, 1028, 1029, 1029, 1030, 1030, 1031, 1031,
128 * Initialises a given port using global settings and with the rx buffers
129 * coming from the mbuf_pool passed as parameter
132 vxlan_port_init(uint8_t port, struct rte_mempool *mbuf_pool)
136 struct rte_eth_dev_info dev_info;
137 uint16_t rx_rings, tx_rings = (uint16_t)rte_lcore_count();
138 const uint16_t rx_ring_size = RTE_TEST_RX_DESC_DEFAULT;
139 const uint16_t tx_ring_size = RTE_TEST_TX_DESC_DEFAULT;
140 struct rte_eth_udp_tunnel tunnel_udp;
141 struct rte_eth_rxconf *rxconf;
142 struct rte_eth_txconf *txconf;
143 struct vxlan_conf *pconf = &vxdev;
145 pconf->dst_port = udp_port;
147 rte_eth_dev_info_get(port, &dev_info);
149 if (dev_info.max_rx_queues > MAX_QUEUES) {
150 rte_exit(EXIT_FAILURE,
151 "please define MAX_QUEUES no less than %u in %s\n",
152 dev_info.max_rx_queues, __FILE__);
155 rxconf = &dev_info.default_rxconf;
156 txconf = &dev_info.default_txconf;
157 txconf->txq_flags = 0;
159 if (port >= rte_eth_dev_count())
162 rx_rings = nb_devices;
164 /* Configure ethernet device. */
165 retval = rte_eth_dev_configure(port, rx_rings, tx_rings, &port_conf);
169 /* Setup the queues. */
170 for (q = 0; q < rx_rings; q++) {
171 retval = rte_eth_rx_queue_setup(port, q, rx_ring_size,
172 rte_eth_dev_socket_id(port),
178 for (q = 0; q < tx_rings; q++) {
179 retval = rte_eth_tx_queue_setup(port, q, tx_ring_size,
180 rte_eth_dev_socket_id(port),
186 /* Start the device. */
187 retval = rte_eth_dev_start(port);
191 /* Configure UDP port for UDP tunneling */
192 tunnel_udp.udp_port = udp_port;
193 tunnel_udp.prot_type = RTE_TUNNEL_TYPE_VXLAN;
194 retval = rte_eth_dev_udp_tunnel_add(port, &tunnel_udp);
197 rte_eth_macaddr_get(port, &ports_eth_addr[port]);
198 RTE_LOG(INFO, PORT, "Port %u MAC: %02"PRIx8" %02"PRIx8" %02"PRIx8
199 " %02"PRIx8" %02"PRIx8" %02"PRIx8"\n",
201 ports_eth_addr[port].addr_bytes[0],
202 ports_eth_addr[port].addr_bytes[1],
203 ports_eth_addr[port].addr_bytes[2],
204 ports_eth_addr[port].addr_bytes[3],
205 ports_eth_addr[port].addr_bytes[4],
206 ports_eth_addr[port].addr_bytes[5]);
212 vxlan_rx_process(struct rte_mbuf *pkt)
214 return decapsulation(pkt);
218 vxlan_tx_process(uint8_t queue_id, struct rte_mbuf *pkt)
220 encapsulation(pkt, queue_id);
225 * This function learns the MAC address of the device and set init
226 * L2 header and L3 header info.
229 vxlan_link(struct vhost_dev *vdev, struct rte_mbuf *m)
232 struct ether_hdr *pkt_hdr;
233 struct virtio_net *dev = vdev->dev;
234 uint64_t portid = dev->device_fh;
237 struct rte_eth_tunnel_filter_conf tunnel_filter_conf;
239 if (unlikely(portid > VXLAN_N_PORTS)) {
240 RTE_LOG(INFO, VHOST_DATA,
241 "(%"PRIu64") WARNING: Not configuring device,"
242 "as already have %d ports for VXLAN.",
243 dev->device_fh, VXLAN_N_PORTS);
247 /* Learn MAC address of guest device from packet */
248 pkt_hdr = rte_pktmbuf_mtod(m, struct ether_hdr *);
249 if (is_same_ether_addr(&(pkt_hdr->s_addr), &vdev->mac_address)) {
250 RTE_LOG(INFO, VHOST_DATA,
251 "(%"PRIu64") WARNING: This device is using an existing"
252 " MAC address and has not been registered.\n",
257 for (i = 0; i < ETHER_ADDR_LEN; i++) {
258 vdev->mac_address.addr_bytes[i] =
259 vxdev.port[portid].vport_mac.addr_bytes[i] =
260 pkt_hdr->s_addr.addr_bytes[i];
261 vxdev.port[portid].peer_mac.addr_bytes[i] = peer_mac[i];
264 memset(&tunnel_filter_conf, 0,
265 sizeof(struct rte_eth_tunnel_filter_conf));
267 tunnel_filter_conf.outer_mac = &ports_eth_addr[0];
268 tunnel_filter_conf.filter_type = tep_filter_type[filter_idx];
271 tunnel_filter_conf.inner_mac = &vdev->mac_address;
273 tunnel_filter_conf.queue_id = vdev->rx_q;
274 tunnel_filter_conf.tenant_id = tenant_id_conf[vdev->rx_q];
276 if (tep_filter_type[filter_idx] == RTE_TUNNEL_FILTER_IMAC_IVLAN_TENID)
277 tunnel_filter_conf.inner_vlan = INNER_VLAN_ID;
279 tunnel_filter_conf.tunnel_type = RTE_TUNNEL_TYPE_VXLAN;
281 ret = rte_eth_dev_filter_ctrl(ports[0],
282 RTE_ETH_FILTER_TUNNEL,
284 &tunnel_filter_conf);
286 RTE_LOG(ERR, VHOST_DATA,
287 "%d Failed to add device MAC address to cloud filter\n",
292 /* Print out inner MAC and VNI info. */
293 RTE_LOG(INFO, VHOST_DATA,
294 "(%d) MAC_ADDRESS %02x:%02x:%02x:%02x:%02x:%02x and VNI %d registered\n",
296 vdev->mac_address.addr_bytes[0],
297 vdev->mac_address.addr_bytes[1],
298 vdev->mac_address.addr_bytes[2],
299 vdev->mac_address.addr_bytes[3],
300 vdev->mac_address.addr_bytes[4],
301 vdev->mac_address.addr_bytes[5],
302 tenant_id_conf[vdev->rx_q]);
304 vxdev.port[portid].vport_id = portid;
306 for (i = 0; i < 4; i++) {
308 vxdev.port_ip |= vxlan_multicast_ips[portid][i] << (8 * i);
310 vxdev.port[portid].peer_ip |=
311 vxlan_overlay_ips[portid][i] << (8 * i);
314 vxdev.out_key = tenant_id_conf[vdev->rx_q];
315 ether_addr_copy(&vxdev.port[portid].peer_mac,
316 &app_l2_hdr[portid].d_addr);
317 ether_addr_copy(&ports_eth_addr[0],
318 &app_l2_hdr[portid].s_addr);
319 app_l2_hdr[portid].ether_type = rte_cpu_to_be_16(ETHER_TYPE_IPv4);
321 ip = &app_ip_hdr[portid];
322 ip->version_ihl = IP_VHL_DEF;
323 ip->type_of_service = 0;
324 ip->total_length = 0;
326 ip->fragment_offset = IP_DN_FRAGMENT_FLAG;
327 ip->time_to_live = IP_DEFTTL;
328 ip->next_proto_id = IPPROTO_UDP;
329 ip->hdr_checksum = 0;
330 ip->src_addr = vxdev.port_ip;
331 ip->dst_addr = vxdev.port[portid].peer_ip;
333 /* Set device as ready for RX. */
334 vdev->ready = DEVICE_RX;
340 * Removes cloud filter. Ensures that nothing is adding buffers to the RX
341 * queue before disabling RX on the device.
344 vxlan_unlink(struct vhost_dev *vdev)
346 unsigned i = 0, rx_count;
348 struct rte_mbuf *pkts_burst[MAX_PKT_BURST];
349 struct rte_eth_tunnel_filter_conf tunnel_filter_conf;
351 if (vdev->ready == DEVICE_RX) {
352 memset(&tunnel_filter_conf, 0,
353 sizeof(struct rte_eth_tunnel_filter_conf));
355 tunnel_filter_conf.outer_mac = &ports_eth_addr[0];
356 tunnel_filter_conf.inner_mac = &vdev->mac_address;
357 tunnel_filter_conf.tenant_id = tenant_id_conf[vdev->rx_q];
358 tunnel_filter_conf.filter_type = tep_filter_type[filter_idx];
360 if (tep_filter_type[filter_idx] ==
361 RTE_TUNNEL_FILTER_IMAC_IVLAN_TENID)
362 tunnel_filter_conf.inner_vlan = INNER_VLAN_ID;
364 tunnel_filter_conf.queue_id = vdev->rx_q;
365 tunnel_filter_conf.tunnel_type = RTE_TUNNEL_TYPE_VXLAN;
367 ret = rte_eth_dev_filter_ctrl(ports[0],
368 RTE_ETH_FILTER_TUNNEL,
369 RTE_ETH_FILTER_DELETE,
370 &tunnel_filter_conf);
372 RTE_LOG(ERR, VHOST_DATA,
373 "%d Failed to add device MAC address to cloud filter\n",
377 for (i = 0; i < ETHER_ADDR_LEN; i++)
378 vdev->mac_address.addr_bytes[i] = 0;
380 /* Clear out the receive buffers */
381 rx_count = rte_eth_rx_burst(ports[0],
382 (uint16_t)vdev->rx_q,
383 pkts_burst, MAX_PKT_BURST);
386 for (i = 0; i < rx_count; i++)
387 rte_pktmbuf_free(pkts_burst[i]);
389 rx_count = rte_eth_rx_burst(ports[0],
390 (uint16_t)vdev->rx_q,
391 pkts_burst, MAX_PKT_BURST);
393 vdev->ready = DEVICE_MAC_LEARNING;
397 /* Transmit packets after encapsulating */
399 vxlan_tx_pkts(uint8_t port_id, uint16_t queue_id,
400 struct rte_mbuf **tx_pkts, uint16_t nb_pkts) {
404 for (i = 0; i < nb_pkts; i++)
405 vxlan_tx_process(queue_id, tx_pkts[i]);
407 ret = rte_eth_tx_burst(port_id, queue_id, tx_pkts, nb_pkts);
412 /* Check for decapsulation and pass packets directly to VIRTIO device */
414 vxlan_rx_pkts(struct virtio_net *dev, struct rte_mbuf **pkts_burst,
420 struct rte_mbuf *pkts_valid[rx_count];
422 for (i = 0; i < rx_count; i++) {
423 ret = vxlan_rx_process(pkts_burst[i]);
424 if (unlikely(ret < 0))
427 pkts_valid[count] = pkts_burst[i];
431 ret = rte_vhost_enqueue_burst(dev, VIRTIO_RXQ, pkts_valid, count);