[dts] [PATCH] tests: add TestSuite_generic_flow_api.py
Liu, Yong
yong.liu at intel.com
Wed May 16 08:02:30 CEST 2018
Yuan,
Some comments are inline. Since this suite cover multiple kinds of filters, we need to think about how to benefit other suites from this implementation.
Thanks,
Marvin
> -----Original Message-----
> From: dts [mailto:dts-bounces at dpdk.org] On Behalf Of Peng Yuan
> Sent: Wednesday, April 25, 2018 4:05 PM
> To: dts at dpdk.org
> Cc: Peng, Yuan <yuan.peng at intel.com>
> Subject: [dts] [PATCH] tests: add TestSuite_generic_flow_api.py
>
> 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
Some imports look like not useful like Crb and DRIVERS, pleasre remove them.
> +
> +from virt_dut import VirtDut
> +from project_dpdk import DPDKdut
> +from dut import Dut
No need to import DPDKdut and Dut module.
> +from packet import Packet
> +
> +import os
> +import random
> +from exception import VerifyFailure
> +import scapy.layers.inet
> +from scapy.utils import rdpcap
Rdpcap is not used in this suite.
> +
> +MAX_VLAN = 4095
> +MAX_QUEUE = 15
> +MAX_VFQUEUE = 3
> +MAX_PORT = 65535
> +MAX_PROTO = 133
> +MAX_TTL = 255
> +MAX_TOS = 255
MAX_QUEUE and MAX_VFQUEUE may different between NICS, is it only meaningful in this suite or the constant value for NIC?
> +
> +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)
As I known, some users environment can't allocate so much cores. Could you please reduce the number of cores? Like one or two.
> +
> + 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()
Please named the session with more meaningful name like self.host_dpdk_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
Flag should be set at the end of this function.
> + # 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")
Module should be configured in conf/global_suite, you can retrieve it by self.get_suite_cfg()['vf_driver'].
> + 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:
Should this flag the prerequisite this function? If that, no need to check this.
> + 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> ")
Recommend to add one function for striping queue id and packet statistic from testpmd session. Which can make verification function simple.
> +
> + 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.
Typo here, " inconsistet " should be inconsistent.
> + 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
Could this case utilize all_flows_process function? Look like packet and flow commands be can verified in that function.
And inconsistent packet check can also be done in that function. If so, each test case only need to define the flow format which need to verified.
> + 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']
As previous comments, could inconsistent check also be done in all_flows_process?
May need more suiteable name for that function.
> + # 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")
I expected that packet string has been
> + 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="xxabcdefghijklmnopq
> rst")], 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="xxabxxxabcddxxabcde
> fghijklmn")], 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)
> +
Could flexbytes format generation also can be done by function, maybe plus some kind of random check?
> + # 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="xxxxxxxxxxxxxxxxxxxxxx
> xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxab")], 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="xxxxxxxxxxxxxxxxxxxxxx
> xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxcb")], 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="xxxxxxxxxxxxxxabxxxxxx
> xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxcd")], 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="xxxxxxxxxxxxxxabxxxxxx
> xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxce")], 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)
Some setup functions are duplicated, may need one function for testpmd startup and set verbose rx mode.
> +
> + # 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(vla
> n=%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()/TC
> P()/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