From: Yufen Mo <yufengx.mo@intel.com>
To: dts@dpdk.org
Cc: yufengmx <yufengx.mo@intel.com>
Subject: [dts] [PATCH V2 2/2] Ipgre: upload automation testing script
Date: Tue, 26 Jul 2016 13:45:03 +0800 [thread overview]
Message-ID: <1469511903-30103-3-git-send-email-yufengx.mo@intel.com> (raw)
In-Reply-To: <1469511903-30103-1-git-send-email-yufengx.mo@intel.com>
From: yufengmx <yufengx.mo@intel.com>
Generic Routing Encapsulation (GRE) is a tunneling protocol developed by Cisco Systems that can encapsulate
a wide variety of network layer protocols inside virtual point-to-point links over an Internet Protocol network.
Fortville support GRE packet detecting, checksum computing and filtering.
Signed-off-by: yufengmx <yufengx.mo@intel.com>
---
test_plans/ipgre_test_plan.rst | 181 +++++++++++++++++++++++++
tests/TestSuite_ipgre.py | 295 +++++++++++++++++++++++++++++++++++++++++
2 files changed, 476 insertions(+)
create mode 100644 test_plans/ipgre_test_plan.rst
create mode 100644 tests/TestSuite_ipgre.py
diff --git a/test_plans/ipgre_test_plan.rst b/test_plans/ipgre_test_plan.rst
new file mode 100644
index 0000000..444efdf
--- /dev/null
+++ b/test_plans/ipgre_test_plan.rst
@@ -0,0 +1,181 @@
+.. Copyright(c) 2010-2016 Intel Corporation
+ All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions
+ are met:
+
+ - Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+
+ - Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in
+ the documentation and/or other materials provided with the
+ distribution.
+
+ - Neither the name of Intel Corporation nor the names of its
+ contributors may be used to endorse or promote products derived
+ from this software without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+ OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+====================
+Generic Routing Encapsulation (GRE)
+====================
+
+Generic Routing Encapsulation (GRE) is a tunneling protocol developed by Cisco Systems that can encapsulate a wide variety of network layer protocols inside virtual point-to-point links over an Internet Protocol network.
+Fortville support GRE packet detecting, checksum computing and filtering.
+
+Prerequisites
+-------------
+
+Fortville nic should be on the DUT.
+
+Test cases
+----------
+
+Test Case 1: GRE ipv4 packet detect
+=================================
+Start testpmd and enable rxonly forwarding mode::
+ testpmd -c ffff -n 4 -- -i --txqflags=0x0
+ testpmd> set fwd rxonly
+ testpmd> set verbose 1
+ testpmd> start
+
+Send packet as table listed and packet type match each layer.
+
++------------+----------+-----------+----------+-----------+
+| Outer Vlan | Outer IP | Tunel | Inner L3 | Inner L4 |
++------------+----------+-----------+----------+-----------+
+| No | Ipv4 | GRE | Ipv4 | Udp |
++------------+----------+-----------+----------+-----------+
+| No | Ipv4 | GRE | Ipv4 | Tcp |
++------------+----------+-----------+----------+-----------+
+| No | Ipv4 | GRE | Ipv4 | Sctp |
++------------+----------+-----------+----------+-----------+
+| Yes | Ipv4 | GRE | Ipv4 | Udp |
++------------+----------+-----------+----------+-----------+
+| Yes | Ipv4 | GRE | Ipv4 | Tcp |
++------------+----------+-----------+----------+-----------+
+| Yes | Ipv4 | GRE | Ipv4 | Sctp |
++------------+----------+-----------+----------+-----------+
+
+
+Test Case 2: GRE ipv6 packet detect
+=================================
+Start testpmd and enable rxonly forwarding mode::
+ testpmd -c ffff -n 4 -- -i --txqflags=0x0
+ testpmd> set fwd rxonly
+ testpmd> set verbose 1
+ testpmd> start
+
+Send packet as table listed and packet type match each layer.
+Ether()/IPv6(nh=47)/GRE()/IP()/UDP()/Raw('x'*40)
+Ether()/IPv6(nh=47)/GRE(proto=0x86dd)/IPv6()/UDP()/Raw('x'*40)
++------------+----------+-----------+----------+-----------+
+| Outer Vlan | Outer IP | Tunel | Inner L3 | Inner L4 |
++------------+----------+-----------+----------+-----------+
+| No | Ipv6 | GRE | Ipv4 | Udp |
++------------+----------+-----------+----------+-----------+
+| No | Ipv6 | GRE | Ipv4 | Tcp |
++------------+----------+-----------+----------+-----------+
+| No | Ipv6 | GRE | Ipv4 | Sctp |
++------------+----------+-----------+----------+-----------+
+| Yes | Ipv6 | GRE | Ipv4 | Udp |
++------------+----------+-----------+----------+-----------+
+| Yes | Ipv6 | GRE | Ipv4 | Tcp |
++------------+----------+-----------+----------+-----------+
+| Yes | Ipv6 | GRE | Ipv4 | Sctp |
++------------+----------+-----------+----------+-----------+
+
++------------+----------+-----------+----------+-----------+
+| Outer Vlan | Outer IP | Tunel | Inner L3 | Inner L4 |
++------------+----------+-----------+----------+-----------+
+| No | Ipv6 | GRE | Ipv6 | Udp |
++------------+----------+-----------+----------+-----------+
+| No | Ipv6 | GRE | Ipv6 | Tcp |
++------------+----------+-----------+----------+-----------+
+| No | Ipv6 | GRE | Ipv6 | Sctp |
++------------+----------+-----------+----------+-----------+
+| Yes | Ipv6 | GRE | Ipv6 | Udp |
++------------+----------+-----------+----------+-----------+
+| Yes | Ipv6 | GRE | Ipv6 | Tcp |
++------------+----------+-----------+----------+-----------+
+| Yes | Ipv6 | GRE | Ipv6 | Sctp |
++------------+----------+-----------+----------+-----------+
+
+Test Case 3: GRE packet filter
+============================
+Start testpmd with multi queues::
+ testpmd -c ff -n 3 -- -i --rxq=4 --txq=4 --txqflags=0x0
+ testpmd> set fwd rxonly
+ testpmd> set nbcore 4
+ testpmd> set verbose 1
+ testpmd> start
+
+Add GRE filter that forward inner ip address 0.0.0.0 to queue 3
+ testpmd> tunnel_filter add 0 XX:XX:XX:XX:XX:XX YY:YY:YY:YY:YY:YY \
+ 0.0.0.0 1 ipingre iip 0 3
+
+Send packet inner ip address matched and check packet recevied by queue 3.
+ p = Ether()/IP()/GRE()/IP(dst="0.0.0.0")/UDP()
+
+Remove tunnel filter and check same packet recevied by queue 0
+ testpmd> tunnel_filter rm 0 XX:XX:XX:XX:XX:XX YY:YY:YY:YY:YY:YY \
+ 0.0.0.0 1 ipingre iip 0 3
+
+Add GRE filter that forward outer ip address 0.0.0.0 to queue 3
+ testpmd> tunnel_filter add 0 XX:XX:XX:XX:XX:XX YY:YY:YY:YY:YY:YY \
+ 0.0.0.0 1 ipingre oip 0 3
+
+Send packet outer ip address matched and check packet recevied by queue 3.
+
+Remove tunnel filter and check same packet recevied by queue 0.
+ testpmd> tunnel_filter rm 0 XX:XX:XX:XX:XX:XX YY:YY:YY:YY:YY:YY \
+ 0.0.0.0 1 ipingre iip 0 3
+
+Test Case 4: GRE packet chksum offload
+====================================
+Start testpmd with hardware checksum offload enabled::
+ testpmd -c ff -n 3 -- -i --txqflags=0x0 --enable-rx-cksum --port-topology=loop
+ testpmd> set verbose 1
+ testpmd> set fwd csum
+ testpmd> csum set ip hw 0
+ testpmd> csum set udp hw 0
+ testpmd> csum set sctp hw 0
+ testpmd> csum set outer-ip hw 0
+ testpmd> csum set tcp hw 0
+ testpmd> csum parse_tunnel on 0
+ testpmd> start
+
+Send packet with wrong outer IP checksum and check forwarded packet IP
+checksum is correct.
+ Ether()/IP(chksum=0x0)/GRE()/IP()/TCP()
+
+Send packet with wrong inner IP checksum and check forwarded packet IP
+checksum is correct.
+ Ether()/IP()/GRE()/IP(chksum=0x0)/TCP()
+
+Send packet with wrong inner TCP checksum and check forwarded packet TCP
+checksum is correct.
+ Ether()/IP()/GRE()/IP()/TCP(chksum=0x0)
+
+Send packet with wrong inner UDP checksum and check forwarded packet UDP
+checksum is correct.
+ Ether()/IP()/GRE()/IP()/UDP(chksum=0xffff)
+
+Send packet with wrong inner SCTP checksum and check forwarded packet SCTP
+checksum is correct.
+ Ether()/IP()/GRE()/IP()/SCTP(chksum=0x0)
diff --git a/tests/TestSuite_ipgre.py b/tests/TestSuite_ipgre.py
new file mode 100644
index 0000000..a628f59
--- /dev/null
+++ b/tests/TestSuite_ipgre.py
@@ -0,0 +1,295 @@
+# BSD LICENSE
+#
+# Copyright(c) 2010-2014 Intel Corporation. All rights reserved.
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions
+# are met:
+#
+# * Redistributions of source code must retain the above copyright
+# notice, this list of conditions and the following disclaimer.
+# * Redistributions in binary form must reproduce the above copyright
+# notice, this list of conditions and the following disclaimer in
+# the documentation and/or other materials provided with the
+# distribution.
+# * Neither the name of Intel Corporation nor the names of its
+# contributors may be used to endorse or promote products derived
+# from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+"""
+DPDK Test suite.
+
+Generic Routing Encapsulation (GRE) is a tunneling protocol developed by
+Cisco Systems that can encapsulate a wide variety of network layer protocols
+inside virtual point-to-point links over an Internet Protocol network.
+
+Fortville support GRE packet detecting, checksum computing and filtering.
+"""
+
+import time
+import os
+
+import dts
+from test_case import TestCase
+from exception import VerifyFailure
+from packet import Packet
+
+class TestIpgre(TestCase):
+
+ def set_up_all(self):
+ """
+ Run at the start of each test suite.
+ """
+ self.printFlag = dts.debug_mode
+ self.src_mac = "11:22:33:44:55:66"
+ ports = self.dut.get_ports()
+ self.verify(self.nic.startswith("fortville"),
+ "GRE tunnel packet type only support by Fortville")
+ self.verify(len(ports) >= 1, "Insufficient ports for testing")
+ valports = [_ for _ in ports if self.tester.get_local_port(_) != -1]
+ # start testpmd
+ self.dut_port = valports[0]
+ tester_port = self.tester.get_local_port(self.dut_port)
+ self.tester_iface = self.tester.get_interface(tester_port)
+ self.tester_iface_mac = self.tester.get_mac(tester_port)
+
+ def set_up(self):
+ """
+ Run before each test case.
+ Nothing to do.
+ """
+ pass
+
+ def check_packet_transmission(self, pkt_types, layer_configs=None):
+ time.sleep(1)
+ for pkt_type in pkt_types.keys():
+ pkt_names = pkt_types[pkt_type]
+ pkt = Packet(pkt_type=pkt_type)
+ if layer_configs:
+ for layer in layer_configs.keys():
+ pkt.config_layer(layer, layer_configs[layer])
+ pkt.send_pkt(tx_port=self.tester_iface)
+ out = self.dut.get_session_output(timeout=2)
+ if self.printFlag: # debug output
+ print out
+ for pkt_layer_name in pkt_names:
+ if self.printFlag:# debug output
+ print pkt_layer_name
+ if pkt_layer_name not in out:
+ print dts.RED("Fail to detect %s" % pkt_layer_name)
+ if not self.printFlag:
+ raise VerifyFailure("Failed to detect %s" % pkt_layer_name)
+ else:
+ print dts.GREEN("Detected %s successfully" % pkt_type)
+ time.sleep(1)
+
+ def test_GRE_ipv4_packet_detect(self):
+ """
+ Start testpmd and enable rxonly forwarding mode
+ Send packet as table listed and packet type match each layer
+ """
+ pkt_types = {
+ "MAC_IP_GRE_IP_UDP_PKT": ["Tunnel type: GRENAT", "Inner L4 type: UDP"],
+ "MAC_IP_GRE_IP_TCP_PKT": ["Tunnel type: GRENAT", "Inner L4 type: TCP"],
+ "MAC_IP_GRE_IP_SCTP_PKT": ["Tunnel type: GRENAT", "Inner L4 type: SCTP"],
+ "MAC_VLAN_IP_GRE_IP_UDP_PKT": ["Tunnel type: GRENAT", "Inner L4 type: UDP"],
+ "MAC_VLAN_IP_GRE_IP_TCP_PKT": ["Tunnel type: GRENAT", "Inner L4 type: TCP"],
+ "MAC_VLAN_IP_GRE_IP_SCTP_PKT": ["Tunnel type: GRENAT", "Inner L4 type: SCTP"]
+ }
+ config_layers = {'ether': {'src': self.src_mac},
+ 'ipv4': {'proto': 'gre'}}
+ # Start testpmd and enable rxonly forwarding mode
+ testpmd_cmd = "./%s/app/testpmd -c ffff -n 4 -- -i --enable-rx-cksum --enable-rx-cksum" % self.target
+ self.dut.send_expect( testpmd_cmd,
+ "testpmd>",
+ 20)
+ self.dut.send_expect("set fwd rxonly", "testpmd>")
+ self.dut.send_expect("set verbose 1", "testpmd>")
+ self.dut.send_expect("start", "testpmd>")
+
+ self.check_packet_transmission(pkt_types, config_layers)
+
+ self.dut.send_expect("quit", "#")
+
+ def test_GRE_ipv6_packet_detect(self):
+ """
+ Start testpmd and enable rxonly forwarding mode
+ Send packet as table listed and packet type match each layer
+ """
+ pkt_types_ipv6_ip = {
+ "MAC_IPv6_GRE_IP_UDP_PKT": ["Tunnel type: GRENAT", "Inner L4 type: UDP"],
+ "MAC_IPv6_GRE_IP_TCP_PKT": ["Tunnel type: GRENAT", "Inner L4 type: TCP"],
+ "MAC_IPv6_GRE_IP_SCTP_PKT": ["Tunnel type: GRENAT", "Inner L4 type: SCTP"],
+ "MAC_VLAN_IPv6_GRE_IP_UDP_PKT": ["Tunnel type: GRENAT", "Inner L4 type: UDP", "PKT_RX_VLAN_PKT"],
+ "MAC_VLAN_IPv6_GRE_IP_TCP_PKT": ["Tunnel type: GRENAT", "Inner L4 type: TCP", "PKT_RX_VLAN_PKT"],
+ "MAC_VLAN_IPv6_GRE_IP_SCTP_PKT": ["Tunnel type: GRENAT", "Inner L4 type: SCTP", "PKT_RX_VLAN_PKT"]
+ }
+
+ pkt_types_ipv6_ipv6 = {
+ "MAC_IPv6_GRE_IPv6_UDP_PKT": ["Tunnel type: GRENAT", "Inner L4 type: UDP"],
+ "MAC_IPv6_GRE_IPv6_TCP_PKT": ["Tunnel type: GRENAT", "Inner L4 type: TCP"],
+ "MAC_VLAN_IPv6_GRE_IPv6_UDP_PKT": ["Tunnel type: GRENAT", "Inner L4 type: UDP", "PKT_RX_VLAN_PKT"],
+ "MAC_VLAN_IPv6_GRE_IPv6_TCP_PKT": ["Tunnel type: GRENAT", "Inner L4 type: TCP", "PKT_RX_VLAN_PKT"]
+ }
+
+ pkt_types_ipv6_ipv6_SCTP = {
+ "MAC_IPv6_GRE_IPv6-TUNNEL_SCTP_PKT": ["Tunnel type: GRENAT", "Inner L4 type: SCTP"],
+ "MAC_VLAN_IPv6_GRE_IPv6-TUNNEL_SCTP_PKT": ["Tunnel type: GRENAT", "Inner L4 type: SCTP", "PKT_RX_VLAN_PKT"]
+ }
+
+ # Start testpmd and enable rxonly forwarding mode
+ testpmd_cmd = "./%s/app/testpmd -c ffff -n 4 -- -i --enable-rx-cksum" % self.target
+ self.dut.send_expect(testpmd_cmd, "testpmd>", 20)
+ self.dut.send_expect("set fwd rxonly", "testpmd>")
+ self.dut.send_expect("set verbose 1", "testpmd>")
+ self.dut.send_expect("start", "testpmd>")
+
+ # inner ipv4
+ config_layers = {'ether': {'src': self.src_mac},
+ 'ipv6': {'nh': 47},
+ 'raw': {'payload':['78']*40}}
+ self.check_packet_transmission(pkt_types_ipv6_ip, config_layers)
+
+ # inner ipv6
+ config_layers = {'ether': {'src': self.src_mac},
+ 'ipv6': {'nh': 47},
+ 'gre': {'proto': 0x86dd},
+ 'raw': {'payload':['78']*40}}
+ self.check_packet_transmission(pkt_types_ipv6_ipv6, config_layers)
+
+ # inner ipv6 SCTP
+ config_layers = {'ether': {'src': self.src_mac},
+ 'ipv6': {'nh': 47},
+ 'gre': {'proto': 0x86dd},
+ 'inner_ipv6': {'nh': 132},
+ 'raw': {'payload':['78']*40}}
+ self.check_packet_transmission(pkt_types_ipv6_ipv6_SCTP, config_layers)
+ self.dut.send_expect("quit", "#")
+
+ def test_GRE_packet_filter(self):
+ """
+ Start testpmd with multi queues, add GRE filter that forward
+ inner/outer ip address 0.0.0.0 to queue 3, Send packet inner
+ ip address matched and check packet recevied by queue 3
+ """
+ outer_mac = self.tester_iface_mac
+ inner_mac = "10:00:00:00:00:00"
+
+ # Start testpmd with multi queues
+ testpmd_cmd = "./%s/app/testpmd -c ff -n 3 -- -i --enable-rx-cksum --rxq=4 --txq=4" % self.target
+ self.dut.send_expect(testpmd_cmd, "testpmd>", 20)
+ self.dut.send_expect("set fwd rxonly", "testpmd>")
+ self.dut.send_expect("set nbcore 4", "testpmd>")
+ self.dut.send_expect("set verbose 1", "testpmd>")
+ self.dut.send_expect("start", "testpmd>")
+
+ # Add GRE filter that forward inner ip address 0.0.0.0 to queue 3
+ cmd = "tunnel_filter add 0 %s %s 0.0.0.0 1 ipingre iip 0 3"%(outer_mac, inner_mac)
+ self.dut.send_expect( cmd, "testpmd>")
+
+ # Send packet inner ip address matched and check packet recevied by queue 3
+ pkt_types = {"MAC_IP_GRE_IP_UDP_PKT": ["Tunnel type: GRENAT", "Inner L4 type: UDP"]}
+ config_layers = {'ether': {'src': self.src_mac},
+ 'ipv4': {'dst': "0.0.0.0", 'proto': 'gre'}}
+ self.check_packet_transmission(pkt_types, config_layers)
+
+ # Remove tunnel filter and check same packet recevied by queue 0
+ cmd = "tunnel_filter rm 0 %s %s 0.0.0.0 1 ipingre iip 0 3"%(outer_mac, inner_mac)
+ self.dut.send_expect( cmd, "testpmd>")
+
+ # Add GRE filter that forward outer ip address 0.0.0.0 to queue 3
+ cmd = "tunnel_filter add 0 %s %s 0.0.0.0 1 ipingre oip 0 3"%(outer_mac, inner_mac)
+ self.dut.send_expect( cmd, "testpmd>")
+
+ # Send packet outer ip address matched and check packet recevied by queue 3.
+ pkt_types = {"MAC_IP_GRE_IP_UDP_PKT": ["Tunnel type: GRENAT", "Inner L4 type: UDP"]}
+ config_layers = {'ether': {'src': self.src_mac},
+ 'ipv4': {'dst': "0.0.0.0", 'proto': 'gre'}}
+ self.check_packet_transmission(pkt_types, config_layers)
+
+ # Add GRE filter that forward outer ip address 0.0.0.0 to queue 3
+ cmd = "tunnel_filter rm 0 %s %s 0.0.0.0 1 ipingre iip 0 3"%(outer_mac, inner_mac)
+ self.dut.send_expect( cmd, "testpmd>")
+ time.sleep(2)
+ self.dut.send_expect("quit", "#")
+
+ def test_GRE_packet_chksum_offload(self):
+ """
+ Start testpmd with hardware checksum offload enabled,
+ Send packet with wrong IP/TCP/UDP/SCTP checksum and check forwarded packet checksum
+ """
+ # Start testpmd and enable rxonly forwarding mode
+ testpmd_cmd = "./%s/app/testpmd -c ff -n 3 -- -i --enable-rx-cksum --txqflags=0x0 --port-topology=loop" % self.target
+ self.dut.send_expect(testpmd_cmd, "testpmd>", 20)
+ self.dut.send_expect("set verbose 1", "testpmd>")
+ self.dut.send_expect("set fwd csum", "testpmd>")
+ self.dut.send_expect("csum set ip hw 0", "testpmd>")
+ self.dut.send_expect("csum set udp hw 0", "testpmd>")
+ self.dut.send_expect("csum set sctp hw 0", "testpmd>")
+ self.dut.send_expect("csum set outer-ip hw 0", "testpmd>")
+ self.dut.send_expect("csum set tcp hw 0", "testpmd>")
+ self.dut.send_expect("csum parse_tunnel on 0", "testpmd>")
+ self.dut.send_expect("start", "testpmd>")
+
+ # Send packet with wrong outer IP checksum and check forwarded packet IP checksum is correct
+ pkt_types = { "MAC_IP_GRE_IP_TCP_PKT": ["PKT_TX_OUTER_IP_CKSUM"]}
+ config_layers = {'ether': {'src': self.src_mac},
+ 'ipv4': {'chksum': 0x0, 'proto': 'gre'}}
+ self.check_packet_transmission(pkt_types, config_layers)
+
+ # Send packet with wrong inner IP checksum and check forwarded packet IP checksum is correct
+ pkt_types = { "MAC_IP_GRE_IP_TCP_PKT": ["PKT_TX_IP_CKSUM"]}
+ config_layers = {'ether': {'src': self.src_mac},
+ 'inner_ipv4': {'chksum': 0x0, 'proto': 'gre'}}
+ self.check_packet_transmission(pkt_types, config_layers)
+
+ # Send packet with wrong inner TCP checksum and check forwarded packet TCP checksum is correct
+ pkt_types = { "MAC_IP_GRE_IP_TCP_PKT": ["PKT_TX_TCP_CKSUM"]}
+ config_layers = {'ether': {'src': self.src_mac},
+ 'tcp': {'chksum': 0x0},
+ 'ipv4': {'proto': 'gre'}}
+ self.check_packet_transmission(pkt_types, config_layers)
+
+ # Send packet with wrong inner UDP checksum and check forwarded packet UDP checksum is correct
+ pkt_types = { "MAC_IP_GRE_IP_UDP_PKT": ["PKT_TX_UDP_CKSUM"]}
+ config_layers = {'ether': {'src': self.src_mac},
+ 'udp': {'chksum': 0xffff},
+ 'ipv4': {'proto': 'gre'}}
+ self.check_packet_transmission(pkt_types, config_layers)
+
+ # Send packet with wrong inner SCTP checksum and check forwarded packet SCTP checksum is correct
+ pkt_types = { "MAC_IP_GRE_IP_SCTP_PKT": ["PKT_TX_SCTP_CKSUM"]}
+ config_layers = {'ether': {'src': self.src_mac},
+ 'ipv4': {'proto': 'gre'},
+ 'sctp': {'chksum': 0x0}}
+ self.check_packet_transmission(pkt_types , config_layers)
+
+ self.dut.send_expect("quit", "#")
+
+ def tear_down(self):
+ """
+ Run after each test case.
+ Nothing to do.
+ """
+ pass
+
+ def tear_down_all(self):
+ """
+ Run after each test suite.
+ Nothing to do.
+ """
+ self.dut.kill_all()
+ pass
--
1.9.3
next prev parent reply other threads:[~2016-07-26 5:45 UTC|newest]
Thread overview: 5+ messages / expand[flat|nested] mbox.gz Atom feed top
2016-07-26 5:45 [dts] [PATCH V2 0/2] Ipgre " Yufen Mo
2016-07-26 5:45 ` [dts] [PATCH V2 1/2] add sctp/gre format support in framework/packet module Yufen Mo
2016-07-26 5:45 ` Yufen Mo [this message]
2016-07-26 8:28 ` [dts] [PATCH V2 2/2] Ipgre: upload automation testing script Liu, Yong
2016-07-27 0:32 ` Liu, Yong
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=1469511903-30103-3-git-send-email-yufengx.mo@intel.com \
--to=yufengx.mo@intel.com \
--cc=dts@dpdk.org \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for NNTP newsgroup(s).