[dts] [PATCH V1] fix ipfrag failed on FreeBSD

xu,gang gangx.xu at intel.com
Tue Aug 29 10:04:14 CEST 2017


on FreeBSD the sed usage different with linux,
modify code on tester(linux) and copy to dut

Signed-off-by: xu,gang <gangx.xu at intel.com>
---
 tests/TestSuite_ipfrag.py | 126 ++++++++++++++++++++++++++++++++--------------
 1 file changed, 87 insertions(+), 39 deletions(-)

diff --git a/tests/TestSuite_ipfrag.py b/tests/TestSuite_ipfrag.py
index f23dbe1..95da3ed 100644
--- a/tests/TestSuite_ipfrag.py
+++ b/tests/TestSuite_ipfrag.py
@@ -84,7 +84,6 @@ class TestIpfrag(TestCase):
 
         # Based on h/w type, choose how many ports to use
         ports = self.dut.get_ports()
-        print ports
 
         # Verify that enough ports are available
         self.verify(len(ports) >= 2, "Insufficient ports for testing")
@@ -109,16 +108,29 @@ l3fwd_ipv4_route_array[] = {\\\n"
             rtLpmTbl[idx] = pat.sub(self.portRepl, rtLpmTbl[idx])
             lpmStr_ipv4 = lpmStr_ipv4 + ' ' * 4 + rtLpmTbl[idx] + ",\\\n"
         lpmStr_ipv4 = lpmStr_ipv4 + "};"
-        print lpmStr_ipv4
         lpmStr_ipv6 = "static struct l3fwd_ipv6_route l3fwd_ipv6_route_array[] = {\\\n"
         rtLpmTbl = list(lpm_table_ipv6)
         for idx in range(len(rtLpmTbl)):
             rtLpmTbl[idx] = pat.sub(self.portRepl, rtLpmTbl[idx])
             lpmStr_ipv6 = lpmStr_ipv6 + ' ' * 4 + rtLpmTbl[idx] + ",\\\n"
         lpmStr_ipv6 = lpmStr_ipv6 + "};"
-        print lpmStr_ipv6
-        self.dut.send_expect(r"sed -i '/l3fwd_ipv4_route_array\[\].*{/,/^\}\;/c\\%s' examples/ip_fragmentation/main.c" % lpmStr_ipv4, "# ")
-        self.dut.send_expect(r"sed -i '/l3fwd_ipv6_route_array\[\].*{/,/^\}\;/c\\%s' examples/ip_fragmentation/main.c" % lpmStr_ipv6, "# ")
+
+        if self.dut.get_os_type() == 'freebsd':
+            self.tester.send_expect("tar zxf dep/dpdk.tar.gz -C /tmp/", "# ")
+            self.tester.send_expect(
+                r"sed -i '/l3fwd_ipv4_route_array\[\].*{/,/^\}\;/c\\%s' /tmp/dpdk/examples/ip_fragmentation/main.c" % lpmStr_ipv4, "# ")
+            self.tester.send_expect(
+                r"sed -i '/l3fwd_ipv6_route_array\[\].*{/,/^\}\;/c\\%s' /tmp/dpdk/examples/ip_fragmentation/main.c" % lpmStr_ipv6, "# ")
+            self.dut.session.copy_file_to(
+                '/tmp/dpdk/examples/ip_fragmentation/main.c', '/root/dpdk')
+            self.dut.send_expect("mv main.c examples/ip_fragmentation/", "# ")
+
+        else:
+            self.dut.send_expect(
+                r"sed -i '/l3fwd_ipv4_route_array\[\].*{/,/^\}\;/c\\%s' examples/ip_fragmentation/main.c" % lpmStr_ipv4, "# ")
+            self.dut.send_expect(
+                r"sed -i '/l3fwd_ipv6_route_array\[\].*{/,/^\}\;/c\\%s' examples/ip_fragmentation/main.c" % lpmStr_ipv6, "# ")
+
         # make application
         out = self.dut.build_dpdk_apps("examples/ip_fragmentation")
         self.verify("Error" not in out, "compilation error 1")
@@ -148,7 +160,8 @@ l3fwd_ipv4_route_array[] = {\\\n"
             # simulate to set TG properties
             if flag == 'frag':
                 # do fragment, each packet max length 1518 - 18 - 20 = 1480
-                expPkts = (size - HEADER_SIZE['eth'] - HEADER_SIZE['ip']) / 1480
+                expPkts = (
+                    size - HEADER_SIZE['eth'] - HEADER_SIZE['ip']) / 1480
                 if (size - HEADER_SIZE['eth'] - HEADER_SIZE['ip']) % 1480:
                     expPkts += 1
                 val = 0
@@ -165,12 +178,15 @@ l3fwd_ipv4_route_array[] = {\\\n"
                 pkt_size = pkt_sizes[pkt_sizes.index(size) + times]
                 pkt = Packet(pkt_type='UDP', pkt_len=pkt_size)
                 pkt.config_layer('ether', {'dst': self.dmac})
-                pkt.config_layer('ipv4', {'dst': '100.10.0.1', 'src': '1.2.3.4', 'flags': val})
+                pkt.config_layer(
+                    'ipv4', {'dst': '100.10.0.1', 'src': '1.2.3.4', 'flags': val})
                 pkt.send_pkt(tx_port=self.txItf)
 
-            # verify normal packet just by number, verify fragment packet by all elements
+            # verify normal packet just by number, verify fragment packet by
+            # all elements
             pkts = load_sniff_packets(inst)
-            self.verify(len(pkts) == expPkts, "Failed on forward packet size " + str(size))
+            self.verify(
+                len(pkts) == expPkts, "Failed on forward packet size " + str(size))
             if flag == 'frag':
                 idx = 1
                 for pkt in pkts:
@@ -178,19 +194,23 @@ l3fwd_ipv4_route_array[] = {\\\n"
                     pkt_id = pkt.strip_element_layer3("id")
                     if idx == 1:
                         prev_idx = pkt_id
-                    self.verify(prev_idx == pkt_id, "Fragmented packets index not match")
+                    self.verify(
+                        prev_idx == pkt_id, "Fragmented packets index not match")
                     prev_idx = pkt_id
 
                     # last flags should be 0
                     flags = pkt.strip_element_layer3("flags")
                     if idx == expPkts:
-                        self.verify(flags == 0, "Fragmented last packet flags not match")
+                        self.verify(
+                            flags == 0, "Fragmented last packet flags not match")
                     else:
-                        self.verify(flags == 1, "Fragmented packets flags not match")
+                        self.verify(
+                            flags == 1, "Fragmented packets flags not match")
 
                     # fragment offset should be correct
                     frag = pkt.strip_element_layer3("frag")
-                    self.verify((frag == ((idx - 1) * 185)), "Fragment packet frag not match")
+                    self.verify(
+                        (frag == ((idx - 1) * 185)), "Fragment packet frag not match")
                     idx += 1
 
     def functional_check_ipv6(self, pkt_sizes, burst=1, flag=None, funtion=None):
@@ -200,8 +220,10 @@ l3fwd_ipv4_route_array[] = {\\\n"
         for size in pkt_sizes[::burst]:
             # simulate to set TG properties
             if flag == 'frag':
-                # each packet max len: 1518 - 18 (eth) - 40 (ipv6) - 8 (ipv6 ext hdr) = 1452
-                expPkts = (size - HEADER_SIZE['eth'] - HEADER_SIZE['ipv6']) / 1452
+                # each packet max len: 1518 - 18 (eth) - 40 (ipv6) - 8 (ipv6
+                # ext hdr) = 1452
+                expPkts = (
+                    size - HEADER_SIZE['eth'] - HEADER_SIZE['ipv6']) / 1452
                 if (size - HEADER_SIZE['eth'] - HEADER_SIZE['ipv6']) % 1452:
                     expPkts += 1
                 val = 0
@@ -215,12 +237,15 @@ l3fwd_ipv4_route_array[] = {\\\n"
                 pkt_size = pkt_sizes[pkt_sizes.index(size) + times]
                 pkt = Packet(pkt_type='IPv6_UDP', pkt_len=pkt_size)
                 pkt.config_layer('ether', {'dst': self.dmac})
-                pkt.config_layer('ipv6', {'dst': '101:101:101:101:101:101:101:101', 'src': 'ee80:ee80:ee80:ee80:ee80:ee80:ee80:ee80'})
+                pkt.config_layer(
+                    'ipv6', {'dst': '101:101:101:101:101:101:101:101', 'src': 'ee80:ee80:ee80:ee80:ee80:ee80:ee80:ee80'})
                 pkt.send_pkt(tx_port=self.txItf)
 
-            # verify normal packet just by number, verify fragment packet by all elements
+            # verify normal packet just by number, verify fragment packet by
+            # all elements
             pkts = load_sniff_packets(inst)
-            self.verify(len(pkts) == expPkts, "Failed on forward packet size " + str(size))
+            self.verify(
+                len(pkts) == expPkts, "Failed on forward packet size " + str(size))
             if flag == 'frag':
                 idx = 1
                 for pkt in pkts:
@@ -228,27 +253,33 @@ l3fwd_ipv4_route_array[] = {\\\n"
                     pkt_id = pkt.strip_element_layer4("id")
                     if idx == 1:
                         prev_idx = pkt_id
-                    self.verify(prev_idx == pkt_id, "Fragmented packets index not match")
+                    self.verify(
+                        prev_idx == pkt_id, "Fragmented packets index not match")
                     prev_idx = pkt_id
 
                     # last flags should be 0
                     flags = pkt.strip_element_layer4("m")
                     if idx == expPkts:
-                        self.verify(flags == 0, "Fragmented last packet flags not match")
+                        self.verify(
+                            flags == 0, "Fragmented last packet flags not match")
                     else:
-                        self.verify(flags == 1, "Fragmented packets flags not match")
+                        self.verify(
+                            flags == 1, "Fragmented packets flags not match")
 
                     # fragment offset should be correct
                     frag = pkt.strip_element_layer4("offset")
-                    self.verify((frag == int((idx - 1) * 181.5)), "Fragment packet frag not match")
+                    self.verify(
+                        (frag == int((idx - 1) * 181.5)), "Fragment packet frag not match")
                     idx += 1
 
     def set_up(self):
         """
         Run before each test case.
         """
-        self.tester.send_expect("ifconfig %s mtu 9200" % self.tester.get_interface(self.tester.get_local_port(P0)), "#")
-        self.tester.send_expect("ifconfig %s mtu 9200" % self.tester.get_interface(self.tester.get_local_port(P1)), "#")
+        self.tester.send_expect("ifconfig %s mtu 9200" %
+                                self.tester.get_interface(self.tester.get_local_port(P0)), "#")
+        self.tester.send_expect("ifconfig %s mtu 9200" %
+                                self.tester.get_interface(self.tester.get_local_port(P1)), "#")
 
     def test_ipfrag_normalfwd(self):
         """
@@ -290,7 +321,8 @@ l3fwd_ipv4_route_array[] = {\\\n"
         Pct = dict()
 
         if int(lcore[0]) == 1:
-            core_mask = utils.create_mask(self.dut.get_core_list(lcore, socket=self.ports_socket))
+            core_mask = utils.create_mask(
+                self.dut.get_core_list(lcore, socket=self.ports_socket))
         else:
             core_mask = utils.create_mask(self.dut.get_core_list(lcore))
 
@@ -302,29 +334,42 @@ l3fwd_ipv4_route_array[] = {\\\n"
         result = [2, lcore, num_pthreads]
         for size in size_list:
             dmac = self.dut.get_mac_address(P0)
-            flows = ['Ether(dst="%s")/IP(src="1.2.3.4", dst="100.10.0.1", flags=0)/("X"*%d)' % (dmac, size - 38),
-                     'Ether(dst="%s")/IP(src="1.2.3.4", dst="100.20.0.1", flags=0)/("X"*%d)' % (dmac, size - 38),
-                     'Ether(dst="%s")/IPv6(dst="101:101:101:101:101:101:101:101",src="ee80:ee80:ee80:ee80:ee80:ee80:ee80:ee80")/Raw(load="X"*%d)' % (dmac, size - 58),
+            flows = [
+                'Ether(dst="%s")/IP(src="1.2.3.4", dst="100.10.0.1", flags=0)/("X"*%d)' % (
+                    dmac, size - 38),
+                     'Ether(dst="%s")/IP(src="1.2.3.4", dst="100.20.0.1", flags=0)/("X"*%d)' % (
+                         dmac, size - 38),
+                     'Ether(dst="%s")/IPv6(dst="101:101:101:101:101:101:101:101",src="ee80:ee80:ee80:ee80:ee80:ee80:ee80:ee80")/Raw(load="X"*%d)' % (
+                         dmac, size - 58),
                      'Ether(dst="%s")/IPv6(dst="201:101:101:101:101:101:101:101",src="ee80:ee80:ee80:ee80:ee80:ee80:ee80:ee80")/Raw(load="X"*%d)' % (dmac, size - 58)]
-            self.tester.scapy_append('wrpcap("test1.pcap", [%s])' % string.join(flows, ','))
+            self.tester.scapy_append(
+                'wrpcap("test1.pcap", [%s])' % string.join(flows, ','))
 
             # reserved for rx/tx bidirection test
             dmac = self.dut.get_mac_address(P1)
-            flows = ['Ether(dst="%s")/IP(src="1.2.3.4", dst="100.30.0.1", flags=0)/("X"*%d)' % (dmac, size - 38),
-                     'Ether(dst="%s")/IP(src="1.2.3.4", dst="100.40.0.1", flags=0)/("X"*%d)' % (dmac, size - 38),
-                     'Ether(dst="%s")/IPv6(dst="301:101:101:101:101:101:101:101",src="ee80:ee80:ee80:ee80:ee80:ee80:ee80:ee80")/Raw(load="X"*%d)' % (dmac, size - 58),
+            flows = [
+                'Ether(dst="%s")/IP(src="1.2.3.4", dst="100.30.0.1", flags=0)/("X"*%d)' % (
+                    dmac, size - 38),
+                     'Ether(dst="%s")/IP(src="1.2.3.4", dst="100.40.0.1", flags=0)/("X"*%d)' % (
+                         dmac, size - 38),
+                     'Ether(dst="%s")/IPv6(dst="301:101:101:101:101:101:101:101",src="ee80:ee80:ee80:ee80:ee80:ee80:ee80:ee80")/Raw(load="X"*%d)' % (
+                         dmac, size - 58),
                      'Ether(dst="%s")/IPv6(dst="401:101:101:101:101:101:101:101",src="ee80:ee80:ee80:ee80:ee80:ee80:ee80:ee80")/Raw(load="X"*%d)' % (dmac, size - 58)]
-            self.tester.scapy_append('wrpcap("test2.pcap", [%s])' % string.join(flows, ','))
+            self.tester.scapy_append(
+                'wrpcap("test2.pcap", [%s])' % string.join(flows, ','))
 
             self.tester.scapy_execute()
 
             tgenInput = []
-            tgenInput.append((self.tester.get_local_port(P0), self.tester.get_local_port(P1), "test1.pcap"))
-            tgenInput.append((self.tester.get_local_port(P1), self.tester.get_local_port(P0), "test2.pcap"))
+            tgenInput.append(
+                (self.tester.get_local_port(P0), self.tester.get_local_port(P1), "test1.pcap"))
+            tgenInput.append(
+                (self.tester.get_local_port(P1), self.tester.get_local_port(P0), "test2.pcap"))
 
             factor = (size + 1517) / 1518
             # wireSpd = 2 * 10000.0 / ((20 + size) * 8)
-            Bps[str(size)], Pps[str(size)] = self.tester.traffic_generator_throughput(tgenInput)
+            Bps[str(size)], Pps[
+                str(size)] = self.tester.traffic_generator_throughput(tgenInput)
             self.verify(Pps[str(size)] > 0, "No traffic detected")
             Pps[str(size)] *= 1.0 / factor / 1000000
             Pct[str(size)] = (1.0 * Bps[str(size)] * 100) / (2 * 10000000000)
@@ -349,7 +394,8 @@ l3fwd_ipv4_route_array[] = {\\\n"
 
         self.result_table_create(tblheader)
 
-        lcores = [("1S/1C/1T", 2), ("1S/1C/2T", 2), ("1S/2C/1T", 2), ("2S/1C/1T", 2)]
+        lcores = [("1S/1C/1T", 2), ("1S/1C/2T", 2),
+                  ("1S/2C/1T", 2), ("2S/1C/1T", 2)]
         index = 1
         for (lcore, numThr) in lcores:
             self.benchmark(index, lcore, numThr, sizes)
@@ -361,8 +407,10 @@ l3fwd_ipv4_route_array[] = {\\\n"
         """
         Run after each test case.
         """
-        self.tester.send_expect("ifconfig %s mtu 1500" % self.tester.get_interface(self.tester.get_local_port(P0)), "#")
-        self.tester.send_expect("ifconfig %s mtu 1500" % self.tester.get_interface(self.tester.get_local_port(P1)), "#")
+        self.tester.send_expect("ifconfig %s mtu 1500" %
+                                self.tester.get_interface(self.tester.get_local_port(P0)), "#")
+        self.tester.send_expect("ifconfig %s mtu 1500" %
+                                self.tester.get_interface(self.tester.get_local_port(P1)), "#")
 
     def tear_down_all(self):
         """
-- 
1.9.3



More information about the dts mailing list