pre test: Send grat ARP, and resolve gateway addresses

1 files changed, 339 insertions, 0 deletions

diff --git a/src/pre_test.cpp b/src/pre_test.cpp
new file mode 100644
index 00000000..9df2ed6b
--- /dev/null
+++ b/src/pre_test.cpp
@@ -0,0 +1,339 @@
+/* 
+?????
+- read also from q 0
+- read periodically - not wait 1 sec
+flush q 0,1 at end
+close q 0 at end (not close it at start)
+test in trex-dan router for long time. remove static arp from router.
+test 10g, vm
+add also per profile
+
+
+remove stuff in ???
+make 10G work
+documentation
+
+ */
+
+/*
+  Ido Barnea
+  Cisco Systems, Inc.
+*/
+
+/*
+  Copyright (c) 2016-2016 Cisco Systems, Inc.
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+  http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/
+
+#include <rte_arp.h>
+#include <rte_ethdev.h>
+#include <arpa/inet.h>
+#include <common/Network/Packet/EthernetHeader.h>
+#include "common/basic_utils.h"
+#include "bp_sim.h"
+#include "main_dpdk.h"
+#include "pre_test.h"
+
+
+void CPretestPortInfo::set_params(uint32_t ip, const uint8_t *src_mac, uint32_t def_gw
+                                  , bool resolve_needed) {
+    m_ip = ip;
+    m_def_gw = def_gw;
+    memcpy(&m_src_mac, src_mac, sizeof(m_src_mac));
+    if (resolve_needed) {
+        m_state = CPretestPortInfo::RESOLVE_NEEDED;
+    } else {
+        m_state = CPretestPortInfo::RESOLVE_NOT_NEEDED;
+    }
+}
+
+void CPretestPortInfo::set_dst_mac(const uint8_t *dst_mac) {
+    memcpy(&m_dst_mac, dst_mac, sizeof(m_dst_mac));
+    m_state = CPretestPortInfo::RESOLVE_DONE;
+}
+
+void CPretestPortInfo::dump(FILE *fd) {
+    if (m_state == INIT_NEEDED) {
+        return;
+    }
+
+    uint32_t ip = htonl(m_ip);
+    
+    fprintf(fd, "  ip:%d.%d.%d.%d", ip & 0xFF, (ip >> 8) & 0xFF, (ip >> 16) & 0xFF, (ip >> 24) & 0xFF);
+    ip = htonl(m_def_gw);
+    fprintf(fd, "  default gw:%d.%d.%d.%d\n", ip & 0xFF, (ip >> 8) & 0xFF, (ip >> 16) & 0xFF, (ip >> 24) & 0xFF);
+
+    printf("  src MAC: %02x:%02x:%02x:%02x:%02x:%02x\n", m_src_mac[0], m_src_mac[1], m_src_mac[2], m_src_mac[3]
+           , m_src_mac[4], m_src_mac[5]);
+    printf(  "  dst MAC: ");
+    if (m_state == RESOLVE_DONE) {
+        printf("%02x:%02x:%02x:%02x:%02x:%02x\n", m_dst_mac[0], m_dst_mac[1], m_dst_mac[2], m_dst_mac[3]
+               , m_dst_mac[4], m_dst_mac[5]);
+    } else {
+        printf("Not resolved\n");
+    }
+}
+
+// Create ARP request for our default gateway.
+// If is_grat is true - create gratuitous ARP.
+// pkt_size will contain the size of buffer returned.
+// Return pointer to buffer containing the packet.
+uint8_t *CPretestPortInfo::create_arp_req(uint16_t &pkt_size, uint8_t port, bool is_grat) {
+    pkt_size = 14 + sizeof (struct arp_hdr);
+    uint16_t l2_proto = htons(EthernetHeader::Protocol::ARP);
+    
+    uint8_t *pkt = (uint8_t *)malloc(pkt_size);
+    assert(pkt != NULL);   
+    uint8_t *p = pkt;
+    
+    // dst MAC
+    memset(p, 0xff, ETHER_ADDR_LEN);
+    p += ETHER_ADDR_LEN;
+    // src MAC
+    memcpy(p, m_src_mac, ETHER_ADDR_LEN);
+    p += ETHER_ADDR_LEN;
+    // l3 type
+    memcpy(p, &l2_proto, sizeof(l2_proto));
+    p += 2;
+
+    struct arp_hdr *arp = (struct arp_hdr *)p;
+    arp->arp_hrd = htons(ARP_HRD_ETHER); // Format of hardware address
+    arp->arp_pro = htons(EthernetHeader::Protocol::IP); // Format of protocol address
+    arp->arp_hln = ETHER_ADDR_LEN; // Length of hardware address
+    arp->arp_pln = 4; // Length of protocol address
+    arp->arp_op = htons(ARP_OP_REQUEST); // ARP opcode (command)
+
+    memcpy(&arp->arp_data.arp_sha, m_src_mac, ETHER_ADDR_LEN); // Sender MAC address
+    arp->arp_data.arp_sip = htonl(m_ip); // Sender IP address
+    uint8_t magic[5] = {0x1, 0x3, 0x5, 0x7, 0x9};
+    memcpy(&arp->arp_data.arp_tha, magic, 5); // Target MAC address
+    arp->arp_data.arp_tha.addr_bytes[5] = port;
+    if (is_grat)
+        arp->arp_data.arp_tip = htonl(m_ip); // gratuitous ARP is request for your own IP.
+    else
+        arp->arp_data.arp_tip = htonl(m_def_gw); // Target IP address
+    
+    return pkt;
+}
+
+/*
+  put in mac relevant dest MAC for port/ip pair.
+  return false if no relevant info exists, true otherwise.
+ */
+bool CPretest::get_mac(uint16_t port, uint32_t ip, uint8_t *mac) {
+    if (port >= TREX_MAX_PORTS) {
+        return false;
+    }
+
+    if (m_port_info[port].m_state != CPretestPortInfo::RESOLVE_DONE) {
+        return false;
+    }
+
+    memcpy(mac, &m_port_info[port].m_dst_mac, sizeof(m_port_info[port].m_dst_mac));
+        
+    return true;    
+}
+
+void CPretest::set_port_params(uint16_t port, uint32_t ip, const uint8_t *src_mac, uint32_t def_gw,
+                               bool resolve_needed) {
+    if (port >= m_max_ports)
+        return;
+
+    m_port_info[port].set_params(ip, src_mac, def_gw, resolve_needed);
+}
+
+
+int CPretest::handle_rx(int port_id, int queue_id) {
+    rte_mbuf_t * rx_pkts[32];
+    uint16_t cnt;
+    int i;
+
+    cnt = rte_eth_rx_burst(port_id, queue_id, rx_pkts, sizeof(rx_pkts)/sizeof(rx_pkts[0]));
+ 
+    for (i = 0; i < cnt; i++) {
+        rte_mbuf_t * m = rx_pkts[i];
+        int pkt_size = rte_pktmbuf_pkt_len(m);
+        uint8_t *p = rte_pktmbuf_mtod(m, uint8_t *);
+        struct arp_hdr *arp;
+        CPretestPortInfo *port = &m_port_info[port_id];
+        if (is_arp(p, pkt_size, arp)) {
+                if (arp->arp_op == htons(ARP_OP_REQUEST)) {
+                    // is this request for our IP?
+                    if (ntohl(arp->arp_data.arp_tip) == port->m_ip) {
+                        // If our request, do a shortcut, and write info directly to asking port
+                        uint8_t magic[5] = {0x1, 0x3, 0x5, 0x7, 0x9};
+                        if (! memcmp((uint8_t *)&arp->arp_data.arp_tha, magic, 5)) {
+                            uint8_t sent_port_id = arp->arp_data.arp_tha.addr_bytes[5];
+                            if ((sent_port_id < m_max_ports) &&
+                                (m_port_info[sent_port_id].m_def_gw == port->m_ip)) {
+                                memcpy(m_port_info[sent_port_id].m_dst_mac, port->m_src_mac, ETHER_ADDR_LEN);
+                                m_port_info[sent_port_id].m_state = CPretestPortInfo::RESOLVE_DONE;
+                            }
+                        }
+                    } else {
+                        // ARP request not to our IP. At the moment, we ignore this.
+                    }
+                } else {
+                    if (arp->arp_op == htons(ARP_OP_REPLY)) {
+                        // If this is response to our request, update our tables
+                        if (port->m_def_gw == ntohl(arp->arp_data.arp_sip)) {
+                            port->set_dst_mac((uint8_t *)&arp->arp_data.arp_sha);
+                        }
+                    }
+                }
+        }       
+
+        printf("port %d, queue:%d\n", port_id, queue_id);
+        utl_DumpBuffer(stdout, p, pkt_size, 0); //??? remove
+        rte_pktmbuf_free(m);
+    }
+    return 0;
+}
+
+/*
+  Try to resolve def_gw address on all ports marked as needed.
+  Return false if failed to resolve on one of the ports
+ */
+bool CPretest::resolve_all() {
+    uint16_t port;
+
+    // send ARP request on all ports
+    for (port = 0; port < m_max_ports; port++) {
+        if (m_port_info[port].m_state == CPretestPortInfo::RESOLVE_NEEDED) {
+            send_arp_req(port, false);
+        }
+    }
+
+    int max_tries = 1000;
+    int i;
+    for (i = 0; i < max_tries; i++) {
+        bool all_resolved = true;
+        for (port = 0; port < m_max_ports; port++) {
+            if (m_port_info[port].m_state == CPretestPortInfo::RESOLVE_NEEDED) {
+                // We need to stop reading packets only if all ports are resolved.
+                // If we are on loopback, We might get requests on port even after it is in RESOLVE_DONE state
+                all_resolved = false;
+            }
+            handle_rx(port, MAIN_DPDK_DATA_Q);
+            if (! CGlobalInfo::m_options.preview.get_vm_one_queue_enable())
+                handle_rx(port, MAIN_DPDK_RX_Q);
+        }
+        if (all_resolved) {
+            break;
+        } else {
+            delay(1);
+        }
+    }
+
+    if (i == max_tries) {
+        return false;
+    } else {
+        return true;
+    }
+}
+
+void CPretest::dump(FILE *fd) {
+    for (int port = 0; port < m_max_ports; port++) {
+        if (m_port_info[port].m_state != CPretestPortInfo::INIT_NEEDED) {
+            fprintf(fd, "port %d:\n", port);
+            m_port_info[port].dump(fd);
+        }
+    }
+}
+
+void CPretest::send_arp_req(uint16_t port, bool is_grat) {
+    uint16_t pkt_size;
+    uint8_t *pkt;
+    rte_mbuf_t *m[1];
+    char *p;
+    int num_sent;
+
+    pkt = m_port_info[port].create_arp_req(pkt_size, port, is_grat);
+    m[0] = CGlobalInfo::pktmbuf_alloc(0, pkt_size);
+    if ( unlikely(m[0] == 0) )  {
+        fprintf(stderr, "ERROR: Could not allocate mbuf for sending ARP to port:%d\n", port);
+        exit(1);
+    }
+    p = rte_pktmbuf_append(m[0], pkt_size);
+    memcpy(p, pkt, pkt_size);
+    free(pkt);
+
+    num_sent = rte_eth_tx_burst(port, 0, m, 1);
+    if (num_sent < 1) {
+        fprintf(stderr, "Failed sending ARP to port:%d\n", port);
+        exit(1);
+    }
+}
+
+/*
+  Send gratuitous ARP on all ports
+ */
+void CPretest::send_grat_arp_all() {
+    for (uint16_t port = 0; port < m_max_ports; port++) {
+        if (m_port_info[port].m_state == CPretestPortInfo::RESOLVE_NEEDED) {
+            send_arp_req(port, true);
+        }
+    }
+}
+
+bool CPretest::is_arp(uint8_t *p, uint16_t pkt_size, struct arp_hdr *&arp) {
+    EthernetHeader *m_ether = (EthernetHeader *)p;
+
+    if ((pkt_size < 60) ||
+        ((m_ether->getNextProtocol() != EthernetHeader::Protocol::ARP)
+         && (m_ether->getNextProtocol() != EthernetHeader::Protocol::VLAN)))
+        return false;
+
+    if (m_ether->getNextProtocol() == EthernetHeader::Protocol::ARP) {
+        arp = (struct arp_hdr *)(p + 14);
+    } else {
+        if (m_ether->getVlanProtocol() != EthernetHeader::Protocol::ARP) {
+            return false;
+        } else {
+            arp = (struct arp_hdr *)(p + 18);
+        }
+    }
+
+    return true;
+}
+
+// Should be run on setup with two interfaces connected by loopback.
+// Before running, should put ports on receive all mode. 
+void CPretest::test() {
+    uint8_t found_mac[ETHER_ADDR_LEN];
+    uint8_t mac0[ETHER_ADDR_LEN] = {0x90, 0xe2, 0xba, 0xae, 0x87, 0xd0};
+    uint8_t mac1[ETHER_ADDR_LEN] = {0x90, 0xe2, 0xba, 0xae, 0x87, 0xd1};
+    uint32_t ip0 = 0x0f000003;
+    uint32_t ip1 = 0x0f000001;
+    
+    set_port_params(0, ip0, mac0, ip1, true);
+    set_port_params(1, ip1, mac1, ip0, true);
+    dump(stdout);
+    resolve_all();
+    dump(stdout);
+    get_mac(0, ip1, found_mac);
+    if (memcmp(found_mac, mac1, ETHER_ADDR_LEN)) {
+        fprintf(stderr, "Test failed: Could not resolve def gw on port 0\n");
+        exit(1);
+    }
+
+    get_mac(1, ip0, found_mac);
+    if (memcmp(found_mac, mac0, ETHER_ADDR_LEN)) {
+        fprintf(stderr, "Test failed: Could not resolve def gw on port 1\n");
+        exit(1);
+    }
+
+    printf("Test passed\n");
+    exit(0);
+}