[dts] [PATCH] tests: add TestSuite_generic_flow_api.py
Peng Yuan
yuan.peng at intel.com
Wed Apr 25 10:05:03 CEST 2018
Add a new test suite "TestSuite_generic_flow_api.py"
Signed-off-by: Peng Yuan <yuan.peng at intel.com>
diff --git a/tests/TestSuite_generic_flow_api.py b/tests/TestSuite_generic_flow_api.py
new file mode 100644
index 0000000..1185f4f
--- /dev/null
+++ b/tests/TestSuite_generic_flow_api.py
@@ -0,0 +1,1537 @@
+# BSD LICENSE
+#
+# Copyright(c) 2010-2017 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.
+
+Test the support of VLAN Offload Features by Poll Mode Drivers.
+
+"""
+
+import utils
+import time
+import re
+
+from test_case import TestCase
+from settings import HEADER_SIZE
+from pmd_output import PmdOutput
+from settings import DRIVERS
+from crb import Crb
+
+from virt_dut import VirtDut
+from project_dpdk import DPDKdut
+from dut import Dut
+from packet import Packet
+
+import os
+import random
+from exception import VerifyFailure
+import scapy.layers.inet
+from scapy.utils import rdpcap
+
+MAX_VLAN = 4095
+MAX_QUEUE = 15
+MAX_VFQUEUE = 3
+MAX_PORT = 65535
+MAX_PROTO = 133
+MAX_TTL = 255
+MAX_TOS = 255
+
+class TestGeneric_flow_api(TestCase):
+
+ def set_up_all(self):
+ """
+ Run at the start of each test suite.
+ Generic filter Prerequistites
+ """
+
+ # Based on h/w type, choose how many ports to use
+ self.dut_ports = self.dut.get_ports(self.nic)
+ # Verify that enough ports are available
+ self.verify(len(self.dut_ports) >= 1, "Insufficient ports")
+ self.cores = "1S/8C/1T"
+ self.pf_cores = "1S/16C/1T"
+ self.pmdout = PmdOutput(self.dut)
+
+ localPort = self.tester.get_local_port(self.dut_ports[0])
+ self.tester_itf = self.tester.get_interface(localPort)
+ self.pf_interface = self.dut.ports_info[self.dut_ports[0]]['intf']
+ self.pf_mac = self.dut.get_mac_address(0)
+ self.pf_pci = self.dut.ports_info[self.dut_ports[0]]['pci']
+
+ self.session_secondary = self.dut.new_session()
+ self.session_third = self.dut.new_session()
+ self.outer_mac = "00:11:22:33:44:55"
+ self.inner_mac = "00:11:22:33:44:66"
+ self.wrong_mac = "00:11:22:33:44:77"
+ self.vf_flag = 0
+
+ def set_up(self):
+ """
+ Run before each test case.
+ """
+ self.dut.kill_all()
+
+ def setup_env(self):
+ """
+ This is to set up 1pf and 2vfs environment.
+ The pf is bound to dpdk driver.
+ """
+ self.vf_flag = 1
+ # create two vfs
+ self.dut.generate_sriov_vfs_by_port(self.dut_ports[0], 2, self.drivername)
+ self.sriov_vfs_port = self.dut.ports_info[self.dut_ports[0]]['vfs_port']
+ try:
+ for port in self.sriov_vfs_port:
+ port.bind_driver(driver="vfio-pci")
+ except Exception as e:
+ self.destroy_env()
+ raise Exception(e)
+
+ def destroy_env(self):
+ """
+ This is to stop testpmd and destroy 1pf and 2vfs environment.
+ """
+ if self.vf_flag == 1:
+ self.session_third.send_expect("quit", "# ")
+ time.sleep(2)
+ self.session_secondary.send_expect("quit", "# ")
+ time.sleep(2)
+ self.dut.send_expect("quit", "# ")
+ time.sleep(2)
+ self.dut.destroy_sriov_vfs_by_port(self.dut_ports[0])
+ else:
+ self.dut.send_expect("quit", "# ")
+ time.sleep(2)
+ self.vf_flag = 0
+
+ def verify_result(self, pf_vf, expect_rxpkts, expect_queue):
+ """
+ verify the packet to the expected queue or be dropped
+ """
+ self.tester.scapy_execute()
+ time.sleep(2)
+
+ if self.vf_flag == 1:
+ outstring_vf0 = self.session_secondary.send_expect("stop", "testpmd> ", 120)
+ outstring_vf1 = self.session_third.send_expect("stop", "testpmd> ", 120)
+ outstring_pf = self.dut.send_expect("stop", "testpmd> ", 120)
+ time.sleep(2)
+ if expect_rxpkts == "0":
+ if pf_vf == "pf":
+ self.verify("Queue" not in outstring_pf, "the packet is not dropped.")
+ elif pf_vf == "vf0":
+ self.verify("Queue" not in outstring_vf0, "the packet is not dropped.")
+ else:
+ self.verify("Queue" not in outstring_vf1, "the packet is not dropped.")
+ else:
+ result_scanner = r"Forward Stats for RX Port= %s/Queue=\s?([0-9]+)" % self.dut_ports[0]
+ scanner = re.compile(result_scanner, re.DOTALL)
+ if pf_vf == "pf":
+ m = scanner.search(outstring_pf)
+ elif pf_vf == "vf0":
+ m = scanner.search(outstring_vf0)
+ else:
+ m = scanner.search(outstring_vf1)
+ queue_id = m.group(1)
+ self.verify(int(expect_queue) == int(queue_id), "the actual queue doesn't equal to the expected queue.")
+
+ self.dut.send_expect("start", "testpmd> ")
+
+ if self.vf_flag == 1:
+ self.session_secondary.send_expect("start", "testpmd> ")
+ self.session_third.send_expect("start", "testpmd> ")
+
+ def compare_memory_rules(self, expectedRules):
+ """
+ dump all flow rules that have been created in memory and compare that total rules number with the given expected number
+ to see if they are equal, as to get your conclusion after you have deleted any flow rule entry.
+ """
+ outstring = self.dut.send_expect("flow list 0", "testpmd> ")
+ result_scanner = r'\d*.*?\d*.*?\d*.*?=>*'
+ scanner = re.compile(result_scanner, re.DOTALL)
+ m = scanner.findall(outstring)
+ print "All flow entries are: "
+ for i in range(len(m)):
+ print m[i]
+ print 'Expected rules are: %d - actual are: %d' % (expectedRules, len(m))
+ self.verify(expectedRules == len(m), 'Total rules number mismatched')
+
+ def all_flows_process(self, basic_flow_actions):
+ """
+ Verify all the flows' action and return the created rule number.
+ Return all the rules' elements to create inconsistet packets.
+ Return all the expect queues which are consistent to the rules.
+ """
+ extra_packet = []
+ expected_queue = []
+ rule_num = 0
+ for flow_action in basic_flow_actions:
+ # generate the flow rule and corresponding packet.
+ flow_process = self.generate_random_command(**flow_action)
+ expected_queue.append(flow_process['queue'])
+ # caculate the rule number created.
+ rule_created = self.flow_test_process(flow_process, flow_action)
+ if rule_created:
+ rule_num += 1
+ extra_packet.append(flow_process['extrapacket'])
+ # Configure a return value.
+ extrapkt_rulenum = {'extrapacket': extra_packet, 'rulenum': rule_num, 'queue': expected_queue}
+
+ return extrapkt_rulenum
+
+ def verify_rulenum(self, rule_num):
+ """
+ Verify all the rules created.
+ """
+ # check if there are expected flow rules have been created
+ self.compare_memory_rules(rule_num)
+ # check if one rule destoried with success
+ self.dut.send_expect("flow destroy 0 rule 0", "testpmd> ")
+ self.compare_memory_rules(rule_num - 1)
+ # check if all flow rules have been removed with success
+ self.dut.send_expect("flow flush 0", "testpmd> ")
+ self.compare_memory_rules(0)
+
+ def flow_test_process(self, flow_process, flow_action):
+ """
+ Add a flow rule and verify the action
+ """
+ rule_created = 0
+ flow_cmd = flow_process['cmd']
+ flow_pkt = flow_process['pkt']
+ flow_queue = flow_process['queue']
+ if "validate" in flow_cmd:
+ # ethertype invalid or queue id exceeds max queue number.
+ if "86dd" in flow_cmd or "0800" in flow_cmd or "index %s" % str(MAX_QUEUE + 1) in flow_cmd:
+ if self.nic in ["fortville_eagle", "fortville_spirit", "fortville_spirit_single", "fortpark_TLV", "niantic", "kawela_4", "kawela", "bartonhills", "twinville", "sagepond", "sageville", "powerville"]:
+ self.dut.send_expect(flow_cmd, "error")
+ elif "88cc" in flow_cmd or "type is 0x8100" in flow_cmd:
+ if self.nic in ["fortville_eagle", "fortville_spirit", "fortville_spirit_single", "fortpark_TLV"]:
+ self.dut.send_expect(flow_cmd, "error")
+ # vf queue id exceeds max vf queue number.
+ elif (("vf0" in flow_action['flows']) or ("vf1" in flow_action['flows']) or ("vf0" in flow_action['actions']) or ("vf1" in flow_action['actions'])) and (("index %s" % str(MAX_VFQUEUE + 1)) in flow_cmd):
+ self.dut.send_expect(flow_cmd, "error")
+ else:
+ self.dut.send_expect(flow_cmd, "validated")
+ elif "create" in flow_cmd:
+ # ethertype invalid or queue id exceeds max queue number.
+ if "86dd" in flow_cmd or "0800" in flow_cmd or "index %s" % str(MAX_QUEUE + 1) in flow_cmd:
+ if self.nic in ["fortville_eagle", "fortville_spirit", "fortville_spirit_single", "fortpark_TLV", "niantic", "kawela_4", "kawela", "bartonhills", "twinville", "sagepond", "sageville", "powerville"]:
+ self.dut.send_expect(flow_cmd, "error")
+ elif "88cc" in flow_cmd or "type is 0x8100" in flow_cmd:
+ if self.nic in ["fortville_eagle", "fortville_spirit", "fortville_spirit_single", "fortpark_TLV"]:
+ self.dut.send_expect(flow_cmd, "error")
+ # vf queue id exceeds max vf queue number.
+ elif (("vf0" in flow_action['flows']) or ("vf1" in flow_action['flows']) or ("vf0" in flow_action['actions']) or ("vf1" in flow_action['actions'])) and (("index %s" % str(MAX_VFQUEUE + 1)) in flow_cmd):
+ self.dut.send_expect(flow_cmd, "error")
+ else:
+ self.dut.send_expect(flow_cmd, "created")
+ rule_created = 1
+ # the rule is created successfully, so send the consistent packet.
+ self.tester.scapy_append('sendp(%s, iface="%s")' % (flow_pkt, self.tester_itf))
+ if ("queue" in flow_action['actions']) or ("passthru" in flow_action['actions']):
+ if ("vf0" in flow_action['flows']) or ("vf0" in flow_action['actions']):
+ self.verify_result("vf0", expect_rxpkts="1", expect_queue=flow_queue)
+ elif "vf1" in flow_action['flows'] or "vf1" in flow_action['actions']:
+ self.verify_result("vf1", expect_rxpkts="1", expect_queue=flow_queue)
+ else:
+ self.verify_result("pf", expect_rxpkts="1", expect_queue=flow_queue)
+ elif "drop" in flow_action['actions']:
+ if ("vf0" in flow_action['flows']) or ("vf0" in flow_action['actions']):
+ self.verify_result("vf0", expect_rxpkts="0", expect_queue="NULL")
+ elif ("vf1" in flow_action['flows']) or ("vf1" in flow_action['actions']):
+ self.verify_result("vf1", expect_rxpkts="0", expect_queue="NULL")
+ else:
+ self.verify_result("pf", expect_rxpkts="0", expect_queue="NULL")
+ # L2-tunnel filter
+ else:
+ if "vf0" in flow_action['actions']:
+ self.verify_result("vf0", expect_rxpkts="1", expect_queue="0")
+ elif "vf1" in flow_action['actions']:
+ self.verify_result("vf1", expect_rxpkts="1", expect_queue="0")
+ elif "pf" in flow_action['actions']:
+ self.verify_result("pf", expect_rxpkts="1", expect_queue="0")
+ # Return the status of the rule.
+ return rule_created
+
+ def generate_random_mac(self):
+ return ':'.join('%02x' % random.randint(0, 255) for i in range(6))
+
+ def generate_random_ip(self, is_ipv4):
+ if is_ipv4 == True:
+ return '.'.join('%s' % random.randint(0, 255) for i in range(4))
+ else:
+ return ':'.join('{:x}'.format(random.randint(0, 2**16 - 1)) for i in range(8))
+
+ def generate_random_int(self, minimum, maximum):
+ return random.randint(minimum, maximum)
+
+ def generate_random_command(self, create, flows=[], actions=[]):
+ """
+ Return random content for flow and action commands
+ Parameters:
+ create : create the rule or validate the rule
+ flows [] : assigned flow layers
+ actions [] : flow actions
+ Return the packets including the consistent packet and inconsistent
+ packet.
+ Return the expected queue which the packet distributed.
+ """
+ # Define the flow rule command.
+ cmd_fmt = "flow %(create)s 0 ingress pattern %(flow)s / end actions %(action)s end"
+ # Record the elements of the rule, ready for the configuration
+ # of packets inconsistent to the rule.
+ extrapacket = {'vlan': '', 'etag': '', 'ipv4': '', 'ipv6': '', 'sip': '', 'dip': '', 'proto': '', 'tos': '', 'ttl': '', 'tcp': '', 'udp': '', 'sctp': '', 'sport': '', 'dport': '', 'vni': '', 'tni': '', 'ineth': '', 'invlan': ''}
+ # Define the packet string, which is consistent to the flow rule.
+ if ('vf0' in flows) or ('vf1' in flows) or ('vf0' in actions) or ('vf1' in actions):
+ pkt = "Ether(dst='%s')" % self.wrong_mac
+ else:
+ pkt = "Ether(dst='%s')" % self.pf_mac
+ # Define the flow string of the rule
+ # Signature mode
+ if 'fuzzy' in flows:
+ thresh = self.generate_random_int(1, 15)
+ flow_str = "fuzzy thresh is %d " % thresh
+ # L2 tunnel
+ elif 'etag' in flows:
+ ecid = self.generate_random_int(4096, 8191)
+ flow_str = "e_tag grp_ecid_b is %s " % hex(ecid)
+ pkt += "/Dot1BR(GRP=0x1, ECIDbase=%s)" % hex(ecid - 4096)
+ extrapacket['etag'] = hex(ecid - 4096)
+ else:
+ flow_str = "eth "
+ # Configure the flow and packet and extrapacket string
+ for flow_type in flows:
+ if flow_type == "dst_mac":
+ dmac = self.outer_mac
+ flow_str += "dst is %s " % dmac
+ pkt = "Ether(dst='%s')" % dmac
+ elif flow_type == "ether":
+ if "dst_mac" in flows:
+ dmac = self.outer_mac
+ pkt = "Ether(dst='%s'" % dmac
+ else:
+ pkt = "Ether(dst='%s'" % self.pf_mac
+ if 'eaps' in flows:
+ eth_type = "0x8100"
+ pkt += ",type=0x8100)/Raw('x' * 20)"
+ elif 'lwapp' in flows:
+ eth_type = "0x86bb"
+ pkt += ",type=0x86bb)/Raw('x' * 20)"
+ elif 'lldp' in flows:
+ eth_type = "0x88cc"
+ pkt += ",type=0x88cc)/Raw('x' * 20)"
+ elif 'ipv6_eth' in flows:
+ eth_type = "0x86dd"
+ pkt += ",type=0x86dd)/Raw('x' * 20)"
+ elif 'arp' in flows:
+ eth_type = "0x0806"
+ pkt = "Ether(dst='ff:ff:ff:ff:ff:ff')/ARP(pdst='192.168.1.1')"
+ elif 'ip_eth' in flows:
+ eth_type = "0x0800"
+ pkt += ",type=0x0800)/Raw('x' * 20)"
+ elif 'ppp' in flows:
+ eth_type = "0x8864"
+ pkt += ",type=0x8864)/Raw('x' * 20)"
+ elif 'mpls' in flows:
+ eth_type = "0x8847"
+ pkt += ",type=0x8847)/Raw('x' * 20)"
+ else:
+ eth_type = "0x8000"
+ pkt += ",type=0x8000)/Raw('x' * 20)"
+ flow_str += "type is %s " % eth_type
+ elif flow_type == "vlan":
+ vlan = self.generate_random_int(0, MAX_VLAN)
+ flow_str += "/ vlan tci is %d " % vlan
+ pkt += "/Dot1Q(vlan=%d)" % vlan
+ extrapacket['vlan'] = str(vlan)
+ elif flow_type == "tpid":
+ flow_str += "tpid is 0x8100 "
+ elif flow_type == "ipv4":
+ is_ipv4 = True
+ flow_str += "/ ipv4 "
+ pkt += "/IP("
+ sip = self.generate_random_ip(is_ipv4)
+ dip = self.generate_random_ip(is_ipv4)
+ if 'sip' in flows:
+ flow_str += "src is %s " % sip
+ extrapacket['sip'] = sip
+ pkt += "src='%s'" % sip
+ if 'dip' in flows:
+ flow_str += "dst is %s " % dip
+ extrapacket['dip'] = dip
+ pkt += ", dst='%s'" % dip
+ if 'proto' in flows:
+ if "udp" in flows:
+ proto = 17
+ extrapacket['proto'] = '17'
+ elif "tcp" in flows:
+ proto = 6
+ extrapacket['proto'] = '6'
+ elif "sctp" in flows:
+ proto = 132
+ extrapacket['proto'] = '132'
+ else:
+ proto = self.generate_random_int(0, MAX_PROTO)
+ extrapacket['proto'] = str(proto)
+ flow_str += "proto is %d " % proto
+ if 'sip' in flows or 'dip' in flows:
+ pkt += ", proto=%d" % proto
+ # for 2-tuple
+ else:
+ pkt += "proto=%d" % proto
+ if 'tos' in flows:
+ tos = self.generate_random_int(0, MAX_TOS)
+ flow_str += "tos is %d " % tos
+ pkt += ", tos=%d" % tos
+ extrapacket['tos'] = tos
+ if 'ttl' in flows:
+ ttl = self.generate_random_int(0, MAX_TTL)
+ flow_str += "ttl is %d " % ttl
+ pkt += ", ttl=%d" % ttl
+ extrapacket['ttl'] = ttl
+ pkt += ")"
+ elif flow_type == "ipv6":
+ is_ipv4 = False
+ flow_str += "/ ipv6 "
+ sip = self.generate_random_ip(is_ipv4)
+ dip = self.generate_random_ip(is_ipv4)
+ if 'sip' in flows:
+ flow_str += "src is %s " % sip
+ extrapacket['sip'] = sip
+ if 'dip' in flows:
+ flow_str += "dst is %s " % dip
+ extrapacket['dip'] = dip
+ pkt += "/IPv6(src='%s', dst='%s'" % (sip, dip)
+ if 'proto' in flows:
+ if "udp" in flows:
+ proto = 17
+ extrapacket['proto'] = '17'
+ elif "tcp" in flows:
+ proto = 6
+ extrapacket['proto'] = '6'
+ elif "sctp" in flows:
+ proto = 132
+ extrapacket['proto'] = '132'
+ else:
+ proto = self.generate_random_int(0, MAX_PROTO)
+ extrapacket['proto'] = str(proto)
+ flow_str += "proto is %d " % proto
+ pkt += ", nh=%d" % proto
+ if 'tc' in flows:
+ tc = self.generate_random_int(0, 255)
+ flow_str += "tc is %d " % tc
+ pkt += ", tc=%d" % tc
+ extrapacket['tos'] = str(tc)
+ if 'hop' in flows:
+ hop = self.generate_random_int(0, 255)
+ flow_str += "hop is %d " % hop
+ pkt += ", hlim=%d" % hop
+ extrapacket['ttl'] = str(hop)
+ if 'sctp' in flows:
+ pkt += ", nh=132"
+ extrapacket['proto'] = '132'
+ pkt += ")"
+ elif flow_type == "tcp":
+ flow_str += "/ tcp "
+ pkt += "/TCP("
+ dport = self.generate_random_int(0, MAX_PORT)
+ sport = self.generate_random_int(0, MAX_PORT)
+ if 'dport' in flows:
+ flow_str += "dst is %s " % dport
+ extrapacket['dport'] = dport
+ pkt += "dport=%s" % dport
+ if 'sport' in flows:
+ flow_str += "src is %s " % sport
+ extrapacket['sport'] = sport
+ pkt += ", sport=%s" % sport
+ pkt += ")"
+ elif flow_type == "udp":
+ flow_str += "/ udp "
+ pkt += "/UDP("
+ dport = self.generate_random_int(0, MAX_PORT)
+ sport = self.generate_random_int(0, MAX_PORT)
+ if 'dport' in flows:
+ flow_str += "dst is %s " % dport
+ extrapacket['dport'] = dport
+ pkt += "dport=%s" % dport
+ if 'sport' in flows:
+ flow_str += "src is %s " % sport
+ extrapacket['sport'] = sport
+ pkt += ", sport=%s" % sport
+ pkt += ")"
+ elif flow_type == "sctp":
+ flow_str += "/ sctp "
+ pkt += "/SCTP("
+ dport = self.generate_random_int(0, MAX_PORT)
+ sport = self.generate_random_int(0, MAX_PORT)
+ if 'dport' in flows:
+ flow_str += "dst is %s " % dport
+ extrapacket['dport'] = dport
+ pkt += "dport=%s" % dport
+ if 'sport' in flows:
+ flow_str += "src is %s " % sport
+ extrapacket['sport'] = sport
+ pkt += ", sport=%s" % sport
+ if 'tag' in flows:
+ flow_str += "tag is 1 "
+ pkt += ", tag=1"
+ pkt += ")"
+ elif flow_type == "vxlan":
+ flow_str += "/ vxlan "
+ if 'vni' in flows:
+ vni = self.generate_random_int(0, MAX_VLAN)
+ flow_str += "vni is %d " % vni
+ pkt += "/Vxlan(vni=%d)" % vni
+ extrapacket['vni'] = str(vni)
+ else:
+ pkt += "/Vxlan()"
+ elif flow_type == "nvgre":
+ flow_str += "/ nvgre "
+ if 'tni' in flows:
+ vni = self.generate_random_int(0, MAX_VLAN)
+ flow_str += "tni is %d " % vni
+ pkt += "/NVGRE(TNI=%d)" % vni
+ extrapacket['tni'] = str(vni)
+ else:
+ pkt += "/NVGRE()"
+ elif flow_type == "ineth":
+ inmac = self.inner_mac
+ flow_str += "/ eth dst is %s " % inmac
+ pkt += "/Ether(dst='%s')" % inmac
+ extrapacket['ineth'] = inmac
+ elif flow_type == "invlan":
+ invlan = self.generate_random_int(0, MAX_VLAN)
+ flow_str += "/ vlan tci is %d " % invlan
+ pkt += "/Dot1Q(vlan=%d)" % invlan
+ extrapacket['invlan'] = str(invlan)
+ elif flow_type == "vf0":
+ flow_str += "/ vf id is 0"
+ elif flow_type == "vf1":
+ flow_str += "/ vf id is 1"
+ pkt += "/Raw('x' * 20)"
+ # Define the action string of the rule.
+ act_str = ""
+ index = 0
+ for action in actions:
+ if action == "pf":
+ act_str += "pf / "
+ elif action == "vf0":
+ act_str += "vf id 0 / "
+ elif action == "vf1":
+ act_str += "vf id 1 / "
+ elif action == "queue":
+ if ("vf0" in flows) or ("vf1" in flows) or ("vf0" in actions) or ("vf1" in actions):
+ index = self.generate_random_int(0, MAX_VFQUEUE)
+ else:
+ index = self.generate_random_int(0, MAX_QUEUE)
+ act_str += "queue index %d / " % index
+ elif action == "invalid":
+ if ("vf0" in flows) or ("vf1" in flows):
+ index = MAX_VFQUEUE + 1
+ else:
+ index = MAX_QUEUE + 1
+ act_str += "queue index %d / " % index
+ elif action == "drop":
+ act_str += "drop / "
+ index = "NULL"
+ elif action == "passthru":
+ act_str += "passthru / "
+ index = 0
+ elif action == "flag":
+ act_str += "flag / "
+ elif action == "mark":
+ act_str += "mark id 3 / "
+ # Configure the whole flow rule.
+ command = cmd_fmt % { "create": create,
+ "flow": flow_str,
+ "action": act_str}
+ # Configure the return value.
+ flow_process = {'cmd': command, 'pkt': pkt, 'queue': index, 'extrapacket': extrapacket}
+
+ return flow_process
+
+ def test_syn_filter(self):
+ """
+ Only supported by ixgbe and igb.
+ """
+ self.verify(self.nic in ["niantic", "kawela_4", "kawela", "bartonhills", "twinville", "sagepond", "sageville",
+ "powerville"], "%s nic not support SYN filter" % self.nic)
+
+ self.pmdout.start_testpmd("%s" % self.cores, "--disable-rss --rxq=%d --txq=%d" % (MAX_QUEUE+1, MAX_QUEUE+1))
+ self.dut.send_expect("set fwd rxonly", "testpmd> ", 120)
+ self.dut.send_expect("set verbose 1", "testpmd> ", 120)
+ self.dut.send_expect("start", "testpmd> ", 120)
+ time.sleep(2)
+
+ # create the flow rules
+ self.dut.send_expect(
+ "flow create 0 ingress pattern eth / ipv4 / tcp flags spec 0x02 flags mask 0x02 / end actions queue index 3 / end", "created")
+ # send the packets and verify the results
+ self.tester.scapy_append(
+ 'sendp([Ether(dst="%s")/IP(src="192.168.0.1", dst="192.168.0.2")/TCP(dport=80,flags="S")/Raw("x" * 20)], iface="%s")' % (self.pf_mac, self.tester_itf))
+ self.verify_result("pf", expect_rxpkts="1", expect_queue="3")
+
+ self.tester.scapy_append(
+ 'sendp([Ether(dst="%s")/IP(src="192.168.0.1", dst="192.168.0.2")/TCP(dport=80,flags="PA")/Raw("x" * 20)], iface="%s")' % (self.pf_mac, self.tester_itf))
+ self.verify_result("pf", expect_rxpkts="1", expect_queue="0")
+
+ # the ipv6 rule is conflicted with ipv4 rule.
+ self.dut.send_expect("flow destroy 0 rule 0", "testpmd> ", 120)
+
+ # create the flow rules
+ self.dut.send_expect(
+ "flow create 0 ingress pattern eth / ipv6 / tcp flags spec 0x02 flags mask 0x02 / end actions queue index 4 / end", "created")
+ # send the packets and verify the results
+ self.tester.scapy_append(
+ 'sendp([Ether(dst="%s")/IPv6(src="2001::1", dst="2001::2")/TCP(dport=80,flags="S")/Raw("x" * 20)], iface="%s")' % (self.pf_mac, self.tester_itf))
+ self.verify_result("pf", expect_rxpkts="1", expect_queue="4")
+
+ self.tester.scapy_append(
+ 'sendp([Ether(dst="%s")/IPv6(src="2001::1", dst="2001::2")/TCP(dport=80,flags="PA")/Raw("x" * 20)], iface="%s")' % (self.pf_mac, self.tester_itf))
+ self.verify_result("pf", expect_rxpkts="1", expect_queue="0")
+
+ self.verify_rulenum(1)
+
+ def test_n_tuple_filter(self):
+ """
+ only supported by ixgbe and igb
+ """
+ self.verify(self.nic in ["niantic", "kawela_4", "kawela",
+ "twinville"], "%s nic not support n-tuple filter" % self.nic)
+
+ self.pmdout.start_testpmd("%s" % self.cores, "--disable-rss --rxq=%d --txq=%d" % (MAX_QUEUE+1, MAX_QUEUE+1))
+ self.dut.send_expect("set fwd rxonly", "testpmd> ", 120)
+ self.dut.send_expect("set verbose 1", "testpmd> ", 120)
+ self.dut.send_expect("start", "testpmd> ", 120)
+ time.sleep(2)
+ # create the flow rules
+ basic_flow_actions = [
+ {'create': 'create', 'flows': ['ipv4', 'sip', 'dip'], 'actions': ['queue']},
+ {'create': 'create', 'flows': ['ipv4', 'sip', 'dip', 'proto', 'udp', 'sport', 'dport'], 'actions': ['queue']},
+ {'create': 'create', 'flows': ['ipv4', 'sip', 'dip', 'proto', 'tcp', 'sport', 'dport'], 'actions': ['queue']},
+ {'create': 'create', 'flows': ['ipv4', 'sip', 'dip', 'proto', 'sctp', 'sport', 'dport'], 'actions': ['queue']}
+ ]
+ extrapkt_rulenum = self.all_flows_process(basic_flow_actions)
+ extra_packet = extrapkt_rulenum['extrapacket']
+ # send the packets inconsistent to the rules.
+ self.tester.scapy_append(
+ 'sendp([Ether(dst="%s")/IP(src="%s", dst="%s")/Raw("x" * 20)], iface="%s")' % (self.pf_mac, extra_packet[0]['dip'], extra_packet[0]['sip'], self.tester_itf))
+ self.verify_result("pf", expect_rxpkts="1", expect_queue="0")
+ self.tester.scapy_append(
+ 'sendp([Ether(dst="%s")/IP(src="%s", dst="%s")/SCTP(sport=%s,dport=%s)/Raw("x" * 20)], iface="%s")' % (self.pf_mac, extra_packet[3]['dip'], extra_packet[3]['sip'], extra_packet[3]['sport'], extra_packet[3]['dport'], self.tester_itf))
+ self.verify_result("pf", expect_rxpkts="1", expect_queue="0")
+ self.tester.scapy_append(
+ 'sendp([Ether(dst="%s")/IP(src="%s", dst="%s")/SCTP(sport=%s,dport=%s)/Raw("x" * 20)], iface="%s")' % (self.pf_mac, extra_packet[0]['sip'], extra_packet[0]['dip'], extra_packet[3]['sport'], extra_packet[3]['dport'], self.tester_itf))
+ self.verify_result("pf", expect_rxpkts="1", expect_queue=extrapkt_rulenum['queue'][0])
+
+ rule_num = extrapkt_rulenum['rulenum']
+ self.verify_rulenum(rule_num)
+
+ def test_2_tuple_filter(self):
+ """
+ only supported by igb
+ """
+ self.verify(self.nic in ["bartonhills", "powerville"], "%s nic not support 2-tuple filter" % self.nic)
+
+ self.pmdout.start_testpmd("%s" % self.cores, "--disable-rss --rxq=%d --txq=%d" % (MAX_QUEUE+1, MAX_QUEUE+1))
+ self.dut.send_expect("set fwd rxonly", "testpmd> ", 120)
+ self.dut.send_expect("set verbose 1", "testpmd> ", 120)
+ self.dut.send_expect("start", "testpmd> ", 120)
+ time.sleep(2)
+
+ # i350 and 82580 only support 2-tuple, and don't support SCTP
+ # create the flow rules
+ basic_flow_actions = [
+ {'create': 'create', 'flows': ['ipv4', 'proto', 'udp', 'dport'], 'actions': ['queue']},
+ {'create': 'create', 'flows': ['ipv4', 'proto', 'tcp', 'dport'], 'actions': ['queue']},
+ ]
+ extrapkt_rulenum = self.all_flows_process(basic_flow_actions)
+ extra_packet = extrapkt_rulenum['extrapacket']
+ # send the packets inconsistent to the rules.
+ self.tester.scapy_append(
+ 'sendp([Ether(dst="%s")/IP(src="192.168.0.1", dst="192.168.0.2")/UDP(sport=22,dport=24)/Raw("x" * 20)], iface="%s")' % (self.pf_mac, self.tester_itf))
+ self.verify_result("pf", expect_rxpkts="1", expect_queue="0")
+ self.tester.scapy_append(
+ 'sendp([Ether(dst="%s")/IP(src="192.168.0.1", dst="192.168.0.2")/TCP(sport=32,dport=34)/Raw("x" * 20)], iface="%s")' % (self.pf_mac, self.tester_itf))
+ self.verify_result("pf", expect_rxpkts="1", expect_queue="0")
+ rule_num = extrapkt_rulenum['rulenum']
+ self.verify_rulenum(rule_num)
+
+ def test_ethertype_filter(self):
+ """
+ supported by i40e, ixgbe and igb
+ """
+ self.verify(self.nic in ["niantic", "kawela_4", "kawela", "bartonhills", "twinville", "sagepond", "sageville",
+ "powerville", "fortville_eagle", "fortville_spirit",
+ "fortville_spirit_single", "fortpark_TLV"], "%s nic not support ethertype filter" % self.nic)
+
+ self.pmdout.start_testpmd("%s" % self.cores, "--disable-rss --rxq=%d --txq=%d" % (MAX_QUEUE+1, MAX_QUEUE+1), "-w %s --file-prefix=test1" % self.pf_pci)
+ self.dut.send_expect("set fwd rxonly", "testpmd> ", 120)
+ self.dut.send_expect("set verbose 1", "testpmd> ", 120)
+ self.dut.send_expect("start", "testpmd> ", 120)
+ time.sleep(2)
+
+ # i40e,ixgbe and igb support different packet types.
+ if (self.nic in ["fortville_eagle", "fortville_spirit",
+ "fortville_spirit_single", "fortpark_TLV"]):
+
+ basic_flow_actions = [
+ {'create': 'validate', 'flows': ['ether', 'arp'], 'actions': ['queue']},
+ {'create': 'validate', 'flows': ['ether', 'arp'], 'actions': ['invalid']},
+ {'create': 'validate', 'flows': ['ether', 'lldp'], 'actions': ['queue']},
+ {'create': 'validate', 'flows': ['ether', 'ipv6_eth'], 'actions': ['queue']},
+ {'create': 'validate', 'flows': ['ether', 'ip_eth'], 'actions': ['queue']},
+ {'create': 'validate', 'flows': ['ether', 'eaps'], 'actions': ['queue']},
+ {'create': 'create', 'flows': ['ether', 'arp'], 'actions': ['invalid']},
+ {'create': 'create', 'flows': ['ether', 'arp'], 'actions': ['queue']},
+ {'create': 'create', 'flows': ['ether', 'lwapp'], 'actions': ['queue']},
+ {'create': 'create', 'flows': ['ether', 'ppp'], 'actions': ['drop']},
+ {'create': 'create', 'flows': ['dst_mac', 'ether', 'mpls'], 'actions': ['queue']},
+ ]
+ extrapkt_rulenum = self.all_flows_process(basic_flow_actions)
+ rule_num = extrapkt_rulenum['rulenum']
+ self.verify_rulenum(rule_num)
+
+ else:
+ # create the flow rules
+ basic_flow_actions = [
+ {'create': 'validate', 'flows': ['ether', 'arp'], 'actions': ['queue']},
+ {'create': 'validate', 'flows': ['ether', 'lldp'], 'actions': ['invalid']},
+ {'create': 'validate', 'flows': ['ether', 'ipv6_eth'], 'actions': ['queue']},
+ {'create': 'create', 'flows': ['ether', 'lldp'], 'actions': ['invalid']},
+ {'create': 'create', 'flows': ['ether', 'arp'], 'actions': ['queue']},
+ {'create': 'create', 'flows': ['ether', 'lldp'], 'actions': ['queue']},
+ ]
+ extrapkt_rulenum = self.all_flows_process(basic_flow_actions)
+ self.tester.scapy_append(
+ 'sendp([Ether(dst="%s",type=0x88E5)/Raw("x" * 20)], iface="%s")' % (self.pf_mac, self.tester_itf))
+ self.verify_result("pf", expect_rxpkts="1", expect_queue="0")
+ rule_num = extrapkt_rulenum['rulenum']
+ self.verify_rulenum(rule_num)
+
+ def test_L2_tunnel_filter(self):
+ """
+ only supported by ixgbe
+ """
+ self.verify(self.nic in ["sagepond", "sageville"], "%s nic not support fdir L2 payload filter" % self.nic)
+
+ self.setup_env()
+ # start testpmd on pf
+ self.pmdout.start_testpmd("1S/4C/1T", "--rxq=4 --txq=4", "-w %s --file-prefix=pf -m 1024" % self.pf_pci)
+ self.dut.send_expect("set fwd rxonly", "testpmd> ", 120)
+ self.dut.send_expect("set verbose 1", "testpmd> ", 120)
+ self.dut.send_expect("start", "testpmd> ", 120)
+ time.sleep(2)
+ # start testpmd on vf0
+ self.session_secondary.send_expect("./%s/app/testpmd -c 0x1e0 -n 4 -m 1024 -w %s --file-prefix=vf1 -- -i --rxq=4 --txq=4" % (self.target, self.sriov_vfs_port[0].pci), "testpmd>", 120)
+ self.session_secondary.send_expect("set fwd rxonly", "testpmd> ")
+ self.session_secondary.send_expect("set verbose 1", "testpmd> ")
+ self.session_secondary.send_expect("start", "testpmd> ")
+ time.sleep(2)
+ # start testpmd on vf1
+ self.session_third.send_expect("./%s/app/testpmd -c 0x1e00 -n 4 -m 1024 -w %s --file-prefix=vf2 -- -i --rxq=4 --txq=4" % (self.target, self.sriov_vfs_port[1].pci), "testpmd>", 120)
+ self.session_third.send_expect("set fwd rxonly", "testpmd> ")
+ self.session_third.send_expect("set verbose 1", "testpmd> ")
+ self.session_third.send_expect("start", "testpmd> ")
+ time.sleep(2)
+
+ # Enabling ability of parsing E-tag packet
+ self.dut.send_expect("port config 0 l2-tunnel E-tag enable", "testpmd> ")
+ # Enable E-tag packet forwarding, set on pf
+ self.dut.send_expect("E-tag set forwarding on port 0", "testpmd> ")
+
+ # create the flow rules
+ basic_flow_actions = [
+ {'create': 'create', 'flows': ['etag'], 'actions': ['vf0']},
+ {'create': 'create', 'flows': ['etag'], 'actions': ['vf1']},
+ {'create': 'create', 'flows': ['etag'], 'actions': ['pf']},
+ ]
+ extrapkt_rulenum = self.all_flows_process(basic_flow_actions)
+ extra_packet = extrapkt_rulenum['extrapacket']
+ self.tester.scapy_append(
+ 'sendp([Ether(dst="%s")/Dot1BR(GRP=0x2, ECIDbase=%s)/Raw("x" * 20)], iface="%s")' % (self.pf_mac, extra_packet[0]['etag'], self.tester_itf))
+ self.verify_result("pf", expect_rxpkts="0", expect_queue="NULL")
+ rule_num = extrapkt_rulenum['rulenum']
+ self.verify_rulenum(rule_num)
+
+ def test_fdir_for_L2_payload(self):
+ """
+ only supported by i40e
+ """
+ self.verify(self.nic in ["fortville_eagle", "fortville_spirit",
+ "fortville_spirit_single", "fortpark_TLV"], "%s nic not support fdir L2 payload filter" % self.nic)
+
+ self.pmdout.start_testpmd("%s" % self.pf_cores, "--pkt-filter-mode=perfect --rxq=%d --txq=%d" % (MAX_QUEUE+1, MAX_QUEUE+1), "-w %s --file-prefix=test1" % self.pf_pci)
+ self.dut.send_expect("set fwd rxonly", "testpmd> ", 120)
+ self.dut.send_expect("set verbose 1", "testpmd> ", 120)
+ self.dut.send_expect("start", "testpmd> ", 120)
+ time.sleep(2)
+
+ basic_flow_actions = [
+ {'create': 'create', 'flows': ['vlan'], 'actions': ['queue']},
+ {'create': 'create', 'flows': ['ether', 'ppp'], 'actions': ['queue']},
+ ]
+ extrapkt_rulenum = self.all_flows_process(basic_flow_actions)
+ rule_num = extrapkt_rulenum['rulenum']
+ self.verify_rulenum(rule_num)
+
+ def test_fdir_for_vlan(self):
+ """
+ only supported by i40e
+ """
+ self.verify(self.nic in ["fortville_eagle", "fortville_spirit",
+ "fortville_spirit_single", "fortpark_TLV"], "%s nic not support fdir L2 payload filter" % self.nic)
+ self.setup_env()
+ # start testpmd on pf
+ self.pmdout.start_testpmd("%s" % self.pf_cores, "--pkt-filter-mode=perfect --disable-rss --rxq=%d --txq=%d" % (MAX_QUEUE+1, MAX_QUEUE+1), "-w %s --file-prefix=pf --socket-mem 1024,1024" % self.pf_pci)
+ self.dut.send_expect("set fwd rxonly", "testpmd> ", 120)
+ self.dut.send_expect("set verbose 1", "testpmd> ", 120)
+ self.dut.send_expect("start", "testpmd> ", 120)
+ time.sleep(2)
+ # start testpmd on vf0
+ self.session_secondary.send_expect("./%s/app/testpmd -c 0x1e0000 -n 4 --socket-mem 1024,1024 -w %s --file-prefix=vf1 -- -i --rxq=4 --txq=4 --disable-rss --pkt-filter-mode=perfect" % (self.target, self.sriov_vfs_port[0].pci), "testpmd>", 120)
+ self.session_secondary.send_expect("set fwd rxonly", "testpmd>")
+ self.session_secondary.send_expect("set verbose 1", "testpmd>")
+ self.session_secondary.send_expect("start", "testpmd>")
+ time.sleep(2)
+ # start testpmd on vf1
+ self.session_third.send_expect("./%s/app/testpmd -c 0x1e000000 -n 4 --socket-mem 1024,1024 -w %s --file-prefix=vf2 -- -i --rxq=4 --txq=4 --disable-rss --pkt-filter-mode=perfect" % (self.target, self.sriov_vfs_port[1].pci), "testpmd>", 120)
+ self.session_third.send_expect("set fwd rxonly", "testpmd>")
+ self.session_third.send_expect("set verbose 1", "testpmd>")
+ self.session_third.send_expect("start", "testpmd>")
+ time.sleep(2)
+ # create the flow rules
+ basic_flow_actions = [
+ {'create': 'create', 'flows': ['vlan', 'ipv4'], 'actions': ['queue']},
+ {'create': 'create', 'flows': ['vlan', 'ipv4', 'udp'], 'actions': ['queue']},
+ {'create': 'create', 'flows': ['vlan', 'ipv4', 'tcp'], 'actions': ['queue']},
+ {'create': 'create', 'flows': ['vlan', 'ipv4', 'sctp'], 'actions': ['queue']},
+ {'create': 'create', 'flows': ['vlan', 'ipv4', 'vf0'], 'actions': ['queue']},
+ {'create': 'create', 'flows': ['vlan', 'ipv4', 'sctp', 'vf1'], 'actions': ['queue']},
+ {'create': 'create', 'flows': ['vlan', 'ipv4', 'sctp'], 'actions': ['drop']},
+ {'create': 'create', 'flows': ['vlan', 'ipv4', 'udp', 'vf1'], 'actions': ['drop']},
+ {'create': 'create', 'flows': ['vlan', 'ipv6'], 'actions': ['queue']},
+ {'create': 'create', 'flows': ['vlan', 'ipv6', 'udp'], 'actions': ['queue']},
+ {'create': 'create', 'flows': ['vlan', 'ipv6', 'tcp'], 'actions': ['queue']},
+ {'create': 'create', 'flows': ['vlan', 'ipv6', 'sctp'], 'actions': ['queue']},
+ {'create': 'create', 'flows': ['vlan', 'ipv6', 'vf0'], 'actions': ['queue']},
+ {'create': 'create', 'flows': ['vlan', 'ipv6', 'tcp', 'vf1'], 'actions': ['queue']},
+ {'create': 'create', 'flows': ['vlan', 'ipv6', 'sctp'], 'actions': ['drop']},
+ {'create': 'create', 'flows': ['vlan', 'ipv6', 'tcp', 'vf1'], 'actions': ['drop']}
+ ]
+ extrapkt_rulenum = self.all_flows_process(basic_flow_actions)
+ extra_packet = extrapkt_rulenum['extrapacket']
+ # send the packets with dst/src ip and dst/src port.
+ self.tester.scapy_append(
+ 'sendp([Ether(dst="%s")/Dot1Q(vlan=%s)/IP(src="192.168.0.1", dst="192.168.0.2", proto=3)/Raw("x" * 20)], iface="%s")' % (self.pf_mac, extra_packet[0]['vlan'], self.tester_itf))
+ self.verify_result("pf", expect_rxpkts="1", expect_queue=extrapkt_rulenum['queue'][0])
+ self.tester.scapy_append(
+ 'sendp([Ether(dst="%s")/Dot1Q(vlan=%s)/IP(src="192.168.0.1", dst="192.168.0.2", tos=3)/UDP()/Raw("x" * 20)], iface="%s")' % (self.pf_mac, extra_packet[1]['vlan'], self.tester_itf))
+ self.verify_result("pf", expect_rxpkts="1", expect_queue=extrapkt_rulenum['queue'][1])
+ self.tester.scapy_append(
+ 'sendp([Ether(dst="%s")/Dot1Q(vlan=%s)/IP(src="192.168.0.1", dst="192.168.0.2", ttl=3)/TCP()/Raw("x" * 20)], iface="%s")' % (self.pf_mac, extra_packet[2]['vlan'], self.tester_itf))
+ self.verify_result("pf", expect_rxpkts="1", expect_queue=extrapkt_rulenum['queue'][2])
+ self.tester.scapy_append(
+ 'sendp([Ether(dst="%s")/Dot1Q(vlan=%s)/IP(src="192.168.0.1", dst="192.168.0.2", tos=3, ttl=3)/SCTP()/Raw("x" * 20)], iface="%s")' % (self.pf_mac, extra_packet[3]['vlan'], self.tester_itf))
+ self.verify_result("pf", expect_rxpkts="1", expect_queue=extrapkt_rulenum['queue'][3])
+ self.tester.scapy_append(
+ 'sendp([Ether(dst="%s")/Dot1Q(vlan=%s)/IP(src="192.168.0.1", dst="192.168.0.2", ttl=3)/TCP()/Raw("x" * 20)], iface="%s")' % (self.pf_mac, extra_packet[3]['vlan'], self.tester_itf))
+ self.verify_result("pf", expect_rxpkts="1", expect_queue="0")
+ self.tester.scapy_append(
+ 'sendp([Ether(dst="%s")/Dot1Q(vlan=%s)/IP()/UDP()/Raw("x" * 20)], iface="%s")' % (self.pf_mac, extra_packet[2]['vlan'], self.tester_itf))
+ self.verify_result("pf", expect_rxpkts="1", expect_queue="0")
+ self.tester.scapy_append(
+ 'sendp([Ether(dst="%s")/Dot1Q(vlan=%s)/IP(src="192.168.0.5", dst="192.168.0.6", tos=3, ttl=3)/SCTP(sport=44,dport=45,tag=1)/Raw("x" * 20)], iface="%s")' % (self.pf_mac, extra_packet[6]['vlan'], self.tester_itf))
+ self.verify_result("pf", expect_rxpkts="0", expect_queue="NULL")
+ self.tester.scapy_append(
+ 'sendp([Ether(dst="%s")/Dot1Q(vlan=%s)/IP(src="192.168.0.5", dst="192.168.0.6", tos=3, ttl=3)/UDP(sport=44,dport=45)/SCTPChunkData(data="X" * 20)], iface="%s")' % (self.outer_mac, extra_packet[7]['vlan'], self.tester_itf))
+ self.verify_result("vf1", expect_rxpkts="0", expect_queue="NULL")
+ self.tester.scapy_append(
+ 'sendp([Ether(dst="%s")/Dot1Q(vlan=%s)/IPv6(src="2001::1", dst="2001::2", tc=1, nh=5, hlim=10)/Raw("x" * 20)], iface="%s")' % (self.pf_mac, extra_packet[8]['vlan'], self.tester_itf))
+ self.verify_result("pf", expect_rxpkts="1", expect_queue=extrapkt_rulenum['queue'][8])
+ self.tester.scapy_append(
+ 'sendp([Ether(dst="%s")/Dot1Q(vlan=%s)/IPv6(src="2001::1", dst="2001::2", tc=2, hlim=20)/UDP(sport=22,dport=23)/Raw("x" * 20)], iface="%s")' % (self.pf_mac, extra_packet[9]['vlan'], self.tester_itf))
+ self.verify_result("pf", expect_rxpkts="1", expect_queue=extrapkt_rulenum['queue'][9])
+ self.tester.scapy_append(
+ 'sendp([Ether(dst="%s")/Dot1Q(vlan=%s)/IPv6(src="2001::1", dst="2001::2", tc=2, hlim=20)/TCP(sport=32,dport=33)/Raw("x" * 20)], iface="%s")' % (self.pf_mac, extra_packet[10]['vlan'], self.tester_itf))
+ self.verify_result("pf", expect_rxpkts="1", expect_queue=extrapkt_rulenum['queue'][10])
+ self.tester.scapy_append(
+ 'sendp([Ether(dst="%s")/Dot1Q(vlan=%s)/IPv6(src="2001::1", dst="2001::2", tc=4, nh=132, hlim=40)/SCTP(sport=44,dport=45,tag=1)/SCTPChunkData(data="X" * 20)], iface="%s")' % (self.pf_mac, extra_packet[11]['vlan'], self.tester_itf))
+ self.verify_result("pf", expect_rxpkts="1", expect_queue=extrapkt_rulenum['queue'][11])
+ self.tester.scapy_append(
+ 'sendp([Ether(dst="%s")/Dot1Q(vlan=%s)/IPv6(src="2001::1", dst="2001::2", tc=4, nh=132, hlim=40)/SCTP(sport=44,dport=45,tag=1)/SCTPChunkData(data="X" * 20)], iface="%s")' % (self.pf_mac, extra_packet[14]['vlan'], self.tester_itf))
+ self.verify_result("pf", expect_rxpkts="0", expect_queue="NULL")
+ self.tester.scapy_append(
+ 'sendp([Ether(dst="%s")/Dot1Q(vlan=%s)/IPv6(src="2001::1", dst="2001::2", tc=2, hlim=20)/TCP(sport=32,dport=33)/Raw("x" * 20)], iface="%s")' % (self.outer_mac, extra_packet[15]['vlan'], self.tester_itf))
+ self.verify_result("vf1", expect_rxpkts="0", expect_queue="NULL")
+
+ rule_num = extrapkt_rulenum['rulenum']
+ self.verify_rulenum(rule_num)
+
+ def test_fdir_for_ipv4(self):
+ """
+ only supported by i40e and ixgbe
+ """
+ self.verify(self.nic in ["niantic", "twinville", "sagepond", "sageville",
+ "fortville_eagle", "fortville_spirit",
+ "fortville_spirit_single", "fortpark_TLV"], "%s nic not support fdir ipv4 filter" % self.nic)
+ # i40e
+ if (self.nic in ["fortville_eagle", "fortville_spirit",
+ "fortville_spirit_single", "fortpark_TLV"]):
+ self.setup_env()
+ # start testpmd on pf
+ self.pmdout.start_testpmd("%s" % self.pf_cores, "--pkt-filter-mode=perfect --disable-rss --rxq=%d --txq=%d" % (MAX_QUEUE+1, MAX_QUEUE+1), "-w %s --file-prefix=pf --socket-mem 1024,1024" % self.pf_pci)
+ self.dut.send_expect("set fwd rxonly", "testpmd> ", 120)
+ self.dut.send_expect("set verbose 1", "testpmd> ", 120)
+ self.dut.send_expect("start", "testpmd> ", 120)
+ time.sleep(2)
+ # start testpmd on vf0
+ self.session_secondary.send_expect("./%s/app/testpmd -c 0x1e0000 -n 4 --socket-mem 1024,1024 -w %s --file-prefix=vf1 -- -i --rxq=4 --txq=4 --disable-rss --pkt-filter-mode=perfect" % (self.target, self.sriov_vfs_port[0].pci), "testpmd>", 120)
+ self.session_secondary.send_expect("set fwd rxonly", "testpmd>")
+ self.session_secondary.send_expect("set verbose 1", "testpmd>")
+ self.session_secondary.send_expect("start", "testpmd>")
+ time.sleep(2)
+ # start testpmd on vf1
+ self.session_third.send_expect("./%s/app/testpmd -c 0x1e000000 -n 4 --socket-mem 1024,1024 -w %s --file-prefix=vf2 -- -i --rxq=4 --txq=4 --disable-rss --pkt-filter-mode=perfect" % (self.target, self.sriov_vfs_port[1].pci), "testpmd>", 120)
+ self.session_third.send_expect("set fwd rxonly", "testpmd>")
+ self.session_third.send_expect("set verbose 1", "testpmd>")
+ self.session_third.send_expect("start", "testpmd>")
+ time.sleep(2)
+
+ # create the flow rules
+ basic_flow_actions = [
+ {'create': 'create', 'flows': ['ipv4', 'sip', 'dip', 'proto'], 'actions': ['queue']},
+ {'create': 'create', 'flows': ['ipv4', 'sip', 'dip', 'ttl', 'udp', 'sport', 'dport'], 'actions': ['queue']},
+ {'create': 'create', 'flows': ['ipv4', 'sip', 'dip', 'tos', 'tcp', 'sport', 'dport'], 'actions': ['queue']},
+ {'create': 'create', 'flows': ['vlan', 'ipv4', 'sip', 'dip', 'tos', 'ttl', 'sctp', 'sport', 'dport', 'tag'], 'actions': ['queue']},
+ {'create': 'create', 'flows': ['vlan', 'ipv4', 'sip', 'dip', 'tos', 'ttl', 'sctp', 'sport', 'dport', 'tag'], 'actions': ['drop']},
+ {'create': 'create', 'flows': ['ipv4', 'sip', 'dip', 'proto', 'vf0'], 'actions': ['invalid']},
+ {'create': 'create', 'flows': ['ipv4', 'sip', 'dip', 'proto', 'vf0'], 'actions': ['queue']},
+ {'create': 'create', 'flows': ['vlan', 'ipv4', 'sip', 'dip', 'tos', 'ttl', 'sctp', 'sport', 'dport', 'tag', 'vf1'], 'actions': ['queue']},
+ {'create': 'create', 'flows': ['vlan', 'ipv4', 'sip', 'dip', 'tos', 'ttl', 'sctp', 'sport', 'dport', 'tag'], 'actions': ['passthru', 'flag']},
+ {'create': 'create', 'flows': ['ipv4', 'sip', 'dip', 'ttl', 'udp', 'sport', 'dport'], 'actions': ['queue', 'flag']},
+ {'create': 'create', 'flows': ['ipv4', 'sip', 'dip', 'tos', 'tcp', 'sport', 'dport'], 'actions': ['queue', 'mark']},
+ {'create': 'create', 'flows': ['ipv4', 'sip', 'dip', 'proto'], 'actions': ['passthru', 'mark']}
+ ]
+ extrapkt_rulenum = self.all_flows_process(basic_flow_actions)
+ extra_packet = extrapkt_rulenum['extrapacket']
+ self.tester.scapy_append(
+ 'sendp([Ether(dst="%s")/IP(src="192.168.0.3", dst="192.168.0.4", proto=%s)/Raw("x" * 20)], iface="%s")' % (self.pf_mac, extra_packet[0]['proto'], self.tester_itf))
+ self.verify_result("pf", expect_rxpkts="1", expect_queue="0")
+ rule_num = extrapkt_rulenum['rulenum']
+ self.verify_rulenum(rule_num)
+
+ # ixgbe
+ else:
+ self.pmdout.start_testpmd("%s" % self.cores, "--pkt-filter-mode=perfect --disable-rss --rxq=%d --txq=%d" % (MAX_QUEUE+1, MAX_QUEUE+1))
+ self.dut.send_expect("set fwd rxonly", "testpmd> ", 120)
+ self.dut.send_expect("set verbose 1", "testpmd> ", 120)
+ self.dut.send_expect("start", "testpmd> ", 120)
+ time.sleep(2)
+
+ if (self.nic in ["sagepond", "sageville"]):
+ # create the flow rules
+ basic_flow_actions = [
+ {'create': 'create', 'flows': ['ipv4', 'sip', 'dip', 'udp', 'sport', 'dport'], 'actions': ['queue']},
+ {'create': 'create', 'flows': ['ipv4', 'sip', 'dip', 'tcp', 'sport', 'dport'], 'actions': ['queue']},
+ {'create': 'create', 'flows': ['ipv4', 'sip', 'dip', 'sctp', 'sport', 'dport'], 'actions': ['queue']},
+ {'create': 'create', 'flows': ['ipv4', 'sip', 'dip', 'sctp', 'sport', 'dport'], 'actions': ['drop']},
+ ]
+ extrapkt_rulenum = self.all_flows_process(basic_flow_actions)
+ extra_packet = extrapkt_rulenum['extrapacket']
+ self.tester.scapy_append(
+ 'sendp([Ether(dst="%s")/IP(src="%s", dst="%s")/SCTP(sport=%s,dport=%s)/Raw("x" * 20)], iface="%s")' % (self.pf_mac, extra_packet[2]['sip'], extra_packet[2]['dip'], extra_packet[2]['dport'], extra_packet[2]['sport'], self.tester_itf))
+ self.verify_result("pf", expect_rxpkts="1", expect_queue="0")
+ rule_num = extrapkt_rulenum['rulenum']
+ self.verify_rulenum(rule_num)
+ else:
+ basic_flow_actions = [
+ {'create': 'create', 'flows': ['ipv4', 'sip', 'dip', 'udp', 'sport', 'dport'], 'actions': ['queue']},
+ {'create': 'create', 'flows': ['ipv4', 'sip', 'dip', 'tcp', 'sport', 'dport'], 'actions': ['queue']},
+ {'create': 'create', 'flows': ['ipv4', 'sip', 'dip', 'sctp'], 'actions': ['queue']},
+ {'create': 'create', 'flows': ['ipv4', 'sip', 'dip', 'sctp'], 'actions': ['drop']},
+ ]
+ extrapkt_rulenum = self.all_flows_process(basic_flow_actions)
+ extra_packet = extrapkt_rulenum['extrapacket']
+ self.tester.scapy_append(
+ 'sendp([Ether(dst="%s")/IP(src="%s", dst="%s")/SCTP()/Raw("x" * 20)], iface="%s")' % (self.pf_mac, extra_packet[2]['dip'], extra_packet[2]['sip'], self.tester_itf))
+ self.verify_result("pf", expect_rxpkts="1", expect_queue="0")
+ rule_num = extrapkt_rulenum['rulenum']
+ self.verify_rulenum(rule_num)
+
+ def test_fdir_for_ipv6(self):
+ """
+ only supported by i40e and ixgbe
+ """
+ self.verify(self.nic in ["niantic", "twinville", "sagepond", "sageville",
+ "fortville_eagle", "fortville_spirit",
+ "fortville_spirit_single", "fortpark_TLV"], "%s nic not support fdir ipv6 filter" % self.nic)
+ # i40e
+ if (self.nic in ["fortville_eagle", "fortville_spirit",
+ "fortville_spirit_single", "fortpark_TLV"]):
+ self.setup_env()
+ self.pmdout.start_testpmd("%s" % self.pf_cores, "--pkt-filter-mode=perfect --disable-rss --rxq=%d --txq=%d" % (MAX_QUEUE+1, MAX_QUEUE+1), "-w %s --file-prefix=pf --socket-mem 1024,1024" % self.pf_pci)
+ self.dut.send_expect("set fwd rxonly", "testpmd> ", 120)
+ self.dut.send_expect("set verbose 1", "testpmd> ", 120)
+ self.dut.send_expect("start", "testpmd> ", 120)
+ time.sleep(2)
+ self.session_secondary.send_expect("./%s/app/testpmd -c 0x1e0000 -n 4 --socket-mem 1024,1024 -w %s --file-prefix=vf1 -- -i --rxq=4 --txq=4 --disable-rss --pkt-filter-mode=perfect" % (self.target, self.sriov_vfs_port[0].pci), "testpmd>", 120)
+ self.session_secondary.send_expect("set fwd rxonly", "testpmd>")
+ self.session_secondary.send_expect("set verbose 1", "testpmd>")
+ self.session_secondary.send_expect("start", "testpmd>")
+ time.sleep(2)
+ self.session_third.send_expect("./%s/app/testpmd -c 0x1e000000 -n 4 --socket-mem 1024,1024 -w %s --file-prefix=vf2 -- -i --rxq=4 --txq=4 --disable-rss --pkt-filter-mode=perfect" % (self.target, self.sriov_vfs_port[1].pci), "testpmd>", 120)
+ self.session_third.send_expect("set fwd rxonly", "testpmd>")
+ self.session_third.send_expect("set verbose 1", "testpmd>")
+ self.session_third.send_expect("start", "testpmd>")
+ time.sleep(2)
+
+ # create the flow rules
+ basic_flow_actions = [
+ {'create': 'create', 'flows': ['vlan', 'ipv6', 'sip', 'dip', 'proto', 'tc', 'hop'], 'actions': ['queue']},
+ {'create': 'create', 'flows': ['vlan', 'ipv6', 'sip', 'dip', 'tc', 'hop', 'udp', 'sport', 'dport'], 'actions': ['queue']},
+ {'create': 'create', 'flows': ['vlan', 'ipv6', 'sip', 'dip', 'tc', 'hop', 'tcp', 'sport', 'dport'], 'actions': ['queue']},
+ {'create': 'create', 'flows': ['vlan', 'ipv6', 'sip', 'dip', 'tc', 'hop', 'sctp', 'sport', 'dport', 'tag'], 'actions': ['queue']},
+ {'create': 'create', 'flows': ['vlan', 'ipv6', 'sip', 'dip', 'proto', 'tc', 'hop', 'vf0'], 'actions': ['queue']},
+ {'create': 'create', 'flows': ['vlan', 'ipv6', 'sip', 'dip', 'tc', 'hop', 'tcp', 'sport', 'dport', 'vf1'], 'actions': ['queue']},
+ {'create': 'create', 'flows': ['vlan', 'ipv6', 'sip', 'dip', 'tc', 'hop', 'sctp', 'sport', 'dport', 'tag'], 'actions': ['drop']},
+ {'create': 'create', 'flows': ['vlan', 'ipv6', 'sip', 'dip', 'tc', 'hop', 'tcp', 'sport', 'dport', 'vf1'], 'actions': ['drop']},
+ ]
+ extrapkt_rulenum = self.all_flows_process(basic_flow_actions)
+ extra_packet = extrapkt_rulenum['extrapacket']
+ self.tester.scapy_append(
+ 'sendp([Ether(dst="%s")/Dot1Q(vlan=%s)/IPv6(src="2001::1", dst="2001::2", tc=2, hlim=20)/UDP(sport=22,dport=23)/Raw("x" * 20)], iface="%s")' % (self.pf_mac, extra_packet[1]['vlan'], self.tester_itf))
+ self.verify_result("pf", expect_rxpkts="1", expect_queue="0")
+ rule_num = extrapkt_rulenum['rulenum']
+ self.verify_rulenum(rule_num)
+
+ # ixgbe signature
+ else:
+ self.pmdout.start_testpmd("%s" % self.cores, "--pkt-filter-mode=signature --disable-rss --rxq=%d --txq=%d" % (MAX_QUEUE+1, MAX_QUEUE+1))
+ self.dut.send_expect("set fwd rxonly", "testpmd> ", 120)
+ self.dut.send_expect("set verbose 1", "testpmd> ", 120)
+ self.dut.send_expect("start", "testpmd> ", 120)
+ time.sleep(2)
+ if (self.nic in ["niantic", "twinville"]):
+ # create the flow rules
+ basic_flow_actions = [
+ {'create': 'create', 'flows': ['fuzzy', 'ipv6', 'sip', 'dip'], 'actions': ['queue']},
+ {'create': 'create', 'flows': ['fuzzy', 'ipv4', 'sip', 'dip'], 'actions': ['queue']},
+ {'create': 'create', 'flows': ['fuzzy', 'ipv4', 'sip', 'dip', 'udp', 'sport', 'dport'], 'actions': ['queue']},
+ {'create': 'create', 'flows': ['fuzzy', 'ipv6', 'sip', 'dip', 'tcp', 'sport', 'dport'], 'actions': ['queue']},
+ {'create': 'create', 'flows': ['fuzzy', 'ipv4', 'sip', 'dip', 'tcp', 'sport', 'dport'], 'actions': ['queue']},
+ {'create': 'create', 'flows': ['fuzzy', 'ipv6', 'sip', 'dip', 'sctp'], 'actions': ['queue']},
+ {'create': 'create', 'flows': ['fuzzy', 'ipv4', 'sip', 'dip', 'sctp'], 'actions': ['queue']},
+ ]
+ extrapkt_rulenum = self.all_flows_process(basic_flow_actions)
+ self.dut.send_expect(
+ "flow create 0 ingress pattern fuzzy thresh spec 2 thresh last 5 thresh mask 0xffffffff / ipv6 src is 2001::1 dst is 2001::2 / udp src is 22 dst is 23 / end actions queue index 1 / end", "created")
+ extra_packet = extrapkt_rulenum['extrapacket']
+ self.tester.scapy_append(
+ 'sendp([Ether(dst="%s")/IPv6(src="2001::1", dst="2001::2",nh=132)/SCTP()/Raw("x" * 20)], iface="%s")' % (self.pf_mac, self.tester_itf))
+ self.verify_result("pf", expect_rxpkts="1", expect_queue="0")
+ self.tester.scapy_append(
+ 'sendp([Ether(dst="%s")/IP(src="192.168.0.1", dst="192.168.0.2")/SCTP()/Raw("x" * 20)], iface="%s")' % (self.pf_mac, self.tester_itf))
+ self.verify_result("pf", expect_rxpkts="1", expect_queue="0")
+ self.tester.scapy_append(
+ 'sendp([Ether(dst="%s")/IPv6(src="2001::1", dst="2001::2")/UDP(sport=22,dport=23)/Raw("x" * 20)], iface="%s")' % (self.pf_mac, self.tester_itf))
+ self.verify_result("pf", expect_rxpkts="1", expect_queue="1")
+ rule_num = extrapkt_rulenum['rulenum']
+ self.verify_rulenum(rule_num+1)
+ elif (self.nic in ["sagepond", "sageville"]):
+ # create the flow rules
+ basic_flow_actions = [
+ {'create': 'create', 'flows': ['fuzzy', 'ipv4', 'sip', 'dip', 'udp', 'sport', 'dport'], 'actions': ['queue']},
+ {'create': 'create', 'flows': ['fuzzy', 'ipv6', 'sip', 'dip', 'tcp', 'sport', 'dport'], 'actions': ['queue']},
+ {'create': 'create', 'flows': ['fuzzy', 'ipv4', 'sip', 'dip', 'tcp', 'sport', 'dport'], 'actions': ['queue']},
+ {'create': 'create', 'flows': ['fuzzy', 'ipv6', 'sip', 'dip', 'sctp', 'sport', 'dport'], 'actions': ['queue']},
+ {'create': 'create', 'flows': ['fuzzy', 'ipv4', 'sip', 'dip', 'sctp', 'sport', 'dport'], 'actions': ['queue']},
+ ]
+ extrapkt_rulenum = self.all_flows_process(basic_flow_actions)
+ self.dut.send_expect(
+ "flow create 0 ingress pattern fuzzy thresh spec 2 thresh last 5 thresh mask 0xffffffff / ipv6 src is 2001::1 dst is 2001::2 / udp src is 22 dst is 23 / end actions queue index 1 / end", "created")
+ extra_packet = extrapkt_rulenum['extrapacket']
+ self.tester.scapy_append(
+ 'sendp([Ether(dst="%s")/IPv6(src="%s", dst="%s", nh=132)/SCTP(sport=32,dport=33,tag=1)/Raw("x" * 20)], iface="%s")' % (self.pf_mac, extra_packet[3]['sip'], extra_packet[3]['dip'], self.tester_itf))
+ self.verify_result("pf", expect_rxpkts="1", expect_queue="0")
+ self.tester.scapy_append(
+ 'sendp([Ether(dst="%s")/IP(src="%s", dst="%s", proto=132)/SCTP(sport=32,dport=33)/Raw("x" * 20)], iface="%s")' % (self.pf_mac, extra_packet[4]['dip'], extra_packet[4]['sip'], self.tester_itf))
+ self.verify_result("pf", expect_rxpkts="1", expect_queue="0")
+ self.tester.scapy_append(
+ 'sendp([Ether(dst="%s")/IPv6(src="2001::1", dst="2001::2")/UDP(sport=22,dport=23)/Raw("x" * 20)], iface="%s")' % (self.pf_mac, self.tester_itf))
+ self.verify_result("pf", expect_rxpkts="1", expect_queue="1")
+ rule_num = extrapkt_rulenum['rulenum']
+ self.verify_rulenum(rule_num+1)
+
+ def test_fdir_for_flexbytes(self):
+ """
+ The filter structure is different between igb, ixgbe and i40e
+ """
+ self.verify(self.nic in ["niantic", "twinville", "sagepond", "sageville",
+ "fortville_eagle", "fortville_spirit",
+ "fortville_spirit_single", "fortpark_TLV"], "%s nic not support fdir flexbytes filter" % self.nic)
+ # i40e
+ if (self.nic in ["fortville_eagle", "fortville_spirit",
+ "fortville_spirit_single", "fortpark_TLV"]):
+
+ self.pmdout.start_testpmd("%s" % self.pf_cores, "--pkt-filter-mode=perfect --disable-rss --rxq=%d --txq=%d" % (MAX_QUEUE+1, MAX_QUEUE+1), "-w %s --file-prefix=pf --socket-mem 1024,1024" % self.pf_pci)
+ self.dut.send_expect("set fwd rxonly", "testpmd> ", 120)
+ self.dut.send_expect("set verbose 1", "testpmd> ", 120)
+ self.dut.send_expect("start", "testpmd> ", 120)
+ time.sleep(2)
+
+ # creat the flow rules
+ # l2-payload exceeds the max length of raw match is 16bytes
+ self.dut.send_expect(
+ "flow create 0 ingress pattern eth type is 0x0807 / raw relative is 1 pattern is abcdefghijklmnopq / end actions queue index 1 / end", "Exceeds maxmial payload limit")
+ # l2-payload equal the max length of raw match is 16bytes
+ self.dut.send_expect(
+ "flow create 0 ingress pattern eth type is 0x0807 / raw relative is 1 pattern is abcdefghijklmnop / end actions queue index 1 / end", "created")
+ # ipv4-other the most 3 fields can be matched, and the max sum bytes of the three fields is 16 bytes.
+ self.dut.send_expect(
+ "flow create 0 ingress pattern eth / vlan tci is 4095 / ipv4 proto is 255 ttl is 40 / raw relative is 1 offset is 2 pattern is ab / raw relative is 1 offset is 10 pattern is abcdefghij / raw relative is 1 offset is 0 pattern is abcd / end actions queue index 2 / end", "created")
+ # ipv4-udp
+ self.dut.send_expect(
+ "flow create 0 ingress pattern eth / ipv4 src is 2.2.2.4 dst is 2.2.2.5 / udp src is 22 dst is 23 / raw relative is 1 offset is 2 pattern is fhds / end actions queue index 3 / end", "created")
+ # ipv4-tcp
+ self.dut.send_expect(
+ "flow create 0 ingress pattern eth / ipv4 src is 2.2.2.4 dst is 2.2.2.5 tos is 4 ttl is 3 / tcp src is 32 dst is 33 / raw relative is 1 offset is 2 pattern is hijk / end actions queue index 4 / end", "created")
+ # ipv4-sctp
+ self.dut.send_expect(
+ "flow create 0 ingress pattern eth / ipv4 src is 2.2.2.4 dst is 2.2.2.5 / sctp src is 42 / raw relative is 1 offset is 2 pattern is abcd / end actions queue index 5 / end", "created")
+
+ # send the packets and verify the results
+ self.tester.scapy_append(
+ 'sendp([Ether(dst="%s", type=0x0807)/Raw(load="abcdefghijklmnop")], iface="%s")' % (self.pf_mac, self.tester_itf))
+ self.verify_result("pf", expect_rxpkts="1", expect_queue="1")
+
+ self.tester.scapy_append(
+ 'sendp([Ether(dst="%s")/Dot1Q(vlan=4095)/IP(src="192.168.0.1", dst="192.168.0.2", proto=255, ttl=40)/Raw(load="xxabxxxxxxxxxxabcdefghijabcdefg")], iface="%s")' % (self.pf_mac, self.tester_itf))
+ self.verify_result("pf", expect_rxpkts="1", expect_queue="2")
+
+ self.tester.scapy_append(
+ 'sendp([Ether(dst="%s")/IP(src="2.2.2.4", dst="2.2.2.5")/UDP(sport=22,dport=23)/Raw(load="fhfhdsdsfwef")], iface="%s")' % (self.pf_mac, self.tester_itf))
+ self.verify_result("pf", expect_rxpkts="1", expect_queue="3")
+
+ self.tester.scapy_append(
+ 'sendp([Ether(dst="%s")/IP(src="2.2.2.4", dst="2.2.2.5", tos=4, ttl=3)/TCP(sport=32,dport=33)/Raw(load="fhhijk")], iface="%s")' % (self.pf_mac, self.tester_itf))
+ self.verify_result("pf", expect_rxpkts="1", expect_queue="4")
+
+ self.tester.scapy_append(
+ 'sendp([Ether(dst="%s")/IP(src="2.2.2.4", dst="2.2.2.5")/SCTP(sport=42,dport=43,tag=1)/Raw(load="xxabcdefghijklmnopqrst")], iface="%s")' % (self.pf_mac, self.tester_itf))
+ self.verify_result("pf", expect_rxpkts="1", expect_queue="5")
+
+ self.tester.scapy_append(
+ 'sendp([Ether(dst="%s")/IP(src="2.2.2.4", dst="2.2.2.5")/SCTP(sport=42,dport=43,tag=1)/Raw(load="xxabxxxabcddxxabcdefghijklmn")], iface="%s")' % (self.outer_mac, self.tester_itf))
+ self.verify_result("pf", expect_rxpkts="1", expect_queue="0")
+
+ self.verify_rulenum(5)
+
+ self.dut.send_expect("quit", "# ")
+ time.sleep(2)
+
+ self.pmdout.start_testpmd("%s" % self.pf_cores, "--pkt-filter-mode=perfect --disable-rss --rxq=%d --txq=%d" % (MAX_QUEUE+1, MAX_QUEUE+1), "-w %s --file-prefix=pf --socket-mem 1024,1024" % self.pf_pci)
+ self.dut.send_expect("set fwd rxonly", "testpmd> ", 120)
+ self.dut.send_expect("set verbose 1", "testpmd> ", 120)
+ self.dut.send_expect("start", "testpmd> ", 120)
+ time.sleep(2)
+
+ # ipv6-tcp
+ self.dut.send_expect(
+ "flow create 0 ingress pattern eth / vlan tci is 1 / ipv6 src is 2001::1 dst is 2001::2 tc is 3 hop is 30 / tcp src is 32 dst is 33 / raw relative is 1 offset is 0 pattern is hijk / raw relative is 1 offset is 8 pattern is abcdefgh / end actions queue index 6 / end", "created")
+
+ # send the packet and verify the result
+ self.tester.scapy_append(
+ 'sendp([Ether(dst="%s")/Dot1Q(vlan=1)/IPv6(src="2001::1", dst="2001::2", tc=3, hlim=30)/TCP(sport=32,dport=33)/Raw(load="hijkabcdefghabcdefghijklmn")], iface="%s")' % (self.outer_mac, self.tester_itf))
+ self.verify_result("pf", expect_rxpkts="1", expect_queue="6")
+
+ # ixgbe
+ else:
+ self.pmdout.start_testpmd("%s" % self.cores, "--pkt-filter-mode=perfect --disable-rss --rxq=%d --txq=%d" % (MAX_QUEUE+1, MAX_QUEUE+1))
+ self.dut.send_expect("set fwd rxonly", "testpmd> ", 120)
+ self.dut.send_expect("set verbose 1", "testpmd> ", 120)
+ self.dut.send_expect("start", "testpmd> ", 120)
+ time.sleep(2)
+
+ # ipv4-udp-flexbytes
+ self.dut.send_expect(
+ "flow create 0 ingress pattern eth / ipv4 src is 192.168.0.1 dst is 192.168.0.2 / udp src is 24 dst is 25 / raw relative is 0 search is 0 offset is 44 limit is 0 pattern is 86 / end actions queue index 1 / end", "created")
+
+ # send the packet and verify the result
+ self.tester.scapy_append(
+ 'sendp([Ether(dst="%s")/IP(src="192.168.0.1", dst="192.168.0.2")/UDP(sport=24,dport=25)/Raw(load="xx86ddef")], iface="%s")' % (self.outer_mac, self.tester_itf))
+ self.verify_result("pf", expect_rxpkts="1", expect_queue="1")
+
+ self.dut.send_expect("quit", "# ")
+ time.sleep(2)
+
+ # the second flexbytes rule should be created after the testpmd reset, because the flexbytes rule is global bit masks
+ self.pmdout.start_testpmd("%s" % self.cores, "--pkt-filter-mode=perfect --disable-rss --rxq=%d --txq=%d" % (MAX_QUEUE+1, MAX_QUEUE+1))
+ self.dut.send_expect("set fwd rxonly", "testpmd> ", 120)
+ self.dut.send_expect("set verbose 1", "testpmd> ", 120)
+ self.dut.send_expect("start", "testpmd> ", 120)
+ time.sleep(2)
+
+ # ipv4-tcp-flexbytes spec-mask
+ self.dut.send_expect(
+ "flow create 0 ingress pattern eth / ipv4 src is 192.168.0.3 dst is 192.168.0.4 / tcp src is 22 dst is 23 / raw relative spec 0 relative mask 1 search spec 0 search mask 1 offset spec 54 offset mask 0xffffffff limit spec 0 limit mask 0xffff pattern is ab pattern is cd / end actions queue index 2 / end", "created")
+
+ # send the packet and verify the result
+ self.tester.scapy_append(
+ 'sendp([Ether(dst="%s")/IP(src="192.168.0.3", dst="192.168.0.4")/TCP(sport=22,dport=23)/Raw(load="abcdxxx")], iface="%s")' % (self.outer_mac, self.tester_itf))
+ self.verify_result("pf", expect_rxpkts="1", expect_queue="0")
+
+ self.tester.scapy_append(
+ 'sendp([Ether(dst="%s")/IP(src="192.168.0.3", dst="192.168.0.4")/TCP(sport=22,dport=23)/Raw(load="cdcdxxx")], iface="%s")' % (self.outer_mac, self.tester_itf))
+ self.verify_result("pf", expect_rxpkts="1", expect_queue="2")
+
+ self.dut.send_expect("quit", "# ")
+ time.sleep(2)
+
+ # signature mode
+ self.pmdout.start_testpmd("%s" % self.cores, "--pkt-filter-mode=signature --disable-rss --rxq=%d --txq=%d" % (MAX_QUEUE+1, MAX_QUEUE+1))
+ self.dut.send_expect("set fwd rxonly", "testpmd> ", 120)
+ self.dut.send_expect("set verbose 1", "testpmd> ", 120)
+ self.dut.send_expect("start", "testpmd> ", 120)
+ time.sleep(2)
+
+ # ipv4-sctp-flexbytes
+ if (self.nic in ["sagepond", "sageville"]):
+ self.dut.send_expect(
+ "flow create 0 ingress pattern fuzzy thresh is 6 / eth / ipv4 src is 192.168.0.1 dst is 192.168.0.2 / sctp src is 24 dst is 25 / raw relative is 0 search is 0 offset is 48 limit is 0 pattern is ab / end actions queue index 3 / end", "created")
+ else:
+ self.dut.send_expect(
+ "flow create 0 ingress pattern fuzzy thresh is 6 / eth / ipv4 src is 192.168.0.1 dst is 192.168.0.2 / sctp / raw relative is 0 search is 0 offset is 48 limit is 0 pattern is ab / end actions queue index 3 / end", "created")
+
+ # send the packet and verify the result
+ self.tester.scapy_append(
+ 'sendp([Ether(dst="%s")/IP(src="192.168.0.1", dst="192.168.0.2")/SCTP(sport=24,dport=25)/Raw(load="xxabcdef")], iface="%s")' % (self.outer_mac, self.tester_itf))
+ self.verify_result("pf", expect_rxpkts="1", expect_queue="3")
+ self.tester.scapy_append(
+ 'sendp([Ether(dst="%s")/IP(src="192.168.0.1", dst="192.168.0.2")/SCTP(sport=24,dport=25)/Raw(load="xxaccdef")], iface="%s")' % (self.outer_mac, self.tester_itf))
+ self.verify_result("pf", expect_rxpkts="1", expect_queue="0")
+
+ # ipv6-other-flexbytes
+ if (self.nic in ["niantic", "twinville"]):
+ self.dut.send_expect("quit", "# ")
+ time.sleep(2)
+
+ self.pmdout.start_testpmd("%s" % self.cores, "--pkt-filter-mode=signature --disable-rss --rxq=%d --txq=%d" % (MAX_QUEUE+1, MAX_QUEUE+1))
+ self.dut.send_expect("set fwd rxonly", "testpmd> ", 120)
+ self.dut.send_expect("set verbose 1", "testpmd> ", 120)
+ self.dut.send_expect("start", "testpmd> ", 120)
+ time.sleep(2)
+
+ self.dut.send_expect(
+ "flow create 0 ingress pattern fuzzy thresh is 6 / ipv6 src is 2001::1 dst is 2001::2 / raw relative is 0 search is 0 offset is 56 limit is 0 pattern is 86 / end actions queue index 4 / end", "created")
+ self.tester.scapy_append(
+ 'sendp([Ether(dst="%s")/IPv6(src="2001::1", dst="2001::2")/Raw(load="xx86abcd")], iface="%s")' % (self.outer_mac, self.tester_itf))
+ self.verify_result("pf", expect_rxpkts="1", expect_queue="4")
+ self.tester.scapy_append(
+ 'sendp([Ether(dst="%s")/IPv6(src="2001::1", dst="2001::2")/Raw(load="xxx86abcd")], iface="%s")' % (self.outer_mac, self.tester_itf))
+ self.verify_result("pf", expect_rxpkts="1", expect_queue="0")
+
+ def test_flexbytes_filter(self):
+ """
+ The filter structure is different between igb, ixgbe and i40e
+ """
+ self.verify(self.nic in ["bartonhills", "powerville"], "%s nic not support flexbytes filter" % self.nic)
+
+ self.pmdout.start_testpmd("%s" % self.pf_cores, "--disable-rss --rxq=%d --txq=%d" % (MAX_QUEUE+1, MAX_QUEUE+1))
+ self.dut.send_expect("set fwd rxonly", "testpmd> ", 120)
+ self.dut.send_expect("set verbose 1", "testpmd> ", 120)
+ self.dut.send_expect("start", "testpmd> ", 120)
+ time.sleep(2)
+
+ # create the flow rules
+ # l2_payload
+ self.dut.send_expect(
+ "flow create 0 ingress pattern raw relative is 0 offset is 14 pattern is fhds / end actions queue index 1 / end", "created")
+ # ipv4 packet
+ self.dut.send_expect(
+ "flow create 0 ingress pattern raw relative is 0 offset is 34 pattern is ab / end actions queue index 2 / end", "created")
+ # ipv6 packet
+ self.dut.send_expect(
+ "flow create 0 ingress pattern raw relative is 0 offset is 58 pattern is efgh / end actions queue index 3 / end", "created")
+ # 3 fields relative is 0
+ self.dut.send_expect(
+ "flow create 0 ingress pattern raw relative is 0 offset is 38 pattern is ab / raw relative is 0 offset is 34 pattern is cd / raw relative is 0 offset is 42 pattern is efgh / end actions queue index 4 / end", "created")
+ # 4 fields relative is 0 and 1
+ self.dut.send_expect(
+ "flow create 0 ingress pattern raw relative is 0 offset is 48 pattern is ab / raw relative is 1 offset is 0 pattern is cd / raw relative is 0 offset is 44 pattern is efgh / raw relative is 1 offset is 10 pattern is hijklmnopq / end actions queue index 5 / end", "created")
+ # 3 fields offset confilict
+ self.dut.send_expect(
+ "flow create 0 ingress pattern raw relative is 0 offset is 64 pattern is ab / raw relative is 1 offset is 4 pattern is cdefgh / raw relative is 0 offset is 68 pattern is klmn / end actions queue index 6 / end", "created")
+
+ # send the packet and verify the result
+ self.tester.scapy_append(
+ 'sendp([Ether(dst="%s")/Raw(load="fhdsab")], iface="%s")' % (self.outer_mac, self.tester_itf))
+ self.verify_result("pf", expect_rxpkts="1", expect_queue="1")
+ self.tester.scapy_append(
+ 'sendp([Ether(dst="%s")/Raw(load="afhdsb")], iface="%s")' % (self.outer_mac, self.tester_itf))
+ self.verify_result("pf", expect_rxpkts="1", expect_queue="0")
+ self.tester.scapy_append(
+ 'sendp([Ether(dst="%s")/IP(src="192.168.0.1", dst="192.168.0.2")/Raw(load="abcdef")], iface="%s")' % (self.outer_mac, self.tester_itf))
+ self.verify_result("pf", expect_rxpkts="1", expect_queue="2")
+ self.tester.scapy_append(
+ 'sendp([Ether(dst="%s")/IPv6(src="2001::1", dst="2001::2")/Raw(load="xxxxefgh")], iface="%s")' % (self.outer_mac, self.tester_itf))
+ self.verify_result("pf", expect_rxpkts="1", expect_queue="3")
+ self.tester.scapy_append(
+ 'sendp([Ether(dst="%s")/IPv6(src="2001::1", dst="2001::2")/TCP(sport=32,dport=33)/Raw(load="abcdefgh")], iface="%s")' % (self.outer_mac, self.tester_itf))
+ self.verify_result("pf", expect_rxpkts="1", expect_queue="0")
+ self.tester.scapy_append(
+ 'sendp([Ether(dst="%s")/IP(src="192.168.0.1", dst="192.168.0.2")/Raw(load="cdxxabxxefghxxxx")], iface="%s")' % (self.outer_mac, self.tester_itf))
+ self.verify_result("pf", expect_rxpkts="1", expect_queue="4")
+ self.tester.scapy_append(
+ 'sendp([Ether(dst="%s")/IP(src="192.168.0.1", dst="192.168.0.2", tos=4, ttl=3)/UDP(sport=32,dport=33)/Raw(load="xxefghabcdxxxxxxhijklmnopqxxxx")], iface="%s")' % (self.outer_mac, self.tester_itf))
+ self.verify_result("pf", expect_rxpkts="1", expect_queue="5")
+ self.tester.scapy_append(
+ 'sendp([Ether(dst="%s")/IP(src="192.168.0.1", dst="192.168.0.2")/TCP(sport=22,dport=23)/Raw(load="xxxxxxxxxxabxxklmnefgh")], iface="%s")' % (self.outer_mac, self.tester_itf))
+ self.verify_result("pf", expect_rxpkts="1", expect_queue="6")
+ self.tester.scapy_append(
+ 'sendp([Ether(dst="%s")/IP(src="192.168.0.1", dst="192.168.0.2")/TCP(sport=22,dport=23)/Raw(load="xxxxxxxxxxabxxklcdefgh")], iface="%s")' % (self.outer_mac, self.tester_itf))
+ self.verify_result("pf", expect_rxpkts="1", expect_queue="0")
+
+ self.dut.send_expect("flow flush 0", "testpmd> ", 120)
+
+ # 1 field 128bytes
+ self.dut.send_expect(
+ "flow create 0 ingress pattern raw relative is 0 offset is 128 pattern is ab / end actions queue index 1 / end", "Failed to create flow")
+ self.dut.send_expect(
+ "flow create 0 ingress pattern raw relative is 0 offset is 126 pattern is abcd / end actions queue index 1 / end", "Failed to create flow")
+ self.dut.send_expect(
+ "flow create 0 ingress pattern raw relative is 0 offset is 126 pattern is ab / end actions queue index 1 / end", "created")
+ # 2 field 128bytes
+ self.dut.send_expect(
+ "flow create 0 ingress pattern raw relative is 0 offset is 68 pattern is ab / raw relative is 1 offset is 58 pattern is cd / end actions queue index 2 / end", "Failed to create flow")
+ self.dut.send_expect(
+ "flow create 0 ingress pattern raw relative is 0 offset is 68 pattern is ab / raw relative is 1 offset is 56 pattern is cd / end actions queue index 2 / end", "created")
+
+ # send the packet and verify the result
+ self.tester.scapy_append(
+ 'sendp([Ether(dst="%s")/IP(src="192.168.0.1", dst="192.168.0.2")/TCP(sport=22,dport=23)/Raw(load="xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxab")], iface="%s")' % (self.outer_mac, self.tester_itf))
+ self.verify_result("pf", expect_rxpkts="1", expect_queue="1")
+ self.tester.scapy_append(
+ 'sendp([Ether(dst="%s")/IP(src="192.168.0.1", dst="192.168.0.2")/TCP(sport=22,dport=23)/Raw(load="xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxcb")], iface="%s")' % (self.outer_mac, self.tester_itf))
+ self.verify_result("pf", expect_rxpkts="1", expect_queue="0")
+ self.tester.scapy_append(
+ 'sendp([Ether(dst="%s")/IP(src="192.168.0.1", dst="192.168.0.2")/TCP(sport=22,dport=23)/Raw(load="xxxxxxxxxxxxxxabxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxcd")], iface="%s")' % (self.outer_mac, self.tester_itf))
+ self.verify_result("pf", expect_rxpkts="1", expect_queue="2")
+ self.tester.scapy_append(
+ 'sendp([Ether(dst="%s")/IP(src="192.168.0.1", dst="192.168.0.2")/TCP(sport=22,dport=23)/Raw(load="xxxxxxxxxxxxxxabxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxce")], iface="%s")' % (self.outer_mac, self.tester_itf))
+ self.verify_result("pf", expect_rxpkts="1", expect_queue="0")
+
+ self.verify_rulenum(2)
+
+ def test_fdir_for_mac_vlan(self):
+ """
+ only supported by ixgbe
+ """
+ self.verify(self.nic in ["twinville", "sagepond", "sageville"], "%s nic not support fdir flexbytes filter" % self.nic)
+
+ self.pmdout.start_testpmd("%s" % self.cores, "--pkt-filter-mode=perfect-mac-vlan --disable-rss --rxq=%d --txq=%d" % (MAX_QUEUE+1, MAX_QUEUE+1))
+ self.dut.send_expect("set fwd rxonly", "testpmd> ", 120)
+ self.dut.send_expect("set verbose 1", "testpmd> ", 120)
+ self.dut.send_expect("vlan set strip off 0", "testpmd> ", 120)
+ self.dut.send_expect("vlan set filter off 0", "testpmd> ", 120)
+ self.dut.send_expect("start", "testpmd> ", 120)
+ time.sleep(2)
+
+ # create the flow rules
+ basic_flow_actions = [
+ {'create': 'create', 'flows': ['dst_mac', 'vlan', 'tpid'], 'actions': ['queue']},
+ {'create': 'create', 'flows': ['dst_mac', 'vlan', 'tpid'], 'actions': ['queue']},
+ ]
+ extrapkt_rulenum = self.all_flows_process(basic_flow_actions)
+ rule_num = extrapkt_rulenum['rulenum']
+ self.verify_rulenum(rule_num)
+
+ def test_fdir_for_vxlan(self):
+ """
+ only supported by ixgbe
+ """
+ self.verify(self.nic in ["twinville", "sagepond", "sageville"], "%s nic not support fdir flexbytes filter" % self.nic)
+
+ self.pmdout.start_testpmd("%s" % self.cores, "--pkt-filter-mode=perfect-tunnel --disable-rss --rxq=%d --txq=%d" % (MAX_QUEUE+1, MAX_QUEUE+1))
+ self.dut.send_expect("set fwd rxonly", "testpmd> ", 120)
+ self.dut.send_expect("set verbose 1", "testpmd> ", 120)
+ self.dut.send_expect("start", "testpmd> ", 120)
+ time.sleep(2)
+
+ # create the flow rules
+ basic_flow_actions = [
+ {'create': 'create', 'flows': ['ipv4', 'udp', 'vxlan', 'vni', 'ineth', 'invlan', 'tpid'], 'actions': ['queue']},
+ {'create': 'create', 'flows': ['ipv6', 'udp', 'vxlan', 'vni', 'ineth', 'invlan', 'tpid'], 'actions': ['queue']},
+ ]
+ extrapkt_rulenum = self.all_flows_process(basic_flow_actions)
+ rule_num = extrapkt_rulenum['rulenum']
+ self.verify_rulenum(rule_num)
+
+ def test_fdir_for_nvgre(self):
+ """
+ only supported by ixgbe
+ """
+ self.verify(self.nic in ["twinville", "sagepond", "sageville"], "%s nic not support fdir flexbytes filter" % self.nic)
+
+ self.pmdout.start_testpmd("%s" % self.cores, "--pkt-filter-mode=perfect-tunnel --disable-rss --rxq=%d --txq=%d" % (MAX_QUEUE+1, MAX_QUEUE+1))
+ self.dut.send_expect("set fwd rxonly", "testpmd> ", 120)
+ self.dut.send_expect("set verbose 1", "testpmd> ", 120)
+ self.dut.send_expect("start", "testpmd> ", 120)
+ time.sleep(2)
+
+ # create the flow rules
+ basic_flow_actions = [
+ {'create': 'create', 'flows': ['ipv4', 'nvgre', 'tni', 'ineth', 'invlan'], 'actions': ['queue']},
+ {'create': 'create', 'flows': ['ipv6', 'nvgre', 'tni', 'ineth', 'invlan'], 'actions': ['queue']},
+ ]
+ extrapkt_rulenum = self.all_flows_process(basic_flow_actions)
+ rule_num = extrapkt_rulenum['rulenum']
+ self.verify_rulenum(rule_num)
+
+ def test_tunnel_filter_vxlan(self):
+ """
+ only supported by i40e
+ """
+ self.verify(self.nic in ["fortville_eagle", "fortville_spirit",
+ "fortville_spirit_single", "fortpark_TLV"], "%s nic not support tunnel vxlan filter" % self.nic)
+
+ self.setup_env()
+ self.pmdout.start_testpmd("%s" % self.pf_cores, "--disable-rss --rxq=%d --txq=%d" % (MAX_QUEUE+1, MAX_QUEUE+1), "-w %s --file-prefix=pf --socket-mem 1024,1024" % self.pf_pci)
+ self.dut.send_expect("rx_vxlan_port add 4789 0", "testpmd> ", 120)
+ self.dut.send_expect("set fwd rxonly", "testpmd> ", 120)
+ self.dut.send_expect("set verbose 1", "testpmd> ", 120)
+ self.dut.send_expect("start", "testpmd> ", 120)
+ time.sleep(2)
+ self.session_secondary.send_expect("./%s/app/testpmd -c 0x1e0000 -n 4 --socket-mem 1024,1024 -w %s --file-prefix=vf1 -- -i --rxq=4 --txq=4 --disable-rss" % (self.target, self.sriov_vfs_port[0].pci), "testpmd>", 120)
+ self.session_secondary.send_expect("set fwd rxonly", "testpmd>")
+ self.session_secondary.send_expect("set verbose 1", "testpmd>")
+ self.session_secondary.send_expect("start", "testpmd>")
+ time.sleep(2)
+ self.session_third.send_expect("./%s/app/testpmd -c 0x1e000000 -n 4 --socket-mem 1024,1024 -w %s --file-prefix=vf2 -- -i --rxq=4 --txq=4 --disable-rss" % (self.target, self.sriov_vfs_port[1].pci), "testpmd>", 120)
+ self.session_third.send_expect("set fwd rxonly", "testpmd>")
+ self.session_third.send_expect("set verbose 1", "testpmd>")
+ self.session_third.send_expect("start", "testpmd>")
+ time.sleep(2)
+
+ # create the flow rules
+ basic_flow_actions = [
+ {'create': 'create', 'flows': ['ipv4', 'udp', 'vxlan', 'ineth'], 'actions': ['pf', 'queue']},
+ {'create': 'create', 'flows': ['ipv4', 'udp', 'vxlan', 'vni', 'ineth'], 'actions': ['pf', 'queue']},
+ {'create': 'create', 'flows': ['ipv4', 'udp', 'vxlan', 'ineth', 'invlan'], 'actions': ['pf', 'queue']},
+ {'create': 'create', 'flows': ['ipv4', 'udp', 'vxlan', 'vni', 'ineth', 'invlan'], 'actions': ['pf', 'queue']},
+ {'create': 'create', 'flows': ['dst_mac', 'ipv4', 'udp', 'vxlan', 'vni', 'ineth'], 'actions': ['pf', 'queue']},
+ {'create': 'create', 'flows': ['ipv4', 'udp', 'vxlan', 'vni', 'ineth', 'invlan'], 'actions': ['vf0', 'queue']},
+ {'create': 'create', 'flows': ['dst_mac', 'ipv4', 'udp', 'vxlan', 'vni', 'ineth'], 'actions': ['vf1', 'queue']},
+ ]
+ extrapkt_rulenum = self.all_flows_process(basic_flow_actions)
+ extra_packet = extrapkt_rulenum['extrapacket']
+ self.tester.scapy_append(
+ 'sendp([Ether(dst="%s")/IP()/UDP()/Vxlan()/Ether(dst="%s")/Dot1Q(vlan=11)/IP()/TCP()/Raw("x" * 20)], iface="%s")' % (self.outer_mac, self.inner_mac, self.tester_itf))
+ self.verify_result("pf", expect_rxpkts="1", expect_queue=extrapkt_rulenum['queue'][0])
+ self.tester.scapy_append(
+ 'sendp([Ether(dst="%s")/IP()/UDP()/Vxlan(vni=5)/Ether(dst="%s")/IP()/TCP()/Raw("x" * 20)], iface="%s")' % (self.outer_mac, self.wrong_mac, self.tester_itf))
+ self.verify_result("pf", expect_rxpkts="1", expect_queue="0")
+ self.tester.scapy_append(
+ 'sendp([Ether(dst="%s")/IP()/UDP()/Vxlan(vni=%s)/Ether(dst="%s")/Dot1Q(vlan=%s)/IP()/TCP()/Raw("x" * 20)], iface="%s")' % (self.outer_mac, extra_packet[5]['vni'], self.wrong_mac, extra_packet[5]['invlan'], self.tester_itf))
+ self.verify_result("vf0", expect_rxpkts="1", expect_queue="0")
+ self.tester.scapy_append(
+ 'sendp([Ether(dst="%s")/IP()/UDP()/Vxlan(vni=%s)/Ether(dst="%s")/IP()/TCP()/Raw("x" * 20)], iface="%s")' % (self.wrong_mac, extra_packet[6]['vni'], self.inner_mac, self.tester_itf))
+ self.verify_result("vf1", expect_rxpkts="0", expect_queue="NULL")
+ rule_num = extrapkt_rulenum['rulenum']
+ self.verify_rulenum(rule_num)
+
+ def test_tunnel_filter_nvgre(self):
+ """
+ only supported by i40e
+ """
+ self.verify(self.nic in ["fortville_eagle", "fortville_spirit",
+ "fortville_spirit_single", "fortpark_TLV"], "%s nic not support tunnel nvgre filter" % self.nic)
+
+ self.setup_env()
+ self.pmdout.start_testpmd("%s" % self.pf_cores, "--disable-rss --rxq=%d --txq=%d" % (MAX_QUEUE+1, MAX_QUEUE+1), "-w %s --file-prefix=pf --socket-mem 1024,1024" % self.pf_pci)
+ self.dut.send_expect("set fwd rxonly", "testpmd> ", 120)
+ self.dut.send_expect("set verbose 1", "testpmd> ", 120)
+ self.dut.send_expect("start", "testpmd> ", 120)
+ time.sleep(2)
+ self.session_secondary.send_expect("./%s/app/testpmd -c 0x1e0000 -n 4 --socket-mem 1024,1024 -w %s --file-prefix=vf1 -- -i --rxq=4 --txq=4 --disable-rss" % (self.target, self.sriov_vfs_port[0].pci), "testpmd>", 120)
+ self.session_secondary.send_expect("set fwd rxonly", "testpmd>")
+ self.session_secondary.send_expect("set verbose 1", "testpmd>")
+ self.session_secondary.send_expect("start", "testpmd>")
+ time.sleep(2)
+ self.session_third.send_expect("./%s/app/testpmd -c 0x1e000000 -n 4 --socket-mem 1024,1024 -w %s --file-prefix=vf2 -- -i --rxq=4 --txq=4 --disable-rss" % (self.target, self.sriov_vfs_port[1].pci), "testpmd>", 120)
+ self.session_third.send_expect("set fwd rxonly", "testpmd>")
+ self.session_third.send_expect("set verbose 1", "testpmd>")
+ self.session_third.send_expect("start", "testpmd>")
+ time.sleep(2)
+
+ # create the flow rules
+ basic_flow_actions = [
+ {'create': 'create', 'flows': ['ipv4', 'nvgre', 'ineth'], 'actions': ['pf', 'queue']},
+ {'create': 'create', 'flows': ['ipv4', 'nvgre', 'tni', 'ineth'], 'actions': ['pf', 'queue']},
+ {'create': 'create', 'flows': ['ipv4', 'nvgre', 'ineth', 'invlan'], 'actions': ['pf', 'queue']},
+ {'create': 'create', 'flows': ['ipv4', 'nvgre', 'tni', 'ineth', 'invlan'], 'actions': ['pf', 'queue']},
+ {'create': 'create', 'flows': ['dst_mac', 'ipv4', 'nvgre', 'tni', 'ineth'], 'actions': ['pf', 'queue']},
+ {'create': 'create', 'flows': ['ipv4', 'nvgre', 'tni', 'ineth', 'invlan'], 'actions': ['vf0', 'queue']},
+ {'create': 'create', 'flows': ['dst_mac', 'ipv4', 'nvgre', 'tni', 'ineth'], 'actions': ['vf1', 'queue']},
+ ]
+ extrapkt_rulenum = self.all_flows_process(basic_flow_actions)
+ extra_packet = extrapkt_rulenum['extrapacket']
+ self.tester.scapy_append(
+ 'sendp([Ether(dst="%s")/IP()/NVGRE()/Ether(dst="%s")/Dot1Q(vlan=1)/IP()/TCP()/Raw("x" * 20)], iface="%s")' % (self.outer_mac, self.inner_mac, self.tester_itf))
+ self.verify_result("pf", expect_rxpkts="1", expect_queue=extrapkt_rulenum['queue'][0])
+ self.tester.scapy_append(
+ 'sendp([Ether(dst="%s")/IP()/NVGRE(TNI=%s)/Ether(dst="%s")/IP()/TCP()/Raw("x" * 20)], iface="%s")' % (self.outer_mac, extra_packet[4]['tni'], self.wrong_mac, self.tester_itf))
+ self.verify_result("pf", expect_rxpkts="1", expect_queue="0")
+ self.tester.scapy_append(
+ 'sendp([Ether(dst="%s")/IP()/NVGRE(TNI=%s)/Ether(dst="%s")/Dot1Q(vlan=%s)/IP()/TCP()/Raw("x" * 20)], iface="%s")' % (self.outer_mac, extra_packet[5]['tni'], self.wrong_mac, extra_packet[5]['invlan'], self.tester_itf))
+ self.verify_result("vf0", expect_rxpkts="1", expect_queue="0")
+ self.tester.scapy_append(
+ 'sendp([Ether(dst="%s")/IP()/NVGRE(TNI=%s)/Ether(dst="%s")/IP()/TCP()/Raw("x" * 20)], iface="%s")' % (self.wrong_mac, extra_packet[6]['tni'], self.inner_mac, self.tester_itf))
+ self.verify_result("vf1", expect_rxpkts="0", expect_queue="NULL")
+ rule_num = extrapkt_rulenum['rulenum']
+ self.verify_rulenum(rule_num)
+
+ def tear_down(self):
+ """
+ Run after each test case.
+ """
+ self.destroy_env()
+ self.dut.kill_all()
+
+ def tear_down_all(self):
+ """
+ Run after each test suite.
+ """
+ self.dut.kill_all()
+ self.dut.close_session(self.session_secondary)
+ self.dut.close_session(self.session_third)
--
2.5.0
More information about the dts
mailing list