From patchwork Fri Aug 26 14:38:24 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: "Jiale, SongX" X-Patchwork-Id: 115459 Return-Path: X-Original-To: patchwork@inbox.dpdk.org Delivered-To: patchwork@inbox.dpdk.org Received: from mails.dpdk.org (mails.dpdk.org [217.70.189.124]) by inbox.dpdk.org (Postfix) with ESMTP id 34BA4A0552; Fri, 26 Aug 2022 08:22:19 +0200 (CEST) Received: from [217.70.189.124] (localhost [127.0.0.1]) by mails.dpdk.org (Postfix) with ESMTP id 2FC1140696; Fri, 26 Aug 2022 08:22:19 +0200 (CEST) Received: from mga05.intel.com (mga05.intel.com [192.55.52.43]) by mails.dpdk.org (Postfix) with ESMTP id 2CC9A40143 for ; Fri, 26 Aug 2022 08:22:17 +0200 (CEST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=intel.com; i=@intel.com; q=dns/txt; s=Intel; t=1661494937; x=1693030937; h=from:to:cc:subject:date:message-id:in-reply-to: references; bh=awYG+SgkvxvEs/zf2DvGfYlvAWT6c9rG6AVDU3mHYLk=; b=B6f7FWpgTIjPbjKmrt1a6vbPfGWyNn5+IEiOxvc5cVDfwf5x5TOnCKQN LRWsKguh6wreNnuVdFU8ME1JnLEYQ8L+9t/OBIv9iqg5fx8hf3n452GBw Ug1oxYfiHboikjyW7pPzNRqwD5KycMNzsXWKrJ+SgIDSsE72VfME2LUjJ 05DOiESVtHFeaJQMm7rsabNrvdazcQl5OYH6wq4nw154lbRNCSsfvnvR5 up4biu2VZawx2ebfAvTLxTMETLlJLSyUqMd4Sk+XH6C9Yx0cYahM/mCXK eX9u5Pqmlu52yP78hNbmC8q+NYhyVL1GhNugqzuUfr9gidWhoMYoJxwR+ g==; X-IronPort-AV: E=McAfee;i="6500,9779,10450"; a="380728083" X-IronPort-AV: E=Sophos;i="5.93,264,1654585200"; d="scan'208";a="380728083" Received: from fmsmga005.fm.intel.com ([10.253.24.32]) by fmsmga105.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 25 Aug 2022 23:22:16 -0700 X-IronPort-AV: E=Sophos;i="5.93,264,1654585200"; d="scan'208";a="938640622" Received: from unknown (HELO cvl_tetser_105.icx.intel.com) ([10.239.252.94]) by fmsmga005-auth.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 25 Aug 2022 23:22:15 -0700 From: Jiale Song To: dts@dpdk.org Cc: Jiale Song Subject: [dts] [PATCH V1 2/2] tests/ice_flow_priority: move the case of rteflow_priority to ice_flow_priority and remove rteflow_priority Date: Fri, 26 Aug 2022 14:38:24 +0000 Message-Id: <20220826143824.12813-2-songx.jiale@intel.com> X-Mailer: git-send-email 2.17.1 In-Reply-To: <20220826143824.12813-1-songx.jiale@intel.com> References: <20220826143824.12813-1-songx.jiale@intel.com> X-BeenThere: dts@dpdk.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: test suite reviews and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dts-bounces@dpdk.org 1. move the case not covered by ice_flow_priority from rteflow_priority to ice_flow_priority. 2. remove the test suite rteflow_priority. Signed-off-by: Jiale Song Signed-off-by: Jiale Song Acked-by: Lijuan Tu --- tests/TestSuite_ice_flow_priority.py | 172 ++++++++- tests/TestSuite_rteflow_priority.py | 529 --------------------------- 2 files changed, 169 insertions(+), 532 deletions(-) delete mode 100644 tests/TestSuite_rteflow_priority.py diff --git a/tests/TestSuite_ice_flow_priority.py b/tests/TestSuite_ice_flow_priority.py index 4f63f06d..ddc6a2af 100644 --- a/tests/TestSuite_ice_flow_priority.py +++ b/tests/TestSuite_ice_flow_priority.py @@ -440,11 +440,22 @@ class ICEPFFlowPriorityTest(TestCase): cores="1S/4C/1T", ports=[self.pf_pci], eal_param="--log-level=ice,8", - param="--rxq=16 --txq=16", + param="--rxq={0} --txq={0}".format(self.rxq), + ) + # start testpmd in pipeline mode + elif "pipeline" in self._suite_result.test_case: + self.pmdout.start_testpmd( + cores="1S/4C/1T", + ports=[self.pf_pci], + port_options={self.pf_pci: "pipeline-mode-support=1"}, + eal_param="--log-level=ice,7", + param="--rxq={0} --txq={0}".format(self.rxq), ) else: self.pmdout.start_testpmd( - cores="1S/4C/1T", ports=[self.pf_pci], param="--rxq=16 --txq=16" + cores="1S/4C/1T", + ports=[self.pf_pci], + param="--rxq={0} --txq={0}".format(self.rxq), ) self.pmdout.execute_cmd("set fwd rxonly") self.pmdout.execute_cmd("set verbose 1") @@ -652,11 +663,166 @@ class ICEPFFlowPriorityTest(TestCase): queue = re.findall(p, out) self.verify(len(queue) == 1 and int(queue[0]) == 5, "drop pkt failed") + def test_create_fdir_rule_with_priority_0_pipeline(self): + """ + Create Flow Rules Only Supported by Fdir Filter with Priority 0 + """ + # create rules only supported by fdir with priority 0, check the rules can not be created. + out = self.dut.send_expect( + "flow create 0 priority 0 ingress pattern eth / ipv6 src is 1111:2222:3333:4444:5555:6666:7777:8888 dst is 1111:2222:3333:4444:5555:6666:7777:9999 / sctp src is 25 dst is 23 / end actions queue index 1 / end", + "testpmd> ", + ) + self.verify("Failed" in out, "failed: priority is not work") + out = self.dut.send_expect( + "flow create 0 priority 0 ingress pattern eth / ipv4 src is 192.168.0.2 dst is 192.168.0.3 tos is 4 ttl is 20 / sctp src is 25 dst is 23 / end actions queue index 1 / end", + "testpmd> ", + ) + self.verify("Failed" in out, "failed: priority is not work") + self.dut.send_expect("quit", "# ") + + def test_create_switch_rule_with_priority_1_pipeline(self): + """ + Create flow rules only supported by switch filter with priority 1 + """ + # create rules only supported by switch with priority 1, check the rules can not be created. + out = self.dut.send_expect( + "flow create 0 priority 1 ingress pattern eth / ipv4 / nvgre / eth / ipv4 src is 192.168.0.2 dst is 192.168.0.3 tos is 4 / end actions queue index 3 / end", + "testpmd> ", + ) + self.verify("Failed" in out, "failed: priority is not work") + out = self.dut.send_expect( + "flow create 0 priority 1 ingress pattern eth / ipv4 / nvgre / eth / ipv4 src is 192.168.0.2 dst is 192.168.0.3 tos is 4 / udp src is 25 dst is 23 / end actions queue index 3 / end", + "testpmd> ", + ) + self.verify("Failed" in out, "failed: priority is not work") + self.dut.send_expect("quit", "# ") + + def test_priority_in_pipeline_mode(self): + """ + Create Flow Rules with Priority in Pipeline Mode + """ + rules = [ + "flow create 0 priority 0 ingress pattern eth / ipv4 src is 192.168.0.2 dst is 192.168.0.3 tos is 4 / tcp src is 25 dst is 23 / end actions queue index 1 / end", + "flow create 0 priority 0 ingress pattern eth / ipv4 / udp / vxlan / eth / ipv4 src is 192.168.0.2 dst is 192.168.0.3 tos is 4 / udp src is 25 dst is 23 / end actions queue index 2 / end", + "flow create 0 priority 1 ingress pattern eth / ipv4 src is 192.168.0.4 dst is 192.168.0.7 tos is 4 ttl is 20 / tcp src is 25 dst is 23 / end actions queue index 3 / end", + "flow create 0 priority 1 ingress pattern eth / ipv4 / udp / vxlan / eth / ipv4 src is 192.168.0.4 dst is 192.168.0.7 / udp src is 25 dst is 23 / end actions queue index 4 / end", + "flow create 0 ingress pattern eth / ipv4 src is 192.168.1.2 dst is 192.168.0.3 tos is 5 / tcp src is 25 dst is 23 / end actions queue index 1 / end", + "flow create 0 ingress pattern eth / ipv4 src is 192.168.0.2 dst is 192.168.0.3 tos is 4 ttl is 20 / sctp src is 25 dst is 23 / end actions queue index 1 / end", + ] + pkts = [ + 'Ether(dst="00:00:00:00:01:00",src="11:22:33:44:55:66")/IP(src="192.168.0.2",dst="192.168.0.3",tos=4)/TCP(sport=25,dport=23)/Raw("x"*80)', + 'Ether(dst="00:00:00:00:01:00",src="11:22:33:44:55:66")/IP()/UDP()/VXLAN()/Ether()/IP(src="192.168.0.2",dst="192.168.0.3",tos=4)/UDP(sport=25,dport=23)/Raw("x"*80)', + 'Ether(dst="00:00:00:00:01:00",src="11:22:33:44:55:66")/IP(src="192.168.0.4",dst="192.168.0.7",tos=4,ttl=20)/TCP(sport=25,dport=23)/Raw("x"*80)', + 'Ether(dst="00:00:00:00:01:00",src="11:22:33:44:55:66")/IP()/UDP()/VXLAN()/Ether()/IP(src="192.168.0.4",dst="192.168.0.7")/UDP(sport=25,dport=23)/Raw("x"*80)', + ] + # create fdir and switch rules with different priority + rule_list1 = self.process.create_rule( + rules[0:2], check_stats=True, msg="Succeeded to create (2) flow" + ) + rule_list2 = self.process.create_rule( + rules[2:4], check_stats=True, msg="Succeeded to create (1) flow" + ) + rule_list = rule_list1 + rule_list2 + self.process.check_rule(port_id=0, stats=True, rule_list=rule_list) + # send pkts and check the rules are written to different filter tables and the rules can work + self.pmdout.wait_link_status_up(self.dut_ports[0]) + out = self.process.send_pkt_get_out(pkts[0], port_id=0) + self.process.check_rx_packets( + out, check_param={"queue": 1}, expect_pkt=1, stats=True + ) + self.logger.info("pass: queue id is 1") + out = self.process.send_pkt_get_out(pkts[1], port_id=0) + self.process.check_rx_packets( + out, check_param={"queue": 2}, expect_pkt=1, stats=True + ) + self.logger.info("pass: queue id is 2") + out = self.process.send_pkt_get_out(pkts[2], port_id=0) + self.process.check_rx_packets( + out, check_param={"queue": 3}, expect_pkt=1, stats=True + ) + self.logger.info("pass: queue id is 3") + out = self.process.send_pkt_get_out(pkts[3], port_id=0) + self.process.check_rx_packets( + out, check_param={"queue": 4}, expect_pkt=1, stats=True + ) + self.logger.info("pass: queue id is 4") + # create rules without priority, only the pattern supported by switch can be created. + self.process.create_rule( + rules[4], check_stats=True, msg="Succeeded to create (2) flow" + ) + self.process.create_rule(rules[5], check_stats=False) + self.pmdout.execute_cmd("flow flush 0") + + def test_rules_with_same_parameters_different_action_pipeline(self): + """ + Create flow rules with same parameter but different actions + """ + rules = [ + "flow create 0 priority 0 ingress pattern eth / ipv4 src is 192.168.0.2 dst is 192.168.0.3 tos is 4 / tcp src is 25 dst is 23 / end actions queue index 1 / end", + "flow create 0 priority 1 ingress pattern eth / ipv4 src is 192.168.0.2 dst is 192.168.0.3 tos is 4 / tcp src is 25 dst is 23 / end actions queue index 3 / end", + ] + pkts = [ + 'Ether(dst="00:00:00:00:01:00",src="11:22:33:44:55:66")/IP(src="192.168.0.2",dst="192.168.0.3",tos=4)/TCP(sport=25,dport=23)/Raw("x"*80)', + ] + + # create rules with same parameters but different action + rule_list1 = self.process.create_rule( + rules[0], check_stats=True, msg="Succeeded to create (2) flow" + ) + rule_list2 = self.process.create_rule( + rules[1], check_stats=True, msg="Succeeded to create (1) flow" + ) + rule_list = rule_list1 + rule_list2 + self.process.check_rule(port_id=0, stats=True, rule_list=rule_list) + # send a pkt to check the switch rule is work for its high priority + self.pmdout.wait_link_status_up(self.dut_ports[0]) + out = self.process.send_pkt_get_out(pkts[0], port_id=0) + self.process.check_rx_packets( + out, check_param={"queue": 1}, expect_pkt=1, stats=True + ) + self.logger.info("pass: queue id is 1") + # remove the switch rule and check the fdir rule is work + self.process.destroy_rule(port_id=0, rule_id=rule_list1) + out = self.process.send_pkt_get_out(pkts[0], port_id=0) + self.process.check_rx_packets( + out, check_param={"queue": 3}, expect_pkt=1, stats=True + ) + self.logger.info("pass: queue id is 3") + self.pmdout.execute_cmd("flow flush 0") + self.pmdout.quit() + # restart testpmd in pipeline mode + self.launch_testpmd() + # create rules with same parameters but different action + rule_list1 = self.process.create_rule( + rules[1], check_stats=True, msg="Succeeded to create (1) flow" + ) + rule_list2 = self.process.create_rule( + rules[0], check_stats=True, msg="Succeeded to create (2) flow" + ) + rule_list = rule_list1 + rule_list2 + self.process.check_rule(port_id=0, stats=True, rule_list=rule_list) + # send a pkt to check the switch rule is work for its high priority + self.pmdout.wait_link_status_up(self.dut_ports[0]) + self.pmdout.wait_link_status_up(self.dut_ports[0]) + out = self.process.send_pkt_get_out(pkts[0], port_id=0) + self.process.check_rx_packets( + out, check_param={"queue": 1}, expect_pkt=1, stats=True + ) + self.logger.info("pass: queue id is 1") + # remove the switch rule and check the fdir rule is work + self.process.destroy_rule(port_id=0, rule_id=rule_list2) + out = self.process.send_pkt_get_out(pkts[0], port_id=0) + self.process.check_rx_packets( + out, check_param={"queue": 3}, expect_pkt=1, stats=True + ) + self.logger.info("pass: queue id is 3") + self.pmdout.execute_cmd("flow flush 0") + def tear_down(self): """ Run after each test case. """ - self.pmdout.execute_cmd("quit", "# ") + self.pmdout.quit() def tear_down_all(self): """ diff --git a/tests/TestSuite_rteflow_priority.py b/tests/TestSuite_rteflow_priority.py deleted file mode 100644 index 813df85c..00000000 --- a/tests/TestSuite_rteflow_priority.py +++ /dev/null @@ -1,529 +0,0 @@ -# SPDX-License-Identifier: BSD-3-Clause -# Copyright(c) 2019 Intel Corporation -# - -""" -DPDK Test suite. - -Test rte_flow priority -""" - -import imp -import re -import string -import sys -import time -from time import sleep - -from scapy.utils import PcapWriter, socket, struct - -import framework.utils as utils -from framework.pktgen import PacketGeneratorHelper -from framework.pmd_output import PmdOutput -from framework.settings import HEADER_SIZE -from framework.test_case import TestCase - -imp.reload(sys) - - -class TestRteflowPriority(TestCase): - def set_up_all(self): - """ - Run at the start of each test suite. - - PMD prerequisites. - """ - self.dut_ports = self.dut.get_ports(self.nic) - localPort = self.tester.get_local_port(self.dut_ports[0]) - self.__tx_iface = self.tester.get_interface(localPort) - cores = self.dut.get_core_list("1S/5C/1T") - self.coreMask = utils.create_mask(cores) - self.portMask = utils.create_mask([self.dut_ports[0]]) - self.path = self.dut.apps_name["test-pmd"] - - def set_up(self): - """ - Run before each test case. - """ - pass - - # - # Utility methods and other non-test code. - # - ########################################################################### - scapyCmds = [] - - def check_link(self): - # check status in test case, dut and tester both should be up. - self.pmd_output = PmdOutput(self.dut) - res = self.pmd_output.wait_link_status_up("all", timeout=30) - if res is True: - for i in range(15): - out = self.tester.get_port_status(self.dut_ports[0]) - if out == "up": - break - else: - time.sleep(1) - return True - else: - return False - - def send_pkt(self, cmd): - """ - Send packages and verify behavior. - """ - self.tester.scapyCmds.append(cmd) - self.tester.scapy_execute() - - def get_packet_number(self, out, match_string): - """ - get the rx packets number. - """ - - out_lines = out.splitlines() - pkt_num = 0 - for i in range(len(out_lines)): - if match_string in out_lines[i]: - result_scanner = r"RX-packets:\s?(\d+)" - scanner = re.compile(result_scanner, re.DOTALL) - m = scanner.search(out_lines[i + 1]) - pkt_num = int(m.group(1)) - break - return pkt_num - - def check_queue_rx_packets_number(self, out, queue_id): - """ - check the queue rx packets number. - """ - match_string = "------- Forward Stats for RX Port= 0/Queue= %d" % queue_id - pkt_num = self.get_packet_number(out, match_string) - return pkt_num - - # - # test cases. - # - ########################################################################### - - def test_priority_in_pipeline_mode(self): - """ - priority is active in pipeline mode. - """ - # start testpmd in pipeline mode - # genarate eal - command = ( - self.path - + '-c %s -n 4 -a %s,pipeline-mode-support=1 --log-level="ice,7" -- -i --portmask=%s --rxq=10 --txq=10' - % ( - self.coreMask, - self.dut.ports_info[0]["pci"], - utils.create_mask([self.dut_ports[0]]), - ) - ) - out = self.dut.send_expect(command, "testpmd> ", 120) - self.logger.debug(out) - - self.dut.send_expect("set fwd rxonly", "testpmd> ", 15) - self.dut.send_expect("set verbose 1", "testpmd> ", 15) - self.dut.send_expect("rx_vxlan_port add 4789 0", "testpmd> ", 15) - - # create fdir and switch rules with different priority - out = self.dut.send_expect( - "flow create 0 priority 0 ingress pattern eth / ipv4 src is 192.168.0.2 dst is 192.168.0.3 tos is 4 / tcp src is 25 dst is 23 / end actions queue index 1 / end ", - "testpmd>", - 15, - ) - self.verify("Successed" and "(2)" in out, "failed: rule map to wrong filter") - out = self.dut.send_expect( - "flow create 0 priority 0 ingress pattern eth / ipv4 / udp / vxlan / eth / ipv4 src is 192.168.0.2 dst is 192.168.0.3 tos is 4 / udp src is 25 dst is 23 / end actions queue index 2 / end ", - "testpmd>", - 15, - ) - self.verify("Successed" and "(2)" in out, "failed: rule map to wrong filter") - out = self.dut.send_expect( - "flow create 0 priority 1 ingress pattern eth / ipv4 src is 192.168.0.4 dst is 192.168.0.7 tos is 4 ttl is 20 / tcp src is 25 dst is 23 / end actions queue index 3 / end ", - "testpmd>", - 15, - ) - self.verify("Successed" and "(1)" in out, "failed: rule map to wrong filter") - out = self.dut.send_expect( - "flow create 0 priority 1 ingress pattern eth / ipv4 / udp / vxlan / eth / ipv4 src is 192.168.0.4 dst is 192.168.0.7 / udp src is 25 dst is 23 / end actions queue index 4 / end ", - "testpmd>", - 15, - ) - self.verify("Successed" and "(1)" in out, "failed: rule map to wrong filter") - out = self.dut.send_expect("flow list 0", "testpmd> ", 15) - self.logger.info(out) - self.verify("3" in out, "failed: flow rules created error") - - # send pkts and check the rules are written to different filter tables and the rules can work - self.dut.send_expect("start", "testpmd>", 20) - a = self.check_link() - self.verify(a, "failed: link can not up") - self.send_pkt( - 'sendp([Ether(dst="00:00:00:00:01:00",src="11:22:33:44:55:66")/IP(src="192.168.0.2",dst="192.168.0.3",tos=4)/TCP(sport=25,dport=23)/Raw("x"*80)],iface="%s")' - % (self.__tx_iface) - ) - out = self.dut.send_expect("stop", "testpmd>", 20) - pkt_num = self.check_queue_rx_packets_number(out, 1) - self.verify(pkt_num == 1, "failed: the flow rule can not work") - self.logger.info("pass: queue id is 1") - - self.dut.send_expect("start", "testpmd>", 20) - self.send_pkt( - 'sendp([Ether(dst="00:00:00:00:01:00",src="11:22:33:44:55:66")/IP()/UDP()/VXLAN()/Ether()/IP(src="192.168.0.2",dst="192.168.0.3",tos=4)/UDP(sport=25,dport=23)/Raw("x"*80)],iface="%s")' - % (self.__tx_iface) - ) - out = self.dut.send_expect("stop", "testpmd>", 20) - pkt_num = self.check_queue_rx_packets_number(out, 2) - self.verify(pkt_num == 1, "failed: the flow rule can not work") - self.logger.info("pass: queue id is 2") - - self.dut.send_expect("start", "testpmd>", 20) - self.send_pkt( - 'sendp([Ether(dst="00:00:00:00:01:00",src="11:22:33:44:55:66")/IP(src="192.168.0.4",dst="192.168.0.7",tos=4,ttl=20)/TCP(sport=25,dport=23)/Raw("x"*80)],iface="%s")' - % (self.__tx_iface) - ) - out = self.dut.send_expect("stop", "testpmd>", 20) - pkt_num = self.check_queue_rx_packets_number(out, 3) - self.verify(pkt_num == 1, "failed: the flow rule can not work") - self.logger.info("pass: queue id is 3") - - self.dut.send_expect("start", "testpmd>", 20) - self.send_pkt( - 'sendp([Ether(dst="00:00:00:00:01:00",src="11:22:33:44:55:66")/IP()/UDP()/VXLAN()/Ether()/IP(src="192.168.0.4",dst="192.168.0.7")/UDP(sport=25,dport=23)/Raw("x"*80)],iface="%s")' - % (self.__tx_iface) - ) - out = self.dut.send_expect("stop", "testpmd>", 20) - pkt_num = self.check_queue_rx_packets_number(out, 4) - self.verify(pkt_num == 1, "failed: the flow rule can not work") - self.logger.info("pass: queue id is 4") - - # create rules without priority, only the pattern supported by switch can be created. - out = self.dut.send_expect( - "flow create 0 ingress pattern eth / ipv4 src is 192.168.1.2 dst is 192.168.0.3 tos is 5 / tcp src is 25 dst is 23 / end actions queue index 1 / end ", - "testpmd>", - 15, - ) - self.verify("Failed" not in out, "failed: default priority 0 is not work") - out = self.dut.send_expect( - "flow create 0 ingress pattern eth / ipv4 src is 192.168.0.2 dst is 192.168.0.3 tos is 4 ttl is 20 / sctp src is 25 dst is 23 / end actions queue index 1 / end ", - "testpmd>", - 15, - ) - self.verify( - "Failed" in out, - "failed: pattern only support by fdir can not be created in default priority", - ) - - self.dut.send_expect("flow flush 0", "testpmd>", 20) - self.dut.send_expect("quit", "#", 50) - - def test_priority_in_nonpipeline_mode(self): - """ - priority is not active in pipeline mode. - """ - - # start testpmd without pipeline-mode-support parameter, check the testpmd is launch in non-pipeline mode - command = ( - self.path - + '-c %s -n 4 -a %s --log-level="ice,7" -- -i --portmask=%s --rxq=10 --txq=10' - % ( - self.coreMask, - self.dut.ports_info[0]["pci"], - utils.create_mask([self.dut_ports[0]]), - ) - ) - out = self.dut.send_expect(command, "testpmd> ", 120) - self.logger.debug(out) - - out = self.dut.send_expect( - "flow create 0 priority 0 ingress pattern eth / ipv4 src is 192.168.0.2 dst is 192.168.0.3 tos is 4 / end actions queue index 2 / mark / end", - "testpmd>", - 15, - ) - self.verify( - "Successed" and "(1)" in out, "failed: rule can't be created to fdir" - ) - out = self.dut.send_expect( - "flow create 0 priority 1 ingress pattern eth / ipv4 src is 192.168.0.2 dst is 192.168.0.3 tos is 4 / end actions queue index 2 / mark / end", - "testpmd>", - 15, - ) - self.verify( - "Failed" in out, - "failed: default value of priority is 0 in non-pipeline mode", - ) - self.dut.send_expect("flow flush 0", "testpmd>", 20) - self.dut.send_expect("quit", "#", 50) - - # restart testpmd with pipeline-mode-support=0, check the testpmd is launch in non-pipeline mode - command = ( - self.path - + '-c %s -n 4 -a %s,pipeline-mode-support=0 --log-level="ice,7" -- -i --portmask=%s --rxq=10 --txq=10' - % ( - self.coreMask, - self.dut.ports_info[0]["pci"], - utils.create_mask([self.dut_ports[0]]), - ) - ) - out = self.dut.send_expect(command, "testpmd> ", 120) - self.logger.debug(out) - - out = self.dut.send_expect( - "flow create 0 priority 0 ingress pattern eth / ipv4 src is 192.168.0.2 dst is 192.168.0.3 tos is 4 / end actions queue index 2 / mark / end", - "testpmd>", - 15, - ) - self.verify( - "Successed" and "(1)" in out, "failed: rule can't be created to fdir" - ) - out = self.dut.send_expect( - "flow create 0 priority 1 ingress pattern eth / ipv4 src is 192.168.0.2 dst is 192.168.0.3 tos is 4 / end actions queue index 2 / mark / end", - "testpmd>", - 15, - ) - self.verify( - "Failed" in out, - "failed: default value of priority is 0 in non-pipeline mode", - ) - self.dut.send_expect("flow flush 0", "testpmd>", 20) - self.dut.send_expect("quit", "#", 50) - - def test_no_destination_high_prority(self): - """ - no destination high priority rule is not acceptable. - """ - - # start testpmd in pipeline mode - command = ( - self.path - + '-c %s -n 4 -a %s,pipeline-mode-support=1 --log-level="ice,7" -- -i --portmask=%s --rxq=10 --txq=10' - % ( - self.coreMask, - self.dut.ports_info[0]["pci"], - utils.create_mask([self.dut_ports[0]]), - ) - ) - out = self.dut.send_expect(command, "testpmd> ", 120) - self.logger.debug(out) - - # create no destination high priority rules, check the rules can not be created. - out = self.dut.send_expect( - "flow create 0 priority 0 ingress pattern eth / ipv4 src is 192.168.0.2 dst is 192.168.0.3 tos is 4 / tcp src is 25 dst is 23 / end actions / end", - "testpmd>", - 15, - ) - self.verify( - "Bad argument" in out, - "failed: no destination high priority rule is not acceptable", - ) - out = self.dut.send_expect( - "flow create 0 priority 0 ingress pattern eth / ipv4 src is 192.168.0.2 dst is 192.168.0.3 tos is 4 / tcp src is 25 dst is 23 / end", - "testpmd>", - 15, - ) - self.verify( - "Bad argument" in out, - "failed: no destination high priority rule is not acceptable", - ) - self.dut.send_expect("quit", "#", 50) - - def test_create_fdir_rule_with_priority_0(self): - """ - create a rule only supported by fdir filter with priority 0 is not acceptable. - """ - - # start testpmd in pipeline mode - command = ( - self.path - + '-c %s -n 4 -a %s,pipeline-mode-support=1 --log-level="ice,7" -- -i --portmask=%s --rxq=10 --txq=10' - % ( - self.coreMask, - self.dut.ports_info[0]["pci"], - utils.create_mask([self.dut_ports[0]]), - ) - ) - out = self.dut.send_expect(command, "testpmd> ", 120) - self.logger.debug(out) - - # create rules only supported by fdir with priority 0, check the rules can not be created. - out = self.dut.send_expect( - "flow create 0 priority 0 ingress pattern eth / ipv6 src is 1111:2222:3333:4444:5555:6666:7777:8888 dst is 1111:2222:3333:4444:5555:6666:7777:9999 / sctp src is 25 dst is 23 / end actions queue index 1 / end", - "testpmd>", - 15, - ) - self.verify("Failed" in out, "failed: priority is not work") - out = self.dut.send_expect( - "flow create 0 priority 0 ingress pattern eth / ipv4 src is 192.168.0.2 dst is 192.168.0.3 tos is 4 ttl is 20 / sctp src is 25 dst is 23 / end actions queue index 1 / end", - "testpmd>", - 15, - ) - self.verify("Failed" in out, "failed: priority is not work") - self.dut.send_expect("quit", "#", 50) - - def test_create_switch_rule_with_priority_1(self): - """ - create a rule only supported by switch filter with priority 1 is not acceptable. - """ - - # start testpmd in pipeline mode - command = ( - self.path - + '-c %s -n 4 -a %s,pipeline-mode-support=1 --log-level="ice,7" -- -i --portmask=%s --rxq=10 --txq=10' - % ( - self.coreMask, - self.dut.ports_info[0]["pci"], - utils.create_mask([self.dut_ports[0]]), - ) - ) - out = self.dut.send_expect(command, "testpmd> ", 120) - self.logger.debug(out) - - # create rules only supported by switch with priority 1, check the rules can not be created. - out = self.dut.send_expect( - "flow create 0 priority 1 ingress pattern eth / ipv4 / nvgre / eth / ipv4 src is 192.168.0.2 dst is 192.168.0.3 tos is 4 / end actions queue index 3 / end", - "testpmd>", - 15, - ) - self.verify("Failed" in out, "failed: priority is not work") - out = self.dut.send_expect( - "flow create 0 priority 1 ingress pattern eth / ipv4 / nvgre / eth / ipv4 src is 192.168.0.2 dst is 192.168.0.3 tos is 4 / udp src is 25 dst is 23 / end actions queue index 3 / end", - "testpmd>", - 15, - ) - self.verify("Failed" in out, "failed: priority is not work") - self.dut.send_expect("quit", "#", 50) - - def test_rules_with_same_parameters_different_action(self): - """ - it's acceptable to create same rules with different filter in pipeline mode. - """ - - # start testpmd in pipeline mode - command = ( - self.path - + '-c %s -n 4 -a %s,pipeline-mode-support=1 --log-level="ice,7" -- -i --portmask=%s --rxq=10 --txq=10' - % ( - self.coreMask, - self.dut.ports_info[0]["pci"], - utils.create_mask([self.dut_ports[0]]), - ) - ) - out = self.dut.send_expect(command, "testpmd> ", 120) - - self.dut.send_expect("set fwd rxonly", "testpmd> ", 15) - self.dut.send_expect("set verbose 1", "testpmd> ", 15) - - # create rules with same parameters but different action - out = self.dut.send_expect( - "flow create 0 priority 0 ingress pattern eth / ipv4 src is 192.168.0.2 dst is 192.168.0.3 tos is 4 / tcp src is 25 dst is 23 / end actions queue index 1 / end", - "testpmd>", - 15, - ) - self.verify( - "Successed" and "(2)" in out, "failed: switch rule can't be created" - ) - out = self.dut.send_expect( - "flow create 0 priority 1 ingress pattern eth / ipv4 src is 192.168.0.2 dst is 192.168.0.3 tos is 4 / tcp src is 25 dst is 23 / end actions queue index 3 / end", - "testpmd>", - 15, - ) - self.verify("Successed" and "(1)" in out, "failed: fdir rule can't be created") - - # send a pkt to check the switch rule is work for its high priority - self.dut.send_expect("start", "testpmd>", 20) - a = self.check_link() - self.verify(a, "failed: link can not up") - - self.send_pkt( - 'sendp([Ether(dst="00:00:00:00:01:00",src="11:22:33:44:55:01")/IP(src="192.168.0.2",dst="192.168.0.3",tos=4)/TCP(sport=25,dport=23)/Raw("x"*80)],iface="%s")' - % (self.__tx_iface) - ) - out = self.dut.send_expect("stop", "testpmd>", 20) - pkt_num = self.check_queue_rx_packets_number(out, 1) - self.verify(pkt_num == 1, "failed: the flow rule can not work") - self.logger.info("pass: queue id is 1") - - # remove the switch rule and check the fdir rule is work - self.dut.send_expect("flow destroy 0 rule 0", "testpmd>", 15) - self.dut.send_expect("start", "testpmd>", 20) - self.send_pkt( - 'sendp([Ether(dst="00:00:00:00:01:00",src="11:22:33:44:55:02")/IP(src="192.168.0.2",dst="192.168.0.3",tos=4)/TCP(sport=25,dport=23)/Raw("x"*80)],iface="%s")' - % (self.__tx_iface) - ) - out = self.dut.send_expect("stop", "testpmd>", 20) - pkt_num = self.check_queue_rx_packets_number(out, 3) - self.verify(pkt_num == 1, "failed: the flow rule can not work") - self.logger.info("pass: queue id is 3") - - self.dut.send_expect("flow flush 0", "testpmd>", 15) - self.dut.send_expect("quit", "#", 50) - - # restart testpmd in pipeline mode - command = ( - self.path - + '-c %s -n 4 -a %s,pipeline-mode-support=1 --log-level="ice,7" -- -i --portmask=%s --rxq=10 --txq=10' - % ( - self.coreMask, - self.dut.ports_info[0]["pci"], - utils.create_mask([self.dut_ports[0]]), - ) - ) - out = self.dut.send_expect(command, "testpmd> ", 120) - self.logger.debug(out) - - self.dut.send_expect("set fwd rxonly", "testpmd> ", 15) - self.dut.send_expect("set verbose 1", "testpmd> ", 15) - - # create rules with same parameters but different action - out = self.dut.send_expect( - "flow create 0 priority 1 ingress pattern eth / ipv4 src is 192.168.0.2 dst is 192.168.0.3 tos is 4 / tcp src is 25 dst is 23 / end actions queue index 3 / end", - "testpmd>", - 15, - ) - self.verify("Successed" and "(1)" in out, "failed: fdir rule can't be created") - out = self.dut.send_expect( - "flow create 0 priority 0 ingress pattern eth / ipv4 src is 192.168.0.2 dst is 192.168.0.3 tos is 4 / tcp src is 25 dst is 23 / end actions queue index 1 / end", - "testpmd>", - 15, - ) - self.verify( - "Successed" and "(2)" in out, "failed: switch rule can't be created" - ) - - # send a pkt to check the switch rule is work for its high priority - self.dut.send_expect("start", "testpmd>", 20) - a = self.check_link() - self.verify(a, "failed: link can not up") - self.send_pkt( - 'sendp([Ether(dst="00:00:00:00:01:00",src="11:22:33:44:55:01")/IP(src="192.168.0.2",dst="192.168.0.3",tos=4)/TCP(sport=25,dport=23)/Raw("x"*80)],iface="%s")' - % (self.__tx_iface) - ) - out = self.dut.send_expect("stop", "testpmd>", 20) - pkt_num = self.check_queue_rx_packets_number(out, 1) - self.verify(pkt_num == 1, "failed: the flow rule can not work") - self.logger.info("pass: queue id is 1") - - # remove the switch rule and check the fdir rule is work - self.dut.send_expect("flow destroy 0 rule 1", "testpmd>", 15) - self.dut.send_expect("start", "testpmd>", 20) - self.send_pkt( - 'sendp([Ether(dst="00:00:00:00:01:00",src="11:22:33:44:55:02")/IP(src="192.168.0.2",dst="192.168.0.3",tos=4)/TCP(sport=25,dport=23)/Raw("x"*80)],iface="%s")' - % (self.__tx_iface) - ) - out = self.dut.send_expect("stop", "testpmd>", 20) - pkt_num = self.check_queue_rx_packets_number(out, 3) - self.verify(pkt_num == 1, "failed: the flow rule can not work") - self.logger.info("pass: queue id is 3") - - self.dut.send_expect("flow flush 0", "testpmd>", 20) - self.dut.send_expect("quit", "#", 50) - - # - ########################################################################### - - def tear_down_all(self): - pass - - def tear_down(self): - self.dut.kill_all()