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
75 struct vxlan_conf vxdev;
77 struct ipv4_hdr app_ip_hdr[VXLAN_N_PORTS];
78 struct ether_hdr app_l2_hdr[VXLAN_N_PORTS];
80 /* local VTEP IP address */
81 uint8_t vxlan_multicast_ips[2][4] = { {239, 1, 1, 1 }, {239, 1, 2, 1 } };
83 /* Remote VTEP IP address */
84 uint8_t vxlan_overlay_ips[2][4] = { {192, 168, 10, 1}, {192, 168, 30, 1} };
86 /* Remote VTEP MAC address */
87 uint8_t peer_mac[6] = {0x00, 0x11, 0x01, 0x00, 0x00, 0x01};
89 /* Options for configuring ethernet port */
90 static const struct rte_eth_conf port_conf = {
93 .header_split = 0, /**< Header Split disabled */
94 .hw_ip_checksum = 0, /**< IP checksum offload disabled */
95 .hw_vlan_filter = 0, /**< VLAN filtering disabled */
96 .jumbo_frame = 0, /**< Jumbo Frame Support disabled */
97 .hw_strip_crc = 0, /**< CRC stripped by hardware */
100 .mq_mode = ETH_MQ_TX_NONE,
105 * The one or two device(s) that belongs to the same tenant ID can
106 * be assigned in a VM.
108 const uint16_t tenant_id_conf[] = {
109 1000, 1000, 1001, 1001, 1002, 1002, 1003, 1003,
110 1004, 1004, 1005, 1005, 1006, 1006, 1007, 1007,
111 1008, 1008, 1009, 1009, 1010, 1010, 1011, 1011,
112 1012, 1012, 1013, 1013, 1014, 1014, 1015, 1015,
113 1016, 1016, 1017, 1017, 1018, 1018, 1019, 1019,
114 1020, 1020, 1021, 1021, 1022, 1022, 1023, 1023,
115 1024, 1024, 1025, 1025, 1026, 1026, 1027, 1027,
116 1028, 1028, 1029, 1029, 1030, 1030, 1031, 1031,
120 * Initialises a given port using global settings and with the rx buffers
121 * coming from the mbuf_pool passed as parameter
124 vxlan_port_init(uint8_t port, struct rte_mempool *mbuf_pool)
128 struct rte_eth_dev_info dev_info;
129 uint16_t rx_rings, tx_rings = (uint16_t)rte_lcore_count();
130 const uint16_t rx_ring_size = RTE_TEST_RX_DESC_DEFAULT;
131 const uint16_t tx_ring_size = RTE_TEST_TX_DESC_DEFAULT;
132 struct rte_eth_rxconf *rxconf;
133 struct rte_eth_txconf *txconf;
135 rte_eth_dev_info_get(port, &dev_info);
137 if (dev_info.max_rx_queues > MAX_QUEUES) {
138 rte_exit(EXIT_FAILURE,
139 "please define MAX_QUEUES no less than %u in %s\n",
140 dev_info.max_rx_queues, __FILE__);
143 rxconf = &dev_info.default_rxconf;
144 txconf = &dev_info.default_txconf;
145 txconf->txq_flags = 0;
147 if (port >= rte_eth_dev_count())
150 rx_rings = nb_devices;
152 /* Configure ethernet device. */
153 retval = rte_eth_dev_configure(port, rx_rings, tx_rings, &port_conf);
157 /* Setup the queues. */
158 for (q = 0; q < rx_rings; q++) {
159 retval = rte_eth_rx_queue_setup(port, q, rx_ring_size,
160 rte_eth_dev_socket_id(port),
166 for (q = 0; q < tx_rings; q++) {
167 retval = rte_eth_tx_queue_setup(port, q, tx_ring_size,
168 rte_eth_dev_socket_id(port),
174 /* Start the device. */
175 retval = rte_eth_dev_start(port);
179 rte_eth_macaddr_get(port, &ports_eth_addr[port]);
180 RTE_LOG(INFO, PORT, "Port %u MAC: %02"PRIx8" %02"PRIx8" %02"PRIx8
181 " %02"PRIx8" %02"PRIx8" %02"PRIx8"\n",
183 ports_eth_addr[port].addr_bytes[0],
184 ports_eth_addr[port].addr_bytes[1],
185 ports_eth_addr[port].addr_bytes[2],
186 ports_eth_addr[port].addr_bytes[3],
187 ports_eth_addr[port].addr_bytes[4],
188 ports_eth_addr[port].addr_bytes[5]);
193 vxlan_rx_process(struct rte_mbuf *pkt)
195 return decapsulation(pkt);
199 vxlan_tx_process(uint8_t queue_id, struct rte_mbuf *pkt)
201 encapsulation(pkt, queue_id);
206 * This function learns the MAC address of the device and set init
207 * L2 header and L3 header info.
210 vxlan_link(struct vhost_dev *vdev, struct rte_mbuf *m)
213 struct ether_hdr *pkt_hdr;
214 struct virtio_net *dev = vdev->dev;
215 uint64_t portid = dev->device_fh;
218 if (unlikely(portid > VXLAN_N_PORTS)) {
219 RTE_LOG(INFO, VHOST_DATA,
220 "(%"PRIu64") WARNING: Not configuring device,"
221 "as already have %d ports for VXLAN.",
222 dev->device_fh, VXLAN_N_PORTS);
226 /* Learn MAC address of guest device from packet */
227 pkt_hdr = rte_pktmbuf_mtod(m, struct ether_hdr *);
228 if (is_same_ether_addr(&(pkt_hdr->s_addr), &vdev->mac_address)) {
229 RTE_LOG(INFO, VHOST_DATA,
230 "(%"PRIu64") WARNING: This device is using an existing"
231 " MAC address and has not been registered.\n",
236 for (i = 0; i < ETHER_ADDR_LEN; i++) {
237 vdev->mac_address.addr_bytes[i] =
238 vxdev.port[portid].vport_mac.addr_bytes[i] =
239 pkt_hdr->s_addr.addr_bytes[i];
240 vxdev.port[portid].peer_mac.addr_bytes[i] = peer_mac[i];
243 /* Print out inner MAC and VNI info. */
244 RTE_LOG(INFO, VHOST_DATA,
245 "(%d) MAC_ADDRESS %02x:%02x:%02x:%02x:%02x:%02x and VNI %d registered\n",
247 vdev->mac_address.addr_bytes[0],
248 vdev->mac_address.addr_bytes[1],
249 vdev->mac_address.addr_bytes[2],
250 vdev->mac_address.addr_bytes[3],
251 vdev->mac_address.addr_bytes[4],
252 vdev->mac_address.addr_bytes[5],
253 tenant_id_conf[vdev->rx_q]);
255 vxdev.port[portid].vport_id = portid;
257 for (i = 0; i < 4; i++) {
259 vxdev.port_ip |= vxlan_multicast_ips[portid][i] << (8 * i);
261 vxdev.port[portid].peer_ip |=
262 vxlan_overlay_ips[portid][i] << (8 * i);
265 vxdev.out_key = tenant_id_conf[vdev->rx_q];
266 ether_addr_copy(&vxdev.port[portid].peer_mac,
267 &app_l2_hdr[portid].d_addr);
268 ether_addr_copy(&ports_eth_addr[0],
269 &app_l2_hdr[portid].s_addr);
270 app_l2_hdr[portid].ether_type = rte_cpu_to_be_16(ETHER_TYPE_IPv4);
272 ip = &app_ip_hdr[portid];
273 ip->version_ihl = IP_VHL_DEF;
274 ip->type_of_service = 0;
275 ip->total_length = 0;
277 ip->fragment_offset = IP_DN_FRAGMENT_FLAG;
278 ip->time_to_live = IP_DEFTTL;
279 ip->next_proto_id = IPPROTO_UDP;
280 ip->hdr_checksum = 0;
281 ip->src_addr = vxdev.port_ip;
282 ip->dst_addr = vxdev.port[portid].peer_ip;
284 /* Set device as ready for RX. */
285 vdev->ready = DEVICE_RX;
291 * Removes cloud filter. Ensures that nothing is adding buffers to the RX
292 * queue before disabling RX on the device.
295 vxlan_unlink(struct vhost_dev *vdev)
297 unsigned i = 0, rx_count;
298 struct rte_mbuf *pkts_burst[MAX_PKT_BURST];
300 if (vdev->ready == DEVICE_RX) {
301 for (i = 0; i < ETHER_ADDR_LEN; i++)
302 vdev->mac_address.addr_bytes[i] = 0;
304 /* Clear out the receive buffers */
305 rx_count = rte_eth_rx_burst(ports[0],
306 (uint16_t)vdev->rx_q,
307 pkts_burst, MAX_PKT_BURST);
310 for (i = 0; i < rx_count; i++)
311 rte_pktmbuf_free(pkts_burst[i]);
313 rx_count = rte_eth_rx_burst(ports[0],
314 (uint16_t)vdev->rx_q,
315 pkts_burst, MAX_PKT_BURST);
317 vdev->ready = DEVICE_MAC_LEARNING;
321 /* Transmit packets after encapsulating */
323 vxlan_tx_pkts(uint8_t port_id, uint16_t queue_id,
324 struct rte_mbuf **tx_pkts, uint16_t nb_pkts) {
328 for (i = 0; i < nb_pkts; i++)
329 vxlan_tx_process(queue_id, tx_pkts[i]);
331 ret = rte_eth_tx_burst(port_id, queue_id, tx_pkts, nb_pkts);
336 /* Check for decapsulation and pass packets directly to VIRTIO device */
338 vxlan_rx_pkts(struct virtio_net *dev, struct rte_mbuf **pkts_burst,
344 struct rte_mbuf *pkts_valid[rx_count];
346 for (i = 0; i < rx_count; i++) {
347 ret = vxlan_rx_process(pkts_burst[i]);
348 if (unlikely(ret < 0))
351 pkts_valid[count] = pkts_burst[i];
355 ret = rte_vhost_enqueue_burst(dev, VIRTIO_RXQ, pkts_valid, count);