From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mga05.intel.com (mga05.intel.com [192.55.52.43]) by dpdk.org (Postfix) with ESMTP id ADEA31B122 for ; Tue, 29 Jan 2019 10:23:04 +0100 (CET) X-Amp-Result: SKIPPED(no attachment in message) X-Amp-File-Uploaded: False Received: from fmsmga006.fm.intel.com ([10.253.24.20]) by fmsmga105.fm.intel.com with ESMTP/TLS/DHE-RSA-AES256-GCM-SHA384; 29 Jan 2019 01:23:03 -0800 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.56,536,1539673200"; d="scan'208";a="314457211" Received: from fmsmsx105.amr.corp.intel.com ([10.18.124.203]) by fmsmga006.fm.intel.com with ESMTP; 29 Jan 2019 01:23:03 -0800 Received: from fmsmsx120.amr.corp.intel.com (10.18.124.208) by FMSMSX105.amr.corp.intel.com (10.18.124.203) with Microsoft SMTP Server (TLS) id 14.3.408.0; Tue, 29 Jan 2019 01:23:03 -0800 Received: from shsmsx154.ccr.corp.intel.com (10.239.6.54) by fmsmsx120.amr.corp.intel.com (10.18.124.208) with Microsoft SMTP Server (TLS) id 14.3.408.0; Tue, 29 Jan 2019 01:22:47 -0800 Received: from shsmsx101.ccr.corp.intel.com ([169.254.1.110]) by SHSMSX154.ccr.corp.intel.com ([169.254.7.232]) with mapi id 14.03.0415.000; Tue, 29 Jan 2019 17:22:45 +0800 From: "Tu, Lijuan" To: "Peng, Yuan" , "dts@dpdk.org" CC: "Peng, Yuan" Thread-Topic: [dts] [PATCH v4 1/2]tests: add script for flow_classify_softnic Thread-Index: AQHUtMpIbAXjN+0llUSQoW9l794x1aXF/rsw Date: Tue, 29 Jan 2019 09:22:45 +0000 Message-ID: <8CE3E05A3F976642AAB0F4675D0AD20E0BA1E5CB@SHSMSX101.ccr.corp.intel.com> References: <1548433596-36881-1-git-send-email-yuan.peng@intel.com> In-Reply-To: <1548433596-36881-1-git-send-email-yuan.peng@intel.com> Accept-Language: zh-CN, en-US Content-Language: en-US X-MS-Has-Attach: X-MS-TNEF-Correlator: dlp-product: dlpe-windows dlp-version: 11.0.400.15 dlp-reaction: no-action x-ctpclassification: CTP_NT x-titus-metadata-40: eyJDYXRlZ29yeUxhYmVscyI6IiIsIk1ldGFkYXRhIjp7Im5zIjoiaHR0cDpcL1wvd3d3LnRpdHVzLmNvbVwvbnNcL0ludGVsMyIsImlkIjoiODllYzZlNjYtYzZjMy00NTFkLTgwMjAtNWU3ZmY0ZDA0MzY0IiwicHJvcHMiOlt7Im4iOiJDVFBDbGFzc2lmaWNhdGlvbiIsInZhbHMiOlt7InZhbHVlIjoiQ1RQX05UIn1dfV19LCJTdWJqZWN0TGFiZWxzIjpbXSwiVE1DVmVyc2lvbiI6IjE3LjEwLjE4MDQuNDkiLCJUcnVzdGVkTGFiZWxIYXNoIjoieDIxOWVrUDRLb1Jza2dyaVo1b2pIT1wvMUlhZUR5SDdxZ1UyN0hQY28yTUVHZFc1ZUpjY1hEekgzNTRYaitFdHQifQ== x-originating-ip: [10.239.127.40] Content-Type: text/plain; charset="us-ascii" Content-Transfer-Encoding: quoted-printable MIME-Version: 1.0 Subject: Re: [dts] [PATCH v4 1/2]tests: add script for flow_classify_softnic X-BeenThere: dts@dpdk.org X-Mailman-Version: 2.1.15 Precedence: list List-Id: test suite reviews and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-List-Received-Date: Tue, 29 Jan 2019 09:23:05 -0000 Applied, thanks > -----Original Message----- > From: dts [mailto:dts-bounces@dpdk.org] On Behalf Of Peng Yuan > Sent: Saturday, January 26, 2019 12:27 AM > To: dts@dpdk.org > Cc: Peng, Yuan > Subject: [dts] [PATCH v4 1/2]tests: add script for flow_classify_softnic >=20 > Add TestSuite_flow_classify_softnic.py to tests. >=20 > Signed-off-by: Peng Yuan >=20 > diff --git a/tests/TestSuite_flow_classify_softnic.py > b/tests/TestSuite_flow_classify_softnic.py > new file mode 100644 > index 0000000..66db5c3 > --- /dev/null > +++ b/tests/TestSuite_flow_classify_softnic.py > @@ -0,0 +1,1358 @@ > +# BSD LICENSE > +# > +# Copyright(c) 2010-2018 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. > + > +import utils > +import re > +import time > + > +from settings import HEADER_SIZE > +from test_case import TestCase > +from pmd_output import PmdOutput > +from settings import DRIVERS > +from crb import Crb > + > +from virt_dut import VirtDut > +from project_dpdk import DPDKdut > +from dut import Dut > +from packet import Packet > + > +import os > +import random > +from exception import VerifyFailure > +import scapy.layers.inet > +from scapy.utils import rdpcap > + > +from time import sleep > +from scapy.utils import wrpcap, rdpcap, hexstr > +from scapy.layers.inet import Ether, IP, TCP, UDP, ICMP > +from scapy.layers.inet6 import IPv6 > +from scapy.layers.l2 import Dot1Q, ARP, GRE > +from scapy.layers.sctp import SCTP, SCTPChunkData > +from scapy.route import * > +from scapy.packet import bind_layers, Raw > +from scapy.arch import get_if_hwaddr > +from scapy.sendrecv import sniff > +from scapy.sendrecv import sendp > + > + > +class TestFlowClassifySoftnic(TestCase): > + > + def copy_config_files_to_dut(self): > + """ > + Copy firmware.cli from tester to DUT. > + """ > + file =3D 'flow_classify_softnic.tar.gz' > + src_file =3D r'./dep/%s' % file > + dst1 =3D '/tmp' > + dst2 =3D '/root/dpdk/drivers/net/softnic' > + self.dut.session.copy_file_to(src_file, dst1) > + self.dut.send_expect("tar xf %s/%s -C %s" % (dst1, file, dst2), = "#", 30) > + > + def start_testpmd(self, filename, port_num): > + """ > + Start testpmd. > + """ > + self.set_ports(filename, port_num) > + TESTPMD =3D "./%s/app/testpmd" % self.target > + VDEV =3D "--vdev > 'net_softnic0,firmware=3D./drivers/net/softnic/flow_classify_softnic/%s,c= pu_id=3D1 > ,conn_port=3D8086'" % filename > + if port_num =3D=3D 4: > + DUT_PORTS =3D " -w {0} -w {1} -w {2} -w {3} "\ > + .format(self.dut_p0_pci, self.dut_p1_pci, self.d= ut_p2_pci, > self.dut_p3_pci) > + cmd =3D "{0} -c 0x1f -s 0x10 -n 4 {1} {2} -- -i --rxq=3D4 --= txq=3D4 --disable-rss -- > portmask=3D0x10".format(TESTPMD, DUT_PORTS, VDEV) > + elif port_num =3D=3D 2: > + DUT_PORTS =3D " -w {0} -w {1} "\ > + .format(self.dut_p0_pci, self.dut_p1_pci) > + cmd =3D "{0} -c 0x7 -s 0x4 -n 4 {1} {2} -- -i --rxq=3D2 --tx= q=3D2 --disable-rss -- > portmask=3D0x4".format(TESTPMD, DUT_PORTS, VDEV) > + else: > + raise Exception("The number of port is wrong!") > + self.dut.send_expect(cmd, "testpmd> ", 60) > + > + def set_ports(self, filename, port_num): > + """ > + Set actual ports. > + """ > + self.dut.send_expect("sed -i '/^link > LINK/d' ./drivers/net/softnic/flow_classify_softnic/%s" % filename, "# ",= 20) > + cmd =3D "sed -i '1i\link LINK0 > dev %s' ./drivers/net/softnic/flow_classify_softnic/%s" % (self.dut_p0_pc= i, > filename) > + self.dut.send_expect(cmd, "# ", 20) > + cmd =3D "sed -i '2i\link LINK1 > dev %s' ./drivers/net/softnic/flow_classify_softnic/%s" % (self.dut_p1_pc= i, > filename) > + self.dut.send_expect(cmd, "# ", 20) > + if port_num =3D=3D 4: > + cmd =3D "sed -i '3i\link LINK2 > dev %s' ./drivers/net/softnic/flow_classify_softnic/%s" % (self.dut_p2_pc= i, > filename) > + self.dut.send_expect(cmd, "# ", 20) > + cmd =3D "sed -i '4i\link LINK3 > dev %s' ./drivers/net/softnic/flow_classify_softnic/%s" % (self.dut_p3_pc= i, > filename) > + self.dut.send_expect(cmd, "# ", 20) > + > + def set_table(self, cmd, filename): > + """ > + Set pipeline table. > + """ > + self.dut.send_expect("sed -i '/^pipeline RX table > match/d' ./drivers/net/softnic/flow_classify_softnic/%s" % filename, "# "= , 20) > + command =3D "sed -i \'/^table action/a" + cmd + > "\' ./drivers/net/softnic/flow_classify_softnic/%s" % filename > + self.dut.send_expect(command, "# ", 20) > + > + def tcpdump_start_sniff(self, interface, filters=3D""): > + """ > + Starts tcpdump in the background to sniff packets that received = by > interface. > + """ > + command =3D 'rm -f /tmp/tcpdump_{0}.pcap'.format(interface) > + self.tester.send_expect(command, '#') > + command =3D 'tcpdump -n -e -Q in -w /tmp/tcpdump_{0}.pcap -i {0}= {1} > 2>/tmp/tcpdump_{0}.out &'\ > + .format(interface, filters) > + self.tester.send_expect(command, '# ') > + > + def tcpdump_stop_sniff(self): > + """ > + Stops the tcpdump process running in the background. > + """ > + self.tester.send_expect('killall tcpdump', '# ') > + # For the [pid]+ Done tcpdump... message after killing the proce= ss > + sleep(1) > + self.tester.send_expect('echo "Cleaning buffer"', '# ') > + sleep(1) > + > + def write_pcap_file(self, pcap_file, pkts): > + try: > + wrpcap(pcap_file, pkts) > + except: > + raise Exception("write pcap error") > + > + def read_pcap_file(self, pcap_file): > + pcap_pkts =3D [] > + try: > + pcap_pkts =3D rdpcap(pcap_file) > + except: > + raise Exception("write pcap error") > + > + return pcap_pkts > + > + def send_and_sniff_pkts(self, from_port, to_port, pcap_file, filters= =3D"", > count=3D1): > + """ > + Sent pkts that read from the pcap_file. > + Return the sniff pkts. > + """ > + tx_port =3D > self.tester.get_local_port(self.dut_ports[from_port%self.port_num]) > + rx_port =3D > self.tester.get_local_port(self.dut_ports[to_port%self.port_num]) > + > + tx_interface =3D self.tester.get_interface(tx_port) > + rx_interface =3D self.tester.get_interface(rx_port) > + > + self.tcpdump_start_sniff(rx_interface, filters) > + > + # Prepare the pkts to be sent > + self.tester.scapy_foreground() > + self.tester.scapy_append('pkt =3D rdpcap("%s")' % (pcap_file)) > + self.tester.scapy_append('sendp(pkt, iface=3D"%s", count=3D%d)' = % > (tx_interface, count)) > + self.tester.scapy_execute() > + > + self.tcpdump_stop_sniff() > + > + return self.read_pcap_file('/tmp/tcpdump_%s.pcap' % rx_interface= ) > + > + def send_pkts(self, from_port, pcap_file, count=3D1): > + """ > + Sent pkts that read from the pcap_file. > + """ > + tx_port =3D self.tester.get_local_port(self.dut_ports[from_port]= ) > + tx_interface =3D self.tester.get_interface(tx_port) > + > + # Prepare the pkts to be sent > + self.tester.scapy_foreground() > + self.tester.scapy_append('pkt =3D rdpcap("%s")' % (pcap_file)) > + self.tester.scapy_append('sendp(pkt, iface=3D"%s", count=3D%d)' = % > (tx_interface, count)) > + self.tester.scapy_execute() > + > + def send_and_check_packets(self, pcap_file, pkt, ltype, src_dst, add= r_port, > from_port, to_port): > + """ > + Sent pkts that read from the pcap_file. > + Check if the rule works. > + """ > + self.write_pcap_file(pcap_file, pkt) > + if ltype in ["udp", "tcp", "sctp"]: > + filters =3D "%s %s port %d" % (ltype, src_dst, addr_port) > + sniff_pkts =3D self.send_and_sniff_pkts(from_port, to_port, = pcap_file, > filters) > + checklist =3D [] > + for packet in sniff_pkts: > + if src_dst =3D=3D "src": > + checklist.append(packet.getlayer(2).sport) > + elif src_dst =3D=3D "dst": > + checklist.append(packet.getlayer(2).dport) > + elif ltype in ["ipv4", "ipv6"]: > + filters =3D "%s host %s" % (src_dst, addr_port) > + sniff_pkts =3D self.send_and_sniff_pkts(from_port, to_port, = pcap_file, > filters) > + checklist =3D [] > + for packet in sniff_pkts: > + if src_dst =3D=3D "src": > + checklist.append(packet.getlayer(1).src) > + elif src_dst =3D=3D "dst": > + checklist.append(packet.getlayer(1).dst) > + addr_port =3D str.lower(addr_port) > + self.verify(addr_port in checklist, "rule test fail") > + > + def check_status(self, rx_pkt_num, tx_pkt_num, port): > + """ > + Check port status > + """ > + rx_num =3D 0 > + tx_num =3D 0 > + for i in range(port): > + stats =3D self.pmdout.get_pmd_stats(self.dut_ports[i]) > + rx_num =3D rx_num + stats['RX-packets'] > + tx_num =3D tx_num + stats['TX-packets'] > + self.verify((rx_num =3D=3D rx_pkt_num) and (tx_num =3D=3D tx_pkt= _num), "The rule > failed to work") > + > + def generate_rules(self, operation=3D"create", port=3D4, group=3D0, = iptype=3D"ipv4", > src_mask=3D"0.0.0.0", dst_mask=3D"0.0.0.0", src_spec=3D"0.0.0.0", dst_spe= c=3D"0.0.0.0", > protomask=3D0, protospec=3D17, l4type=3D"udp", sportmask=3D0, dportmask= =3D0, > sportspec=3D0, dportspec=3D0, action=3D"queue", index=3D[]): > + """ > + Generate flow rules > + """ > + if port =3D=3D 4: > + port =3D self.port_num > + if iptype =3D=3D "ipv6": > + if src_mask =3D=3D "0.0.0.0": > + src_mask =3D "0:0:0:0:0:0:0:0" > + if dst_mask =3D=3D "0.0.0.0": > + dst_mask =3D "0:0:0:0:0:0:0:0" > + if src_spec =3D=3D "0.0.0.0": > + src_spec =3D "0:0:0:0:0:0:0:0" > + if dst_spec =3D=3D "0.0.0.0": > + dst_spec =3D "0:0:0:0:0:0:0:0" > + if action =3D=3D "queue": > + actions =3D "queue index %d" % (index[0]%port) > + elif action =3D=3D "jump": > + actions =3D "jump group %d" % (index[0]%port) > + elif action =3D=3D "rss": > + queue_idx =3D "" > + for queue in index: > + queue_idx =3D queue_idx + str(queue%port) + " " > + actions =3D "rss queues %s end" % queue_idx > + > + if l4type =3D=3D "": > + self.dut.send_expect("flow %s %d group %d ingress pattern et= h / %s > proto mask %d src mask %s dst mask %s src spec %s dst spec %s / end actio= ns %s > / end" % (operation, port, group, iptype, protomask, src_mask, dst_mask, > src_spec, dst_spec, actions), operation, 60) > + else: > + self.dut.send_expect("flow %s %d group %d ingress pattern et= h / %s > proto mask %d src mask %s dst mask %s src spec %s dst spec %s proto spec = %d > / %s src mask %d dst mask %d src spec %d dst spec %d / end actions %s / e= nd" % > (operation, port, group, iptype, protomask, src_mask, dst_mask, src_spec, > dst_spec, protospec, l4type, sportmask, dportmask, sportspec, dportspec, > actions), operation, 60) > + > + def send_continuous_packet(self, ptype, src_dst, src_addr, dst_addr,= itf): > + """ > + Sends continuous packets. > + """ > + self.tester.scapy_foreground() > + time.sleep(2) > + if src_dst =3D=3D "src": > + if ptype =3D=3D "ipv4": > + var =3D src_addr.split(".") > + string =3D "." > + ipaddr =3D string.join(var[0:3]) > + for i in range(32): > + packet =3D r'sendp([Ether(dst=3D"%s", > src=3Dget_if_hwaddr("%s"))/IP(src=3D"%s.%d", dst=3D"%s", proto=3D17)/UDP(= sport=3D100, > dport=3D200)], iface=3D"%s")' % ( > + self.dut_p0_mac, itf, ipaddr, i, dst_addr, itf) > + self.tester.scapy_append(packet) > + self.tester.scapy_execute() > + elif ptype =3D=3D "ipv6": > + var =3D src_addr.split(":") > + string =3D ":" > + if len(var) =3D=3D 8: > + ipaddr =3D string.join(var[0:7]) > + else: > + ipaddr =3D string.join(var[0:(len(var) - 1)]) > + for i in range(16): > + packet =3D r'sendp([Ether(dst=3D"%s", > src=3Dget_if_hwaddr("%s"))/IPv6(src=3D"%s:%d", dst=3D"%s", nh=3D17)/UDP(s= port=3D100, > dport=3D200)], iface=3D"%s")' % ( > + self.dut_p0_mac, itf, ipaddr, i, dst_addr, itf) > + self.tester.scapy_append(packet) > + self.tester.scapy_execute() > + > + elif src_dst =3D=3D "dst": > + if ptype =3D=3D "ipv4": > + var =3D dst_addr.split(".") > + string =3D "." > + ipaddr =3D string.join(var[0:3]) > + for i in range(32): > + packet =3D r'sendp([Ether(dst=3D"%s", > src=3Dget_if_hwaddr("%s"))/IP(src=3D"%s", dst=3D"%s.%d", proto=3D17)/UDP(= sport=3D100, > dport=3D100)], iface=3D"%s")' % ( > + self.dut_p0_mac, itf, src_addr, ipaddr, i, itf) > + self.tester.scapy_append(packet) > + self.tester.scapy_execute() > + elif ptype =3D=3D "ipv6": > + var =3D dst_addr.split(":") > + string =3D ":" > + if len(var) =3D=3D 8: > + ipaddr =3D string.join(var[0:7]) > + else: > + ipaddr =3D string.join(var[0:(len(var) - 1)]) > + for i in range(16): > + packet =3D r'sendp([Ether(dst=3D"%s", > src=3Dget_if_hwaddr("%s"))/IPv6(src=3D"%s", dst=3D"%s:%d", nh=3D17)/UDP(s= port=3D100, > dport=3D200)], iface=3D"%s")' % ( > + self.dut_p0_mac, itf, src_addr, ipaddr, i, itf) > + self.tester.scapy_append(packet) > + self.tester.scapy_execute() > + > + def check_packet_queue(self, queues=3D[], out=3D""): > + """ > + Get the queue which packet enter. > + """ > + time.sleep(2) > + for queue in queues: > + self.verify("Queue=3D %d" % (queue%self.port_num) in out, "T= here is some > queues doesn't work.") > + lines =3D out.split("\r\n") > + reta_line =3D {} > + queue_flag =3D 0 > + # collect the hash result and the queue id > + for line in lines: > + line =3D line.strip() > + if queue_flag =3D=3D 1: > + result_scanner =3D r"RX-packets:\s?([0-9]+)" > + scanner =3D re.compile(result_scanner, re.DOTALL) > + m =3D scanner.search(line) > + rxpkt_num =3D m.group(1) > + result_scanner =3D r"TX-packets:\s?([0-9]+)" > + scanner =3D re.compile(result_scanner, re.DOTALL) > + m =3D scanner.search(line) > + txpkt_num =3D m.group(1) > + self.verify(rxpkt_num =3D=3D txpkt_num, "There are some = packets failed to > forward.") > + queue_flag =3D 0 > + elif line.strip().startswith("------- Forward"): > + queue_flag =3D 1 > + > + def set_up_all(self): > + """ > + Run at the start of each test suite. > + """ > + self.dut_ports =3D self.dut.get_ports() > + self.port_num =3D len(self.dut_ports) > + self.verify(self.port_num =3D=3D 2 or self.port_num =3D=3D 4, > + "Insufficient ports for speed testing") > + > + self.dut_p0_pci =3D self.dut.get_port_pci(self.dut_ports[0]) > + self.dut_p1_pci =3D self.dut.get_port_pci(self.dut_ports[1]) > + self.dut_p0_mac =3D self.dut.get_mac_address(self.dut_ports[0]) > + self.dut_p1_mac =3D self.dut.get_mac_address(self.dut_ports[1]) > + self.pf0_interface =3D self.dut.ports_info[self.dut_ports[0]]['i= ntf'] > + self.pf1_interface =3D self.dut.ports_info[self.dut_ports[1]]['i= ntf'] > + > + if self.port_num =3D=3D 4: > + self.dut_p2_pci =3D self.dut.get_port_pci(self.dut_ports[2]) > + self.dut_p3_pci =3D self.dut.get_port_pci(self.dut_ports[3]) > + self.dut_p2_mac =3D self.dut.get_mac_address(self.dut_ports[= 2]) > + self.dut_p3_mac =3D self.dut.get_mac_address(self.dut_ports[= 3]) > + self.pf2_interface =3D self.dut.ports_info[self.dut_ports[2]= ]['intf'] > + self.pf3_interface =3D self.dut.ports_info[self.dut_ports[3]= ]['intf'] > + > + self.ipv4_mask =3D "255.255.255.255" > + self.ipv6_mask =3D "ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff" > + self.portmask =3D 65535 > + self.protomask =3D 255 > + > + self.pmdout =3D PmdOutput(self.dut) > + localPort =3D self.tester.get_local_port(self.dut_ports[0]) > + self.tester_itf =3D self.tester.get_interface(localPort) > + self.copy_config_files_to_dut() > + > + def set_up(self): > + """ > + Run before each test case. > + """ > + pass > + > + def test_ipv4_acl_table(self): > + """ > + Ipv4 ACL table > + """ > + filename =3D "flow_ipv4_acl_firmware.cli" > + self.start_testpmd(filename, self.port_num) > + > + # validate rule > + self.generate_rules(operation=3D"validate", dst_mask=3D"255.192.= 0.0", > dst_spec=3D"2.0.0.0", sportspec=3D100, dportspec=3D200, index=3D[3]) > + > + # create rule > + self.generate_rules(dst_mask=3D"255.192.0.0", dst_spec=3D"2.0.0.= 0", > protomask=3Dself.protomask, sportmask=3Dself.portmask, dportmask=3Dself.p= ortmask, > sportspec=3D100, dportspec=3D200, index=3D[3]) > + self.generate_rules(dst_mask=3D"255.192.0.0", dst_spec=3D"2.64.0= .0", > protomask=3Dself.protomask, protospec=3D6, l4type=3D"tcp", > sportmask=3Dself.portmask, dportmask=3Dself.portmask, sportspec=3D100, > dportspec=3D200, index=3D[2]) > + self.generate_rules(src_mask=3D"255.192.0.0", src_spec=3D"2.128.= 0.0", > protomask=3Dself.protomask, protospec=3D132, l4type=3D"sctp", > sportmask=3Dself.portmask, dportmask=3Dself.portmask, sportspec=3D100, > dportspec=3D200, index=3D[1]) > + self.generate_rules(dst_mask=3D"255.192.0.0", dst_spec=3D"4.0.0.= 0", > protomask=3Dself.protomask, sportspec=3D100, sportmask=3Dself.portmask, > dportmask=3Dself.portmask, dportspec=3D200, index=3D[0]) > + self.dut.send_expect("start", "testpmd> ", 60) > + > + # rule 0 test > + pcap_file =3D '/tmp/route_0.pcap' > + pkt =3D [Ether(dst=3Dself.dut_p0_mac)/IP(src=3D'0.0.0.0', dst=3D= '2.0.0.0', > proto=3D17)/UDP(sport=3D100, dport=3D200)/('X'*48)] > + self.send_and_check_packets(pcap_file, pkt, "ipv4", "dst", "2.0.= 0.0", 0, 3) > + > + # rule 1 test > + pcap_file =3D '/tmp/route_1.pcap' > + pkt =3D [Ether(dst=3Dself.dut_p0_mac)/IP(src=3D'0.0.0.0', dst=3D= '2.64.0.0', > proto=3D6)/TCP(sport=3D100, dport=3D200)/('X'*48)] > + self.send_and_check_packets(pcap_file, pkt, "ipv4", "dst", "2.64= .0.0", 0, 2) > + > + # rule 2 test > + pcap_file =3D '/tmp/route_2.pcap' > + pkt =3D [Ether(dst=3Dself.dut_p0_mac)/IP(src=3D'2.128.0.0', dst= =3D'0.0.0.0', > proto=3D132)/SCTP(sport=3D100, dport=3D200)/('X'*48)] > + self.send_and_check_packets(pcap_file, pkt, "ipv4", "src", "2.12= 8.0.0", 0, 1) > + > + # rule 3 test > + pcap_file =3D '/tmp/route_3.pcap' > + pkt =3D [Ether(dst=3Dself.dut_p0_mac)/IP(src=3D'0.0.0.0', dst=3D= '4.0.0.0', > proto=3D17)/UDP(sport=3D100, dport=3D200)/('X'*48)] > + self.send_and_check_packets(pcap_file, pkt, "ipv4", "dst", "4.0.= 0.0", 0, 0) > + > + # send another 3 packets > + pcap_file =3D '/tmp/route_4.pcap' > + pkt =3D [Ether(dst=3Dself.dut_p0_mac)/IP(src=3D'0.0.0.0', dst=3D= '3.0.0.0', > proto=3D17)/UDP(sport=3D100, dport=3D200)/('X'*48)] > + self.write_pcap_file(pcap_file, pkt) > + self.send_pkts(0, pcap_file) > + > + pcap_file =3D '/tmp/route_4.pcap' > + pkt =3D [Ether(dst=3Dself.dut_p0_mac)/IP(src=3D'0.0.0.0', dst=3D= '2.64.0.0', > proto=3D17)/UDP(sport=3D100, dport=3D200)/('X'*48)] > + self.write_pcap_file(pcap_file, pkt) > + self.send_pkts(0, pcap_file) > + > + pcap_file =3D '/tmp/route_4.pcap' > + pkt =3D [Ether(dst=3Dself.dut_p0_mac)/IP(src=3D'2.128.0.0', dst= =3D'0.0.0.0', > proto=3D17)/UDP(sport=3D100, dport=3D200)/('X'*48)] > + self.write_pcap_file(pcap_file, pkt) > + self.send_pkts(0, pcap_file) > + > + self.check_status(7, 4, self.port_num) > + > + # query rule > + out =3D self.dut.send_expect("flow query %d 3 queue" % self.port= _num, > "QUEUE", 60) > + > + # destroy rule 1 > + self.dut.send_expect("flow destroy %d rule 1" % self.port_num, "= Flow rule > #1 destroyed", 60) > + destroy_out =3D self.dut.send_expect("flow list %d" % self.port_= num, > "testpmd> ", 60) > + self.verify("1" not in destroy_out, "destroy rule fail") > + > + # rule 1 test > + pcap_file =3D '/tmp/route_1.pcap' > + pkt =3D [Ether(dst=3Dself.dut_p0_mac)/IP(src=3D'0.0.0.0', dst=3D= '2.64.0.0', > proto=3D6)/TCP(sport=3D100, dport=3D200)/('X'*48)] > + self.write_pcap_file(pcap_file, pkt) > + filters =3D "dst host 2.64.0.0" > + sniff_pkts =3D self.send_and_sniff_pkts(0, 2, pcap_file, filters= ) > + dst_ip_list =3D [] > + for packet in sniff_pkts: > + dst_ip_list.append(packet.getlayer(1).dst) > + self.verify("2.64.0.0" not in dst_ip_list, "rule 1 test fail") > + > + # flush rules > + self.dut.send_expect("flow flush %d" % self.port_num, "testpmd> = ", 60) > + flush_out =3D self.dut.send_expect("flow list %d" % self.port_nu= m, "testpmd> > ", 60) > + self.verify("Rule" not in flush_out, "flush rule fail") > + self.dut.send_expect("clear port stats all", "testpmd> ", 60) > + > + # test all the rules > + pcap_file =3D '/tmp/route_4.pcap' > + pkt =3D [Ether(dst=3Dself.dut_p0_mac)/IP(src=3D'0.0.0.0', dst=3D= '2.0.0.0', > proto=3D17)/UDP(sport=3D100, dport=3D200)/('X'*48)] > + self.write_pcap_file(pcap_file, pkt) > + self.send_pkts(0, pcap_file) > + > + pcap_file =3D '/tmp/route_4.pcap' > + pkt =3D [Ether(dst=3Dself.dut_p0_mac)/IP(src=3D'0.0.0.0', dst=3D= '2.64.0.0', > proto=3D6)/TCP(sport=3D100, dport=3D200)/('X'*48)] > + self.write_pcap_file(pcap_file, pkt) > + self.send_pkts(0, pcap_file) > + > + pcap_file =3D '/tmp/route_4.pcap' > + pkt =3D [Ether(dst=3Dself.dut_p0_mac)/IP(src=3D'2.128.0.0', dst= =3D'0.0.0.0', > proto=3D132)/SCTP(sport=3D100, dport=3D200)/('X'*48)] > + self.write_pcap_file(pcap_file, pkt) > + self.send_pkts(0, pcap_file) > + > + pcap_file =3D '/tmp/route_4.pcap' > + pkt =3D [Ether(dst=3Dself.dut_p0_mac)/IP(src=3D'0.0.0.0', dst=3D= '4.0.0.0', > proto=3D17)/UDP(sport=3D100, dport=3D200)/('X'*48)] > + self.write_pcap_file(pcap_file, pkt) > + self.send_pkts(0, pcap_file) > + > + self.check_status(4, 0, self.port_num) > + self.dut.send_expect("quit", "# ", 60) > + > + def test_ipv4_5tuple_hash_table(self): > + """ > + Ipv4 5tuple hash table > + """ > + filename =3D "flow_ipv4_5tuple_hash_firmware.cli" > + self.start_testpmd(filename, self.port_num) > + > + # create rule > + self.generate_rules(src_mask=3Dself.ipv4_mask, dst_mask=3Dself.i= pv4_mask, > src_spec=3D"100.0.0.1", dst_spec=3D"200.0.0.1", protomask=3Dself.protomas= k, > protospec=3D6, l4type=3D"tcp", sportmask=3Dself.portmask, dportmask=3Dsel= f.portmask, > sportspec=3D101, dportspec=3D201, index=3D[3]) > + self.generate_rules(src_mask=3Dself.ipv4_mask, dst_mask=3Dself.i= pv4_mask, > src_spec=3D"100.0.0.2", dst_spec=3D"200.0.0.2", protomask=3Dself.protomas= k, > sportmask=3Dself.portmask, dportmask=3Dself.portmask, sportspec=3D102, > dportspec=3D202, index=3D[2]) > + self.generate_rules(src_mask=3Dself.ipv4_mask, dst_mask=3Dself.i= pv4_mask, > src_spec=3D"100.0.0.3", dst_spec=3D"200.0.0.3", protomask=3Dself.protomas= k, > protospec=3D132, l4type=3D"sctp", sportmask=3Dself.portmask, > dportmask=3Dself.portmask, sportspec=3D103, dportspec=3D203, index=3D[1]) > + self.generate_rules(src_mask=3Dself.ipv4_mask, dst_mask=3Dself.i= pv4_mask, > src_spec=3D"100.0.0.4", dst_spec=3D"200.0.0.4", protomask=3Dself.protomas= k, > sportmask=3Dself.portmask, dportmask=3Dself.portmask, sportspec=3D104, > dportspec=3D204, index=3D[0]) > + self.dut.send_expect("start", "testpmd> ", 60) > + > + # rule 0 test > + pcap_file =3D '/tmp/route_0.pcap' > + pkt =3D [Ether(dst=3Dself.dut_p0_mac)/IP(src=3D'100.0.0.1', dst= =3D'200.0.0.1', > proto=3D6)/TCP(sport=3D101, dport=3D201)/('X'*48)] > + self.send_and_check_packets(pcap_file, pkt, "ipv4", "dst", "200.= 0.0.1", 0, 3) > + > + # rule 1 test > + pcap_file =3D '/tmp/route_1.pcap' > + pkt =3D [Ether(dst=3Dself.dut_p0_mac)/IP(src=3D'100.0.0.2', dst= =3D'200.0.0.2', > proto=3D17)/UDP(sport=3D102, dport=3D202)/('X'*48)] > + self.send_and_check_packets(pcap_file, pkt, "ipv4", "dst", "200.= 0.0.2", 0, 2) > + > + # rule 2 test > + pcap_file =3D '/tmp/route_2.pcap' > + pkt =3D [Ether(dst=3Dself.dut_p0_mac)/IP(src=3D'100.0.0.3', dst= =3D'200.0.0.3', > proto=3D132)/SCTP(sport=3D103, dport=3D203)/('X'*48)] > + self.send_and_check_packets(pcap_file, pkt, "ipv4", "dst", "200.= 0.0.3", 0, 1) > + > + # rule 3 test > + pcap_file =3D '/tmp/route_3.pcap' > + pkt =3D [Ether(dst=3Dself.dut_p0_mac)/IP(src=3D'100.0.0.4', dst= =3D'200.0.0.4', > proto=3D17)/UDP(sport=3D104, dport=3D204)/('X'*48)] > + self.send_and_check_packets(pcap_file, pkt, "ipv4", "dst", "200.= 0.0.4", 0, 0) > + > + self.dut.send_expect("quit", "# ", 60) > + > + def test_ipv4_addr_hash_table(self): > + """ > + Ipv4 addr hash table > + """ > + filename =3D "flow_ipv4_addr_hash_firmware.cli" > + > + # match ipv4 src_addr > + cmd =3D "pipeline RX table match hash ext key 8 mask FFFFFFFF000= 00000 > offset 282 buckets 16K size 64K action AP0" > + self.set_table(cmd, filename) > + self.start_testpmd(filename, self.port_num) > + > + # create rule > + self.generate_rules(src_mask=3Dself.ipv4_mask, src_spec=3D"100.0= .0.1", > dst_spec=3D"200.0.0.1", sportspec=3D100, dportspec=3D200, index=3D[3]) > + self.generate_rules(src_mask=3Dself.ipv4_mask, src_spec=3D"100.0= .0.2", > dst_spec=3D"200.0.0.1", sportspec=3D100, dportspec=3D200, index=3D[2]) > + self.generate_rules(src_mask=3Dself.ipv4_mask, src_spec=3D"100.0= .0.3", > dst_spec=3D"200.0.0.1", sportspec=3D100, dportspec=3D200, index=3D[1]) > + self.generate_rules(src_mask=3Dself.ipv4_mask, src_spec=3D"100.0= .0.4", > dst_spec=3D"200.0.0.1", sportspec=3D100, dportspec=3D200, index=3D[0]) > + self.dut.send_expect("start", "testpmd> ", 60) > + > + # rule 0 test > + pcap_file =3D '/tmp/route_0.pcap' > + pkt =3D [Ether(dst=3Dself.dut_p0_mac)/IP(src=3D'100.0.0.1', dst= =3D'200.0.0.1', > proto=3D6)/TCP(sport=3D101, dport=3D201)/('X'*48)] > + self.send_and_check_packets(pcap_file, pkt, "ipv4", "src", "100.= 0.0.1", 0, 3) > + > + # rule 1 test > + pcap_file =3D '/tmp/route_1.pcap' > + pkt =3D [Ether(dst=3Dself.dut_p0_mac)/IP(src=3D'100.0.0.2', dst= =3D'200.0.0.2', > proto=3D17)/UDP(sport=3D102, dport=3D202)/('X'*48)] > + self.send_and_check_packets(pcap_file, pkt, "ipv4", "src", "100.= 0.0.2", 0, 2) > + > + # rule 2 test > + pcap_file =3D '/tmp/route_2.pcap' > + pkt =3D [Ether(dst=3Dself.dut_p0_mac)/IP(src=3D'100.0.0.3', dst= =3D'200.0.0.3', > proto=3D132)/SCTP(sport=3D103, dport=3D203)/('X'*48)] > + self.send_and_check_packets(pcap_file, pkt, "ipv4", "src", "100.= 0.0.3", 0, 1) > + > + # rule 3 test > + pcap_file =3D '/tmp/route_3.pcap' > + pkt =3D [Ether(dst=3Dself.dut_p0_mac)/IP(src=3D'100.0.0.4', > dst=3D'200.0.0.4')/('X'*48)] > + self.send_and_check_packets(pcap_file, pkt, "ipv4", "src", "100.= 0.0.4", 0, 0) > + self.dut.send_expect("quit", "# ", 60) > + > + # match ipv4 dst_addr > + cmd =3D "pipeline RX table match hash ext key 8 mask FFFFFF00000= 00000 > offset 286 buckets 16K size 64K action AP0" > + self.set_table(cmd, filename) > + self.start_testpmd(filename, self.port_num) > + > + # create rule > + self.generate_rules(dst_mask=3D"255.255.255.0", src_spec=3D"100.= 0.0.1", > dst_spec=3D"200.0.0.1", sportspec=3D100, dportspec=3D200, index=3D[3]) > + self.generate_rules(dst_mask=3D"255.255.255.0", src_spec=3D"100.= 0.0.1", > dst_spec=3D"200.0.1.1", protospec=3D6, l4type=3D"tcp", sportspec=3D100, > dportspec=3D200, index=3D[2]) > + self.generate_rules(dst_mask=3D"255.255.255.0", src_spec=3D"100.= 0.0.1", > dst_spec=3D"200.0.2.1", protospec=3D132, l4type=3D"sctp", sportspec=3D100= , > dportspec=3D200, index=3D[1]) > + self.generate_rules(dst_mask=3D"255.255.255.0", src_spec=3D"100.= 0.0.1", > dst_spec=3D"200.0.3.1", l4type=3D"", index=3D[0]) > + self.dut.send_expect("start", "testpmd> ", 60) > + > + # rule 0 test > + pcap_file =3D '/tmp/route_0.pcap' > + pkt =3D [Ether(dst=3Dself.dut_p0_mac)/IP(src=3D'100.0.0.1', dst= =3D'200.0.0.1', > proto=3D6)/TCP(sport=3D101, dport=3D201)/('X'*48)] > + self.send_and_check_packets(pcap_file, pkt, "ipv4", "dst", "200.= 0.0.1", 0, 3) > + > + # rule 1 test > + pcap_file =3D '/tmp/route_1.pcap' > + pkt =3D [Ether(dst=3Dself.dut_p0_mac)/IP(src=3D'100.0.0.2', dst= =3D'200.0.1.2', > proto=3D17)/UDP(sport=3D102, dport=3D202)/('X'*48)] > + self.send_and_check_packets(pcap_file, pkt, "ipv4", "dst", "200.= 0.1.2", 0, 2) > + > + # rule 2 test > + pcap_file =3D '/tmp/route_2.pcap' > + pkt =3D [Ether(dst=3Dself.dut_p0_mac)/IP(src=3D'100.0.0.3', dst= =3D'200.0.2.3', > proto=3D132)/SCTP(sport=3D103, dport=3D203)/('X'*48)] > + self.send_and_check_packets(pcap_file, pkt, "ipv4", "dst", "200.= 0.2.3", 0, 1) > + > + # rule 3 test > + pcap_file =3D '/tmp/route_3.pcap' > + pkt =3D [Ether(dst=3Dself.dut_p0_mac)/IP(src=3D'100.0.0.4', > dst=3D'200.0.3.4')/('X'*48)] > + self.send_and_check_packets(pcap_file, pkt, "ipv4", "dst", "200.= 0.3.4", 0, 0) > + self.dut.send_expect("quit", "# ", 60) > + > + # match sport > + cmd =3D "pipeline RX table match hash ext key 8 mask FFFF0000000= 00000 > offset 290 buckets 16K size 64K action AP0" > + self.set_table(cmd, filename) > + self.start_testpmd(filename, self.port_num) > + > + # create rule > + self.generate_rules(src_spec=3D"100.0.0.1", dst_spec=3D"200.0.0.= 1", > sportmask=3Dself.portmask, sportspec=3D100, dportspec=3D200, index=3D[3]) > + self.generate_rules(src_spec=3D"100.0.0.1", dst_spec=3D"200.0.0.= 1", > protospec=3D6, l4type=3D"tcp", sportmask=3Dself.portmask, sportspec=3D101= , > dportspec=3D200, index=3D[2]) > + self.generate_rules(src_spec=3D"100.0.0.1", dst_spec=3D"200.0.0.= 1", > protospec=3D132, l4type=3D"sctp", sportmask=3Dself.portmask, sportspec=3D= 102, > dportspec=3D200, index=3D[1]) > + self.generate_rules(src_spec=3D"100.0.0.1", dst_spec=3D"200.0.0.= 1", > sportmask=3Dself.portmask, sportspec=3D103, dportspec=3D200, index=3D[0]) > + self.dut.send_expect("start", "testpmd> ", 60) > + > + # rule 0 test > + pcap_file =3D '/tmp/route_0.pcap' > + pkt =3D [Ether(dst=3Dself.dut_p0_mac)/IP(src=3D'100.0.0.1', dst= =3D'200.0.0.1', > proto=3D6)/TCP(sport=3D100, dport=3D201)/('X'*48)] > + self.send_and_check_packets(pcap_file, pkt, "tcp", "src", 100, 0= , 3) > + > + # rule 1 test > + pcap_file =3D '/tmp/route_1.pcap' > + pkt =3D [Ether(dst=3Dself.dut_p0_mac)/IP(src=3D'100.0.0.2', dst= =3D'200.0.1.2', > proto=3D17)/UDP(sport=3D101, dport=3D202)/('X'*48)] > + self.send_and_check_packets(pcap_file, pkt, "udp", "src", 101, 0= , 2) > + > + # rule 2 test > + pcap_file =3D '/tmp/route_2.pcap' > + pkt =3D [Ether(dst=3Dself.dut_p0_mac)/IP(src=3D'100.0.0.3', dst= =3D'200.0.2.3', > proto=3D132)/SCTP(sport=3D102, dport=3D203)/('X'*48)] > + self.send_and_check_packets(pcap_file, pkt, "sctp", "src", 102, = 0, 1) > + > + # rule 3 test > + pcap_file =3D '/tmp/route_3.pcap' > + pkt =3D [Ether(dst=3Dself.dut_p0_mac)/IP(src=3D'100.0.0.2', dst= =3D'200.0.1.2', > proto=3D17)/UDP(sport=3D103, dport=3D202)/('X'*48)] > + self.send_and_check_packets(pcap_file, pkt, "udp", "src", 103, 0= , 0) > + > + # send a packet without l4 info > + pcap_file =3D '/tmp/route_4.pcap' > + pkt =3D [Ether(dst=3Dself.dut_p0_mac)/IP(src=3D'100.0.0.4', > dst=3D'200.0.3.4')/('X'*48)] > + self.write_pcap_file(pcap_file, pkt) > + self.send_pkts(0, pcap_file) > + self.check_status(5, 4, self.port_num) > + > + self.dut.send_expect("quit", "# ", 60) > + > + def test_ipv6_acl_table(self): > + """ > + Ipv6 acl table > + """ > + filename =3D "flow_ipv6_acl_firmware.cli" > + self.start_testpmd(filename, self.port_num) > + > + # create rule > + self.generate_rules(iptype=3D"ipv6", src_mask=3Dself.ipv6_mask, > src_spec=3D"ABCD:EF01:2345:6789:ABCD:EF01:2345:5789", > protomask=3Dself.protomask, index=3D[3]) > + self.generate_rules(iptype=3D"ipv6", src_mask=3Dself.ipv6_mask, > src_spec=3D"ABCD:EF01:2345:6789:ABCD:EF01:2345:6789", > protomask=3Dself.protomask, protospec=3D6, l4type=3D"tcp", index=3D[2]) > + self.generate_rules(iptype=3D"ipv6", src_mask=3Dself.ipv6_mask, > src_spec=3D"ABCD:EF01:2345:6789:ABCD:EF01:2345:7789", > protomask=3Dself.protomask, protospec=3D132, l4type=3D"sctp", index=3D[1]= ) > + self.generate_rules(iptype=3D"ipv6", src_mask=3Dself.ipv6_mask, > src_spec=3D"ABCD:EF01:2345:6789:ABCD:EF01:2345:8789", > protomask=3Dself.protomask, sportmask=3Dself.portmask, sportspec=3D100, i= ndex=3D[0]) > + self.dut.send_expect("start", "testpmd> ", 60) > + > + # rule 0 test > + pcap_file =3D '/tmp/route_0.pcap' > + pkt =3D > [Ether(dst=3Dself.dut_p0_mac)/IPv6(src=3D'ABCD:EF01:2345:6789:ABCD:EF01:2= 345: > 5789', dst=3D'2001::2', nh=3D17)/UDP(sport=3D101, dport=3D201)/('X'*48)] > + self.send_and_check_packets(pcap_file, pkt, "ipv6", "src", > "ABCD:EF01:2345:6789:ABCD:EF01:2345:5789", 0, 3) > + > + # rule 1 test > + pcap_file =3D '/tmp/route_1.pcap' > + pkt =3D > [Ether(dst=3Dself.dut_p0_mac)/IPv6(src=3D'ABCD:EF01:2345:6789:ABCD:EF01:2= 345: > 6789', dst=3D'2001::2', nh=3D6)/TCP(sport=3D101, dport=3D201)/('X'*48)] > + self.send_and_check_packets(pcap_file, pkt, "ipv6", "src", > "ABCD:EF01:2345:6789:ABCD:EF01:2345:6789", 0, 2) > + > + # rule 2 test > + pcap_file =3D '/tmp/route_2.pcap' > + pkt =3D > [Ether(dst=3Dself.dut_p0_mac)/IPv6(src=3D'ABCD:EF01:2345:6789:ABCD:EF01:2= 345: > 7789', dst=3D'2001::2', nh=3D132)/SCTP(sport=3D101, dport=3D201)/('X'*48)= ] > + self.send_and_check_packets(pcap_file, pkt, "ipv6", "src", > "ABCD:EF01:2345:6789:ABCD:EF01:2345:7789", 0, 1) > + > + # rule 3 test > + pcap_file =3D '/tmp/route_3.pcap' > + pkt =3D > [Ether(dst=3Dself.dut_p0_mac)/IPv6(src=3D'ABCD:EF01:2345:6789:ABCD:EF01:2= 345: > 8789', dst=3D'2001::2', nh=3D17)/UDP(sport=3D100, dport=3D201)/('X'*48)] > + self.send_and_check_packets(pcap_file, pkt, "udp", "src", 100, 0= , 0) > + > + # send another 3 packets > + pcap_file =3D '/tmp/route_4.pcap' > + pkt =3D > [Ether(dst=3Dself.dut_p0_mac)/IPv6(src=3D'ABCD:EF01:2345:6789:ABCD:EF01:2= 345: > 9789', dst=3D'2001::2', nh=3D17)/UDP(sport=3D101, dport=3D201)/('X'*48)] > + self.write_pcap_file(pcap_file, pkt) > + self.send_pkts(0, pcap_file) > + > + pcap_file =3D '/tmp/route_4.pcap' > + pkt =3D > [Ether(dst=3Dself.dut_p0_mac)/IPv6(src=3D'ABCD:EF01:2345:6789:ABCD:EF01:2= 345: > 8789', dst=3D'2001::2', nh=3D17)/UDP(sport=3D101, dport=3D201)/('X'*48)] > + self.write_pcap_file(pcap_file, pkt) > + self.send_pkts(0, pcap_file) > + > + pcap_file =3D '/tmp/route_4.pcap' > + pkt =3D > [Ether(dst=3Dself.dut_p0_mac)/IPv6(src=3D'ABCD:EF01:2345:6789:ABCD:EF01:2= 345: > 6789', dst=3D'2001::2', nh=3D17)/TCP(sport=3D101, dport=3D201)/('X'*48)] > + self.write_pcap_file(pcap_file, pkt) > + self.send_pkts(0, pcap_file) > + > + self.check_status(7, 4, self.port_num) > + self.dut.send_expect("quit", "# ", 60) > + > + def test_ipv6_addr_hash_table(self): > + """ > + Ipv6 addr hash table > + """ > + filename =3D "flow_ipv6_addr_hash_firmware.cli" > + > + # match ipv6 src_addr > + cmd =3D "pipeline RX table match hash ext key 16 mask > FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF offset 278 buckets 16K size 64K action A= P0" > + self.set_table(cmd, filename) > + self.start_testpmd(filename, self.port_num) > + > + # create rule > + self.generate_rules(iptype=3D"ipv6", src_mask=3Dself.ipv6_mask, > src_spec=3D"ABCD:EF01:2345:6789:ABCD:EF01:2345:5789", index=3D[3]) > + self.generate_rules(iptype=3D"ipv6", src_mask=3Dself.ipv6_mask, > src_spec=3D"ABCD:EF01:2345:6789:ABCD:EF01:2345:6789", index=3D[2]) > + self.generate_rules(iptype=3D"ipv6", src_mask=3Dself.ipv6_mask, > src_spec=3D"ABCD:EF01:2345:6789:ABCD:EF01:2345:7789", index=3D[1]) > + self.generate_rules(iptype=3D"ipv6", src_mask=3Dself.ipv6_mask, > src_spec=3D"ABCD:EF01:2345:6789:ABCD:EF01:2345:8789", index=3D[0]) > + self.dut.send_expect("start", "testpmd> ", 60) > + > + # rule 0 test > + pcap_file =3D '/tmp/route_0.pcap' > + pkt =3D > [Ether(dst=3Dself.dut_p0_mac)/IPv6(src=3D'ABCD:EF01:2345:6789:ABCD:EF01:2= 345: > 5789', dst=3D'2001::2', nh=3D6)/TCP(sport=3D101, dport=3D201)/('X'*48)] > + self.send_and_check_packets(pcap_file, pkt, "ipv6", "src", > "ABCD:EF01:2345:6789:ABCD:EF01:2345:5789", 0, 3) > + > + # rule 1 test > + pcap_file =3D '/tmp/route_1.pcap' > + pkt =3D > [Ether(dst=3Dself.dut_p0_mac)/IPv6(src=3D'ABCD:EF01:2345:6789:ABCD:EF01:2= 345: > 6789', dst=3D'2001::2', nh=3D6)/TCP(sport=3D101, dport=3D201)/('X'*48)] > + self.send_and_check_packets(pcap_file, pkt, "ipv6", "src", > "ABCD:EF01:2345:6789:ABCD:EF01:2345:6789", 0, 2) > + > + # rule 2 test > + pcap_file =3D '/tmp/route_2.pcap' > + pkt =3D > [Ether(dst=3Dself.dut_p0_mac)/IPv6(src=3D'ABCD:EF01:2345:6789:ABCD:EF01:2= 345: > 7789', dst=3D'2001::2', nh=3D132)/SCTP(sport=3D101, dport=3D201)/('X'*48)= ] > + self.send_and_check_packets(pcap_file, pkt, "ipv6", "src", > "ABCD:EF01:2345:6789:ABCD:EF01:2345:7789", 0, 1) > + > + # rule 3 test > + pcap_file =3D '/tmp/route_3.pcap' > + pkt =3D > [Ether(dst=3Dself.dut_p0_mac)/IPv6(src=3D'ABCD:EF01:2345:6789:ABCD:EF01:2= 345: > 8789', dst=3D'2001::2', nh=3D17)/UDP(sport=3D100, dport=3D201)/('X'*48)] > + self.send_and_check_packets(pcap_file, pkt, "ipv6", "src", > "ABCD:EF01:2345:6789:ABCD:EF01:2345:8789", 0, 0) > + > + pcap_file =3D '/tmp/route_4.pcap' > + pkt =3D > [Ether(dst=3Dself.dut_p0_mac)/IPv6(src=3D'ABCD:EF01:2345:6789:ABCD:EF01:2= 345: > 9789', dst=3D'2001::2', nh=3D17)/UDP(sport=3D101, dport=3D201)/('X'*48)] > + self.write_pcap_file(pcap_file, pkt) > + self.send_pkts(0, pcap_file) > + self.check_status(5, 4, self.port_num) > + self.dut.send_expect("quit", "# ", 60) > + > + # match ipv6 dst_addr > + cmd =3D "pipeline RX table match hash ext key 16 mask > FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF offset 294 buckets 16K size 64K action A= P0" > + self.set_table(cmd, filename) > + self.start_testpmd(filename, self.port_num) > + > + # create rule > + self.generate_rules(iptype=3D"ipv6", dst_mask=3Dself.ipv6_mask, > dst_spec=3D"ABCD:EF01:2345:6789:ABCD:EF01:2345:5789", index=3D[3]) > + self.generate_rules(iptype=3D"ipv6", dst_mask=3Dself.ipv6_mask, > dst_spec=3D"ABCD:EF01:2345:6789:ABCD:EF01:2345:6789", index=3D[2]) > + self.generate_rules(iptype=3D"ipv6", dst_mask=3Dself.ipv6_mask, > dst_spec=3D"ABCD:EF01:2345:6789:ABCD:EF01:2345:7789", index=3D[1]) > + self.generate_rules(iptype=3D"ipv6", dst_mask=3Dself.ipv6_mask, > dst_spec=3D"ABCD:EF01:2345:6789:ABCD:EF01:2345:8789", index=3D[0]) > + self.dut.send_expect("start", "testpmd> ", 60) > + > + # rule 0 test > + pcap_file =3D '/tmp/route_0.pcap' > + pkt =3D > [Ether(dst=3Dself.dut_p0_mac)/IPv6(dst=3D'ABCD:EF01:2345:6789:ABCD:EF01:2= 345: > 5789', src=3D'2001::2', nh=3D6)/TCP(sport=3D101, dport=3D201)/('X'*48)] > + self.send_and_check_packets(pcap_file, pkt, "ipv6", "dst", > "ABCD:EF01:2345:6789:ABCD:EF01:2345:5789", 0, 3) > + > + # rule 1 test > + pcap_file =3D '/tmp/route_1.pcap' > + pkt =3D > [Ether(dst=3Dself.dut_p0_mac)/IPv6(dst=3D'ABCD:EF01:2345:6789:ABCD:EF01:2= 345: > 6789', src=3D'2001::2', nh=3D6)/TCP(sport=3D101, dport=3D201)/('X'*48)] > + self.send_and_check_packets(pcap_file, pkt, "ipv6", "dst", > "ABCD:EF01:2345:6789:ABCD:EF01:2345:6789", 0, 2) > + > + # rule 2 test > + pcap_file =3D '/tmp/route_2.pcap' > + pkt =3D > [Ether(dst=3Dself.dut_p0_mac)/IPv6(dst=3D'ABCD:EF01:2345:6789:ABCD:EF01:2= 345: > 7789', src=3D'2001::2', nh=3D132)/SCTP(sport=3D101, dport=3D201)/('X'*48)= ] > + self.send_and_check_packets(pcap_file, pkt, "ipv6", "dst", > "ABCD:EF01:2345:6789:ABCD:EF01:2345:7789", 0, 1) > + > + # rule 3 test > + pcap_file =3D '/tmp/route_3.pcap' > + pkt =3D > [Ether(dst=3Dself.dut_p0_mac)/IPv6(dst=3D'ABCD:EF01:2345:6789:ABCD:EF01:2= 345: > 8789', src=3D'2001::2', nh=3D17)/UDP(sport=3D100, dport=3D201)/('X'*48)] > + self.send_and_check_packets(pcap_file, pkt, "ipv6", "dst", > "ABCD:EF01:2345:6789:ABCD:EF01:2345:8789", 0, 0) > + > + pcap_file =3D '/tmp/route_4.pcap' > + pkt =3D > [Ether(dst=3Dself.dut_p0_mac)/IPv6(dst=3D'ABCD:EF01:2345:6789:ABCD:EF01:2= 345: > 9789', src=3D'2001::2', nh=3D17)/UDP(sport=3D101, dport=3D201)/('X'*48)] > + self.write_pcap_file(pcap_file, pkt) > + self.send_pkts(0, pcap_file) > + self.check_status(5, 4, self.port_num) > + self.dut.send_expect("quit", "# ", 60) > + > + def test_ipv6_5tuple_hash_table(self): > + """ > + Ipv6 5tuple hash table > + """ > + filename =3D "flow_ipv6_5tuple_hash_firmware.cli" > + cmd =3D "pipeline RX table match hash ext key 64 mask > 0000FF00FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF > FFFFFFFF000000000000000000000000000000000000000000000000 offset 274 > buckets 16K size 64K action AP0" > + self.set_table(cmd, filename) > + self.start_testpmd(filename, self.port_num) > + > + # create rule > + self.generate_rules(iptype=3D"ipv6", src_mask=3Dself.ipv6_mask, > dst_mask=3Dself.ipv6_mask, src_spec=3D"2001::1", dst_spec=3D"0::1", > protomask=3Dself.protomask, sportmask=3Dself.portmask, dportmask=3Dself.p= ortmask, > sportspec=3D101, dportspec=3D201, index=3D[3]) > + self.generate_rules(iptype=3D"ipv6", src_mask=3Dself.ipv6_mask, > dst_mask=3Dself.ipv6_mask, src_spec=3D"2001::2", dst_spec=3D"0::2", > protomask=3Dself.protomask, protospec=3D6, l4type=3D"tcp", > sportmask=3Dself.portmask, dportmask=3Dself.portmask, sportspec=3D102, > dportspec=3D202, index=3D[2]) > + self.generate_rules(iptype=3D"ipv6", src_mask=3Dself.ipv6_mask, > dst_mask=3Dself.ipv6_mask, src_spec=3D"2001::3", dst_spec=3D"0::3", > protomask=3Dself.protomask, protospec=3D132, l4type=3D"sctp", > sportmask=3Dself.portmask, dportmask=3Dself.portmask, sportspec=3D103, > dportspec=3D203, index=3D[1]) > + self.generate_rules(iptype=3D"ipv6", src_mask=3Dself.ipv6_mask, > dst_mask=3Dself.ipv6_mask, src_spec=3D"2001::4", dst_spec=3D"0::4", > protomask=3Dself.protomask, sportmask=3Dself.portmask, dportmask=3Dself.p= ortmask, > sportspec=3D104, dportspec=3D204, index=3D[0]) > + self.dut.send_expect("start", "testpmd> ", 60) > + > + # rule 0 test > + pcap_file =3D '/tmp/route_0.pcap' > + pkt =3D [Ether(dst=3Dself.dut_p0_mac)/IPv6(src=3D"2001::1", dst= =3D"0::1", > nh=3D17)/UDP(sport=3D101, dport=3D201)/('X'*48)] > + self.send_and_check_packets(pcap_file, pkt, "ipv6", "src", "2001= ::1", 0, 3) > + > + # rule 1 test > + pcap_file =3D '/tmp/route_1.pcap' > + pkt =3D [Ether(dst=3Dself.dut_p0_mac)/IPv6(src=3D'2001::2', dst= =3D'0::2', > nh=3D6)/TCP(sport=3D102, dport=3D202)/('X'*48)] > + self.send_and_check_packets(pcap_file, pkt, "ipv6", "src", "2001= ::2", 0, 2) > + > + # rule 2 test > + pcap_file =3D '/tmp/route_2.pcap' > + pkt =3D [Ether(dst=3Dself.dut_p0_mac)/IPv6(src=3D'2001::3', dst= =3D'0::3', > nh=3D132)/SCTP(sport=3D103, dport=3D203)/('X'*48)] > + self.send_and_check_packets(pcap_file, pkt, "ipv6", "src", "2001= ::3", 0, 1) > + > + # rule 3 test > + pcap_file =3D '/tmp/route_3.pcap' > + pkt =3D [Ether(dst=3Dself.dut_p0_mac)/IPv6(src=3D'2001::4', dst= =3D'0::4', > nh=3D17)/UDP(sport=3D104, dport=3D204)/('X'*48)] > + self.send_and_check_packets(pcap_file, pkt, "ipv6", "src", "2001= ::4", 0, 0) > + > + pcap_file =3D '/tmp/route_4.pcap' > + pkt =3D [Ether(dst=3Dself.dut_p0_mac)/IPv6(src=3D"2001::1", dst= =3D"0::1", > nh=3D6)/TCP(sport=3D101, dport=3D201)/('X'*48)] > + self.write_pcap_file(pcap_file, pkt) > + self.send_pkts(0, pcap_file) > + self.check_status(5, 4, self.port_num) > + self.dut.send_expect("quit", "# ", 60) > + > + def test_inconsistent_rules(self): > + """ > + Flow rule item is inconsistent with table match format > + """ > + # ipv4 > + filename =3D "flow_ipv4_addr_hash_firmware.cli" > + cmd =3D "pipeline RX table match hash ext key 8 mask FFFFFFFF000= 00000 > offset 282 buckets 16K size 64K action AP0" > + self.set_table(cmd, filename) > + self.start_testpmd(filename, self.port_num) > + > + # create rule > + self.dut.send_expect("flow create 4 group 0 ingress pattern eth = / ipv4 > proto mask 0 src mask 0.0.0.0 dst mask 255.255.255.255 src spec 100.0.0.1= dst > spec 200.0.0.1 proto spec 17 / udp src mask 0 dst mask 0 src spec 100 dst= spec > 200 / end actions queue index 3 / end", "error", 60) > + self.dut.send_expect("quit", "# ", 60) > + > + cmd =3D "pipeline RX table match hash ext key 8 mask FFFFFF00000= 00000 > offset 286 buckets 16K size 64K action AP0" > + self.set_table(cmd, filename) > + self.start_testpmd(filename, self.port_num) > + self.dut.send_expect("flow create 4 group 0 ingress pattern eth = / ipv4 > proto mask 0 src mask 0.0.0.0 dst mask 255.255.255.255 src spec 100.0.0.1= dst > spec 200.0.0.1 proto spec 17 / udp src mask 0 dst mask 0 src spec 100 dst= spec > 200 / end actions queue index 3 / end", "error", 60) > + self.dut.send_expect("quit", "# ", 60) > + > + # ipv6 > + filename =3D "flow_ipv6_5tuple_hash_firmware.cli" > + cmd =3D "pipeline RX table match hash ext key 64 mask > 0000FF00FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF > FFFFFFFF000000000000000000000000000000000000000000000000 offset 274 > buckets 16K size 64K action AP0" > + self.set_table(cmd, filename) > + self.start_testpmd(filename, self.port_num) > + self.dut.send_expect("flow create 4 group 0 ingress pattern eth = / ipv6 > proto mask 255 src mask ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff dst mask > ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff src spec 2001::1 dst spec 0::1 pr= oto spec 17 / > udp src mask 0 dst mask 65535 src spec 31 dst spec 41 / end actions queue= index > 3 / end", "error", 60) > + self.dut.send_expect("quit", "# ", 60) > + > + cmd =3D "pipeline RX table match hash ext key 16 mask > FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF offset 294 buckets 16K size 64K action A= P0" > + self.set_table(cmd, filename) > + self.start_testpmd(filename, self.port_num) > + self.dut.send_expect("flow create 4 group 0 ingress pattern eth = / ipv6 > proto mask 0 src mask ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff dst mask 0= :0:0:0:0:0:0:0 > src spec ABCD:EF01:2345:6789:ABCD:EF01:2345:5789 dst spec 0:0:0:0:0:0:0:0 > proto spec 17 / udp src mask 0 dst mask 0 src spec 0 dst spec 0 / end act= ions > queue index 3 / end", "error", 60) > + self.dut.send_expect("quit", "# ", 60) > + > + def test_ipv4_hash_rss_action(self): > + """ > + Set rss action using acl table. > + """ > + filename =3D "flow_ipv4_rss_firmware.cli" > + > + # match ipv4 src_addr > + cmd =3D "pipeline RX table match hash ext key 16 mask > 00FF0000FFFFFFFFFFFFFFFFFFFFFFFF offset 278 buckets 16K size 64K action A= P0" > + self.set_table(cmd, filename) > + self.start_testpmd(filename, self.port_num) > + > + # create rule > + self.generate_rules(src_mask=3Dself.ipv4_mask, dst_mask=3Dself.i= pv4_mask, > src_spec=3D"100.0.0.1", dst_spec=3D"200.0.0.1", protomask=3Dself.protomas= k, > protospec=3D6, l4type=3D"tcp", sportmask=3Dself.portmask, dportmask=3Dsel= f.portmask, > sportspec=3D100, dportspec=3D200, action=3D"rss", index=3D[3]) > + self.generate_rules(src_mask=3Dself.ipv4_mask, dst_mask=3Dself.i= pv4_mask, > src_spec=3D"100.0.0.2", dst_spec=3D"200.0.0.2", protomask=3Dself.protomas= k, > protospec=3D17, l4type=3D"udp", sportmask=3Dself.portmask, > dportmask=3Dself.portmask, sportspec=3D100, dportspec=3D200, action=3D"rs= s", > index=3D[2]) > + self.generate_rules(src_mask=3Dself.ipv4_mask, dst_mask=3Dself.i= pv4_mask, > src_spec=3D"100.0.0.3", dst_spec=3D"200.0.0.3", protomask=3Dself.protomas= k, > protospec=3D132, l4type=3D"sctp", sportmask=3Dself.portmask, > dportmask=3Dself.portmask, sportspec=3D100, dportspec=3D200, action=3D"rs= s", > index=3D[1]) > + self.generate_rules(src_mask=3Dself.ipv4_mask, dst_mask=3Dself.i= pv4_mask, > src_spec=3D"100.0.0.4", dst_spec=3D"200.0.0.4", protomask=3Dself.protomas= k, > protospec=3D6, l4type=3D"tcp", sportmask=3Dself.portmask, dportmask=3Dsel= f.portmask, > sportspec=3D100, dportspec=3D200, action=3D"rss", index=3D[0]) > + self.dut.send_expect("start", "testpmd> ", 60) > + > + # rule 0 test > + pcap_file =3D '/tmp/route_0.pcap' > + pkt =3D [Ether(dst=3Dself.dut_p0_mac)/IP(src=3D'100.0.0.1', dst= =3D'200.0.0.1', > proto=3D6)/TCP(sport=3D100, dport=3D200)/('X'*48)] > + self.send_and_check_packets(pcap_file, pkt, "ipv4", "dst", "200.= 0.0.1", 0, 3) > + > + # rule 1 test > + pcap_file =3D '/tmp/route_1.pcap' > + pkt =3D [Ether(dst=3Dself.dut_p0_mac)/IP(src=3D'100.0.0.2', dst= =3D'200.0.0.2', > proto=3D17)/UDP(sport=3D100, dport=3D200)/('X'*48)] > + self.send_and_check_packets(pcap_file, pkt, "ipv4", "dst", "200.= 0.0.2", 0, 2) > + > + # rule 2 test > + pcap_file =3D '/tmp/route_2.pcap' > + pkt =3D [Ether(dst=3Dself.dut_p0_mac)/IP(src=3D'100.0.0.3', dst= =3D'200.0.0.3', > proto=3D132)/SCTP(sport=3D100, dport=3D200)/('X'*48)] > + self.send_and_check_packets(pcap_file, pkt, "ipv4", "src", "100.= 0.0.3", 0, 1) > + > + # rule 3 test > + pcap_file =3D '/tmp/route_3.pcap' > + pkt =3D [Ether(dst=3Dself.dut_p0_mac)/IP(src=3D'100.0.0.4', dst= =3D'200.0.0.4', > proto=3D6)/TCP(sport=3D100, dport=3D200)/('X'*48)] > + self.send_and_check_packets(pcap_file, pkt, "ipv4", "dst", "200.= 0.0.4", 0, 0) > + > + # not match test > + pcap_file =3D '/tmp/route_4.pcap' > + pkt =3D [Ether(dst=3Dself.dut_p0_mac)/IP(src=3D'100.0.0.4', dst= =3D'200.0.0.4', > proto=3D6)/TCP(sport=3D101, dport=3D200)/('X'*48)] > + self.write_pcap_file(pcap_file, pkt) > + self.send_pkts(0, pcap_file) > + self.check_status(5, 4, self.port_num) > + self.dut.send_expect("quit", "# ", 60) > + > + # match ipv4 src_addr > + cmd =3D "pipeline RX table match hash ext key 16 mask > 00FF0000FFFFFF00FFFFFFFFFFFFFFFF offset 278 buckets 16K size 64K action A= P0" > + self.set_table(cmd, filename) > + self.start_testpmd(filename, self.port_num) > + > + self.generate_rules(src_mask=3D"255.255.255.0", dst_mask=3Dself.= ipv4_mask, > src_spec=3D"100.0.0.1", dst_spec=3D"200.0.0.1", protomask=3Dself.protomas= k, > sportmask=3Dself.portmask, dportmask=3Dself.portmask, sportspec=3D100, > dportspec=3D200, action=3D"rss", index=3D[0, 1, 2, 3]) > + self.generate_rules(src_mask=3D"255.255.255.0", dst_mask=3Dself.= ipv4_mask, > src_spec=3D"100.0.1.2", dst_spec=3D"200.0.0.1", protomask=3Dself.protomas= k, > sportmask=3Dself.portmask, dportmask=3Dself.portmask, sportspec=3D100, > dportspec=3D200, action=3D"rss", index=3D[0, 1, 2, 3]) > + self.dut.send_expect("start", "testpmd> ", 60) > + > + self.send_continuous_packet("ipv4", "src", "100.0.0.1", "200.0.0= .1", > self.tester_itf) > + out =3D self.dut.send_expect("stop", "testpmd> ", 120) > + self.check_packet_queue([0, 1, 2, 3], out) > + self.dut.send_expect("start", "testpmd> ", 120) > + self.send_continuous_packet("ipv4", "src", "100.0.1.2", "200.0.0= .1", > self.tester_itf) > + out =3D self.dut.send_expect("stop", "testpmd> ", 120) > + self.check_packet_queue([0, 1, 2, 3], out) > + self.dut.send_expect("quit", "# ", 60) > + > + # match ipv4 src_addr > + cmd =3D "pipeline RX table match hash ext key 8 mask FFFF0000FFF= FFFFF > offset 282 buckets 16K size 64K action AP0" > + self.set_table(cmd, filename) > + self.start_testpmd(filename, self.port_num) > + > + self.generate_rules(src_mask=3D"255.255.0.0", dst_mask=3Dself.ip= v4_mask, > src_spec=3D"100.0.0.1", dst_spec=3D"200.0.0.1", sportspec=3D100, dportspe= c=3D200, > action=3D"rss", index=3D[0]) > + self.generate_rules(src_mask=3D"255.255.0.0", dst_mask=3Dself.ip= v4_mask, > src_spec=3D"100.0.0.1", dst_spec=3D"200.0.0.2", sportspec=3D100, dportspe= c=3D200, > action=3D"rss", index=3D[2, 3]) > + self.generate_rules(src_mask=3D"255.255.0.0", dst_mask=3Dself.ip= v4_mask, > src_spec=3D"200.0.0.1", dst_spec=3D"200.0.0.2", sportspec=3D100, dportspe= c=3D200, > action=3D"rss", index=3D[1, 2]) > + self.dut.send_expect("start", "testpmd> ", 60) > + > + self.send_continuous_packet("ipv4", "src", "100.0.0.1", "200.0.0= .1", > self.tester_itf) > + out =3D self.dut.send_expect("stop", "testpmd> ", 120) > + self.check_packet_queue([0], out) > + self.dut.send_expect("start", "testpmd> ", 120) > + self.send_continuous_packet("ipv4", "src", "100.0.1.1", "200.0.0= .2", > self.tester_itf) > + out =3D self.dut.send_expect("stop", "testpmd> ", 120) > + self.check_packet_queue([2, 3], out) > + self.dut.send_expect("start", "testpmd> ", 120) > + self.send_continuous_packet("ipv4", "src", "200.0.0.1", "200.0.0= .2", > self.tester_itf) > + out =3D self.dut.send_expect("stop", "testpmd> ", 120) > + self.check_packet_queue([1, 2], out) > + > + self.dut.send_expect("quit", "# ", 60) > + > + def test_ipv6_hash_rss_action(self): > + """ > + Set rss action using hash table. > + """ > + filename =3D "flow_ipv6_rss_firmware.cli" > + > + # match ipv6 src_addr > + cmd =3D "pipeline RX table match hash ext key 64 mask > 0000FF00FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF > FFFFFFFF000000000000000000000000000000000000000000000000 offset 274 > buckets 16K size 64K action AP0" > + self.set_table(cmd, filename) > + self.start_testpmd(filename, self.port_num) > + > + # create rule > + self.generate_rules(iptype=3D"ipv6", src_mask=3Dself.ipv6_mask, > dst_mask=3Dself.ipv6_mask, src_spec=3D"2001::1", dst_spec=3D"1001::1", > protomask=3Dself.protomask, protospec=3D6, l4type=3D"tcp", > sportmask=3Dself.portmask, dportmask=3Dself.portmask, sportspec=3D100, > dportspec=3D200, action=3D"rss", index=3D[3]) > + self.generate_rules(iptype=3D"ipv6", src_mask=3Dself.ipv6_mask, > dst_mask=3Dself.ipv6_mask, src_spec=3D"2001::2", dst_spec=3D"1001::2", > protomask=3Dself.protomask, protospec=3D17, l4type=3D"udp", > sportmask=3Dself.portmask, dportmask=3Dself.portmask, sportspec=3D100, > dportspec=3D200, action=3D"rss", index=3D[2]) > + self.generate_rules(iptype=3D"ipv6", src_mask=3Dself.ipv6_mask, > dst_mask=3Dself.ipv6_mask, src_spec=3D"2001::3", dst_spec=3D"1001::3", > protomask=3Dself.protomask, protospec=3D132, l4type=3D"sctp", > sportmask=3Dself.portmask, dportmask=3Dself.portmask, sportspec=3D100, > dportspec=3D200, action=3D"rss", index=3D[1]) > + self.generate_rules(iptype=3D"ipv6", src_mask=3Dself.ipv6_mask, > dst_mask=3Dself.ipv6_mask, src_spec=3D"2001::4", dst_spec=3D"1001::4", > protomask=3Dself.protomask, protospec=3D6, l4type=3D"tcp", > sportmask=3Dself.portmask, dportmask=3Dself.portmask, sportspec=3D100, > dportspec=3D200, action=3D"rss", index=3D[0]) > + self.dut.send_expect("start", "testpmd> ", 60) > + > + # rule 0 test > + pcap_file =3D '/tmp/route_0.pcap' > + pkt =3D [Ether(dst=3Dself.dut_p0_mac)/IPv6(src=3D'2001::1', dst= =3D'1001::1', > nh=3D6)/TCP(sport=3D100, dport=3D200)/('X'*48)] > + self.send_and_check_packets(pcap_file, pkt, "ipv6", "dst", "1001= ::1", 0, 3) > + > + # rule 1 test > + pcap_file =3D '/tmp/route_1.pcap' > + pkt =3D [Ether(dst=3Dself.dut_p0_mac)/IPv6(src=3D'2001::2', dst= =3D'1001::2', > nh=3D17)/UDP(sport=3D100, dport=3D200)/('X'*48)] > + self.send_and_check_packets(pcap_file, pkt, "ipv6", "dst", "1001= ::2", 0, 2) > + > + # rule 2 test > + pcap_file =3D '/tmp/route_2.pcap' > + pkt =3D [Ether(dst=3Dself.dut_p0_mac)/IPv6(src=3D'2001::3', dst= =3D'1001::3', > nh=3D132)/SCTP(sport=3D100, dport=3D200)/('X'*48)] > + self.send_and_check_packets(pcap_file, pkt, "ipv6", "dst", "1001= ::3", 0, 1) > + > + # rule 3 test > + pcap_file =3D '/tmp/route_3.pcap' > + pkt =3D [Ether(dst=3Dself.dut_p0_mac)/IPv6(src=3D'2001::4', dst= =3D'1001::4', > nh=3D6)/TCP(sport=3D100, dport=3D200)/('X'*48)] > + self.send_and_check_packets(pcap_file, pkt, "ipv6", "dst", "1001= ::4", 0, 0) > + > + # not match test > + pcap_file =3D '/tmp/route_4.pcap' > + pkt =3D [Ether(dst=3Dself.dut_p0_mac)/IPv6(src=3D'2001::1', dst= =3D'1001::1', > nh=3D17)/UDP(sport=3D100, dport=3D200)/('X'*48)] > + self.write_pcap_file(pcap_file, pkt) > + self.send_pkts(0, pcap_file) > + self.check_status(5, 4, self.port_num) > + self.dut.send_expect("quit", "# ", 60) > + > + cmd =3D "pipeline RX table match hash ext key 64 mask > 0000FF00FFFFFFFFFFFFFFFFFFFFFFFFFFFF0000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF > FFFFFFFF000000000000000000000000000000000000000000000000 offset 274 > buckets 16K size 64K action AP0" > + self.set_table(cmd, filename) > + self.start_testpmd(filename, self.port_num) > + > + # create rule > + self.generate_rules(iptype=3D"ipv6", > src_mask=3D"ffff:ffff:ffff:ffff:ffff:ffff:ffff:0", dst_mask=3Dself.ipv6_m= ask, > src_spec=3D"ABCD:EF01:2345:6789:ABCD:EF01:2345:0", dst_spec=3D"0::1", > protomask=3Dself.protomask, sportmask=3Dself.portmask, dportmask=3Dself.p= ortmask, > sportspec=3D100, dportspec=3D200, action=3D"rss", index=3D[0, 1, 2, 3]) > + self.generate_rules(iptype=3D"ipv6", > src_mask=3D"ffff:ffff:ffff:ffff:ffff:ffff:ffff:0", dst_mask=3Dself.ipv6_m= ask, > src_spec=3D"ABCD:EF01:2345:6789:ABCD:EF01:2346:0", dst_spec=3D"0::1", > protomask=3Dself.protomask, sportmask=3Dself.portmask, dportmask=3Dself.p= ortmask, > sportspec=3D100, dportspec=3D200, action=3D"rss", index=3D[0, 1, 2, 3]) > + self.dut.send_expect("start", "testpmd> ", 60) > + > + self.send_continuous_packet("ipv6", "src", > "ABCD:EF01:2345:6789:ABCD:EF01:2345:0", "0::1", self.tester_itf) > + out =3D self.dut.send_expect("stop", "testpmd> ", 120) > + self.check_packet_queue([0, 1, 2, 3], out) > + self.dut.send_expect("start", "testpmd> ", 120) > + self.send_continuous_packet("ipv6", "src", > "ABCD:EF01:2345:6789:ABCD:EF01:2346:0", "0::1", self.tester_itf) > + out =3D self.dut.send_expect("stop", "testpmd> ", 120) > + self.check_packet_queue([0, 1, 2, 3], out) > + self.dut.send_expect("quit", "# ", 60) > + > + cmd =3D "pipeline RX table match hash ext key 64 mask > 00000000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF0000 > FFFFFFFF000000000000000000000000000000000000000000000000 offset 274 > buckets 16K size 64K action AP0" > + self.set_table(cmd, filename) > + self.start_testpmd(filename, self.port_num) > + > + # create rule > + self.generate_rules(iptype=3D"ipv6", src_mask=3Dself.ipv6_mask, > dst_mask=3D"ffff:ffff:ffff:ffff:ffff:ffff:ffff:0", src_spec=3D"2001::1", > dst_spec=3D"1001::1", sportmask=3Dself.portmask, dportmask=3Dself.portmas= k, > sportspec=3D100, dportspec=3D200, action=3D"rss", index=3D[0]) > + self.generate_rules(iptype=3D"ipv6", src_mask=3Dself.ipv6_mask, > dst_mask=3D"ffff:ffff:ffff:ffff:ffff:ffff:ffff:0", src_spec=3D"2001::2", > dst_spec=3D"1001::1", sportmask=3Dself.portmask, dportmask=3Dself.portmas= k, > sportspec=3D100, dportspec=3D200, action=3D"rss", index=3D[2, 3]) > + self.generate_rules(iptype=3D"ipv6", src_mask=3Dself.ipv6_mask, > dst_mask=3D"ffff:ffff:ffff:ffff:ffff:ffff:ffff:0", src_spec=3D"2001::1", > dst_spec=3D"1002::1", sportmask=3Dself.portmask, dportmask=3Dself.portmas= k, > sportspec=3D100, dportspec=3D200, action=3D"rss", index=3D[1, 2]) > + self.dut.send_expect("start", "testpmd> ", 60) > + > + self.send_continuous_packet("ipv6", "dst", "2001::1", "1001::1", > self.tester_itf) > + out =3D self.dut.send_expect("stop", "testpmd> ", 120) > + self.check_packet_queue([0], out) > + self.dut.send_expect("start", "testpmd> ", 120) > + self.send_continuous_packet("ipv6", "dst", "2001::2", "1001::1", > self.tester_itf) > + out =3D self.dut.send_expect("stop", "testpmd> ", 120) > + self.check_packet_queue([2, 3], out) > + self.dut.send_expect("start", "testpmd> ", 120) > + self.send_continuous_packet("ipv6", "dst", "2001::1", "1002::1", > self.tester_itf) > + out =3D self.dut.send_expect("stop", "testpmd> ", 120) > + self.check_packet_queue([1, 2], out) > + self.dut.send_expect("quit", "# ", 60) > + > + def test_ipv4_acl_jump(self): > + """ > + Set jump action using acl table. > + """ > + filename =3D "flow_ipv4_acl_jump_firmware.cli" > + port_num =3D 2 > + self.start_testpmd(filename, port_num) > + > + # create rule > + self.generate_rules(port=3Dport_num, group=3D1, dst_mask=3D"255.= 192.0.0", > dst_spec=3D"200.0.0.0", protomask=3Dself.protomask, sportmask=3Dself.port= mask, > dportmask=3Dself.portmask, sportspec=3D100, dportspec=3D200, index=3D[0]) > + self.generate_rules(port=3Dport_num, group=3D1, dst_mask=3D"255.= 192.0.0", > dst_spec=3D"200.64.0.0", protomask=3Dself.protomask, sportmask=3Dself.por= tmask, > dportmask=3Dself.portmask, sportspec=3D100, dportspec=3D200, index=3D[1]) > + self.generate_rules(port=3Dport_num, dst_mask=3D"255.192.0.0", > dst_spec=3D"200.0.0.0", protomask=3Dself.protomask, sportmask=3Dself.port= mask, > dportmask=3Dself.portmask, sportspec=3D100, dportspec=3D200, action=3D"ju= mp", > index=3D[1]) > + self.generate_rules(port=3Dport_num, dst_mask=3D"255.192.0.0", > dst_spec=3D"200.64.0.0", protomask=3Dself.protomask, sportmask=3Dself.por= tmask, > dportmask=3Dself.portmask, sportspec=3D100, dportspec=3D200, action=3D"ju= mp", > index=3D[1]) > + self.dut.send_expect("start", "testpmd> ", 60) > + > + # rule 0 test > + pcap_file =3D '/tmp/route_0.pcap' > + pkt =3D [Ether(dst=3Dself.dut_p0_mac)/IP(src=3D'0.0.0.0', dst=3D= '200.0.0.0', > proto=3D17)/UDP(sport=3D100, dport=3D200)/('X'*48)] > + self.send_and_check_packets(pcap_file, pkt, "ipv4", "dst", "200.= 0.0.0", 0, 0) > + > + # rule 1 test > + pcap_file =3D '/tmp/route_1.pcap' > + pkt =3D [Ether(dst=3Dself.dut_p0_mac)/IP(src=3D'0.0.0.0', dst=3D= '200.64.0.0', > proto=3D17)/UDP(sport=3D100, dport=3D200)/('X'*48)] > + self.send_and_check_packets(pcap_file, pkt, "ipv4", "dst", "200.= 64.0.0", 0, > 1) > + > + # destroy rules of group 1 > + self.dut.send_expect("flow destroy 2 rule 0", "testpmd> ", 60) > + self.dut.send_expect("flow destroy 2 rule 1", "testpmd> ", 60) > + destroy_out =3D self.dut.send_expect("flow list 2", "testpmd> ",= 60) > + self.verify("QUEUE" not in destroy_out, "destroy rule fail") > + > + # rule 2 test > + pcap_file =3D '/tmp/route_1.pcap' > + pkt =3D [Ether(dst=3Dself.dut_p0_mac)/IP(src=3D'0.0.0.0', dst=3D= '200.0.0.0', > proto=3D17)/UDP(sport=3D100, dport=3D200)/('X'*48)] > + self.write_pcap_file(pcap_file, pkt) > + filters =3D "dst host 200.0.0.0" > + sniff_pkts =3D self.send_and_sniff_pkts(0, 0, pcap_file, filters= ) > + dst_ip_list =3D [] > + for packet in sniff_pkts: > + dst_ip_list.append(packet.getlayer(1).dst) > + self.verify("200.0.0.0" not in dst_ip_list, "rule 2 test fail") > + > + self.dut.send_expect("quit", "# ", 60) > + > + def test_ipv4_hash_jump(self): > + """ > + Set jump action using hash table. > + """ > + filename =3D "flow_ipv4_hash_jump_firmware.cli" > + port_num =3D 2 > + self.start_testpmd(filename, port_num) > + > + # create rule > + self.generate_rules(port=3Dport_num, group=3D1, src_mask=3Dself.= ipv4_mask, > dst_mask=3Dself.ipv4_mask, src_spec=3D"1.10.11.0", dst_spec=3D"2.20.21.0"= , > protomask=3Dself.protomask, sportspec=3D100, dportspec=3D200, index=3D[0]= ) > + self.generate_rules(port=3Dport_num, group=3D1, src_mask=3Dself.= ipv4_mask, > dst_mask=3Dself.ipv4_mask, src_spec=3D"1.10.11.1", dst_spec=3D"2.20.21.1"= , > protomask=3Dself.protomask, sportspec=3D100, dportspec=3D200, index=3D[1]= ) > + self.generate_rules(port=3Dport_num, src_mask=3Dself.ipv4_mask, > dst_mask=3Dself.ipv4_mask, src_spec=3D"1.10.11.0", dst_spec=3D"2.20.21.0"= , > protomask=3Dself.protomask, sportspec=3D100, dportspec=3D200, action=3D"j= ump", > index=3D[1]) > + self.generate_rules(port=3Dport_num, src_mask=3Dself.ipv4_mask, > dst_mask=3Dself.ipv4_mask, src_spec=3D"1.10.11.1", dst_spec=3D"2.20.21.1"= , > protomask=3Dself.protomask, sportspec=3D100, dportspec=3D200, action=3D"j= ump", > index=3D[1]) > + self.dut.send_expect("start", "testpmd> ", 60) > + > + # rule 0 test > + pcap_file =3D '/tmp/route_0.pcap' > + pkt =3D [Ether(dst=3Dself.dut_p0_mac)/IP(src=3D'1.10.11.0', dst= =3D'2.20.21.0', > proto=3D17)/UDP(sport=3D100, dport=3D200)/('X'*48)] > + self.send_and_check_packets(pcap_file, pkt, "ipv4", "dst", "2.20= .21.0", 0, 0) > + > + # rule 1 test > + pcap_file =3D '/tmp/route_1.pcap' > + pkt =3D [Ether(dst=3Dself.dut_p0_mac)/IP(src=3D'1.10.11.1', dst= =3D'2.20.21.1', > proto=3D17)/UDP(sport=3D100, dport=3D200)/('X'*48)] > + self.send_and_check_packets(pcap_file, pkt, "ipv4", "dst", "2.20= .21.1", 0, 1) > + > + # destroy rules of group 1 > + self.dut.send_expect("flow destroy 2 rule 0", "Flow rule #0 dest= royed", 60) > + self.dut.send_expect("flow destroy 2 rule 1", "Flow rule #1 dest= royed", 60) > + destroy_out =3D self.dut.send_expect("flow list 2", "testpmd> ",= 60) > + self.verify("QUEUE" not in destroy_out, "destroy rule fail") > + > + # rule 2 test > + pcap_file =3D '/tmp/route_1.pcap' > + pkt =3D [Ether(dst=3Dself.dut_p0_mac)/IP(src=3D'1.10.11.1', dst= =3D'2.20.21.1', > proto=3D17)/UDP(sport=3D100, dport=3D200)/('X'*48)] > + self.write_pcap_file(pcap_file, pkt) > + filters =3D "dst host 2.20.21.1" > + sniff_pkts =3D self.send_and_sniff_pkts(0, 1, pcap_file, filters= ) > + dst_ip_list =3D [] > + for packet in sniff_pkts: > + dst_ip_list.append(packet.getlayer(1).dst) > + self.verify("2.20.21.1" not in dst_ip_list, "rule 3 test fail") > + > + self.dut.send_expect("quit", "# ", 60) > + > + def test_ipv4_acl_hash_jump(self): > + """ > + Set jump action from acl table to hash table. > + """ > + filename =3D "flow_ipv4_acl_hash_jump_firmware.cli" > + port_num =3D 2 > + self.start_testpmd(filename, port_num) > + > + # create rule > + self.generate_rules(port=3Dport_num, group=3D1, src_mask=3Dself.= ipv4_mask, > dst_mask=3Dself.ipv4_mask, src_spec=3D"1.10.11.0", dst_spec=3D"2.20.21.0"= , > protomask=3Dself.protomask, sportmask=3Dself.portmask, dportmask=3Dself.p= ortmask, > sportspec=3D100, dportspec=3D200, index=3D[0]) > + self.generate_rules(port=3Dport_num, group=3D1, src_mask=3Dself.= ipv4_mask, > dst_mask=3Dself.ipv4_mask, src_spec=3D"1.10.11.1", dst_spec=3D"2.20.21.1"= , > protomask=3Dself.protomask, sportmask=3Dself.portmask, dportmask=3Dself.p= ortmask, > sportspec=3D100, dportspec=3D200, index=3D[1]) > + self.generate_rules(port=3Dport_num, src_mask=3Dself.ipv4_mask, > dst_mask=3Dself.ipv4_mask, src_spec=3D"1.10.11.0", dst_spec=3D"2.20.21.0"= , > protomask=3Dself.protomask, sportspec=3D100, dportspec=3D200, action=3D"j= ump", > index=3D[1]) > + self.generate_rules(port=3Dport_num, src_mask=3Dself.ipv4_mask, > dst_mask=3Dself.ipv4_mask, src_spec=3D"1.10.11.1", dst_spec=3D"2.20.21.1"= , > protomask=3Dself.protomask, sportspec=3D100, dportspec=3D200, action=3D"j= ump", > index=3D[1]) > + self.dut.send_expect("start", "testpmd> ", 60) > + > + # rule 0 test > + pcap_file =3D '/tmp/route_0.pcap' > + pkt =3D [Ether(dst=3Dself.dut_p0_mac)/IP(src=3D'1.10.11.0', dst= =3D'2.20.21.0', > proto=3D17)/UDP(sport=3D100, dport=3D200)/('X'*48)] > + self.send_and_check_packets(pcap_file, pkt, "ipv4", "dst", "2.20= .21.0", 0, 0) > + > + # rule 1 test > + pcap_file =3D '/tmp/route_1.pcap' > + pkt =3D [Ether(dst=3Dself.dut_p0_mac)/IP(src=3D'1.10.11.1', dst= =3D'2.20.21.1', > proto=3D17)/UDP(sport=3D100, dport=3D200)/('X'*48)] > + self.send_and_check_packets(pcap_file, pkt, "ipv4", "dst", "2.20= .21.1", 0, 1) > + > + # rule 2 test > + pcap_file =3D '/tmp/route_2.pcap' > + pkt =3D [Ether(dst=3Dself.dut_p0_mac)/IP(src=3D'1.10.11.0', dst= =3D'2.20.21.0', > proto=3D17)/UDP(sport=3D101, dport=3D200)/('X'*48)] > + self.write_pcap_file(pcap_file, pkt) > + self.send_pkts(0, pcap_file) > + > + # rule 3 test > + pcap_file =3D '/tmp/route_3.pcap' > + pkt =3D [Ether(dst=3Dself.dut_p0_mac)/IP(src=3D'1.10.11.1', dst= =3D'2.20.21.1', > proto=3D17)/UDP(sport=3D100, dport=3D201)/('X'*48)] > + self.write_pcap_file(pcap_file, pkt) > + self.send_pkts(0, pcap_file) > + > + self.check_status(4, 2, port_num) > + self.dut.send_expect("quit", "# ", 60) > + > + def test_ipv4_hash_acl_jump(self): > + """ > + Set jump action from hash table to acl table. > + """ > + filename =3D "flow_ipv4_hash_acl_jump_firmware.cli" > + port_num =3D 2 > + self.start_testpmd(filename, port_num) > + > + # create rule > + self.generate_rules(port=3Dport_num, group=3D1, src_mask=3Dself.= ipv4_mask, > dst_mask=3Dself.ipv4_mask, src_spec=3D"1.10.11.0", dst_spec=3D"2.20.21.0"= , > protomask=3Dself.protomask, sportspec=3D100, dportspec=3D200, index=3D[0]= ) > + self.generate_rules(port=3Dport_num, group=3D1, src_mask=3Dself.= ipv4_mask, > dst_mask=3Dself.ipv4_mask, src_spec=3D"1.10.11.1", dst_spec=3D"2.20.21.1"= , > protomask=3Dself.protomask, sportspec=3D100, dportspec=3D200, index=3D[1]= ) > + self.generate_rules(port=3Dport_num, src_mask=3Dself.ipv4_mask, > dst_mask=3D"255.255.255.0", src_spec=3D"1.10.11.0", dst_spec=3D"2.20.21.0= ", > protomask=3Dself.protomask, sportmask=3Dself.portmask, dportmask=3Dself.p= ortmask, > sportspec=3D100, dportspec=3D200, action=3D"jump", index=3D[1]) > + self.generate_rules(port=3Dport_num, src_mask=3Dself.ipv4_mask, > dst_mask=3D"255.255.255.0", src_spec=3D"1.10.11.1", dst_spec=3D"2.20.21.1= ", > protomask=3Dself.protomask, sportmask=3Dself.portmask, dportmask=3Dself.p= ortmask, > sportspec=3D100, dportspec=3D200, action=3D"jump", index=3D[1]) > + self.dut.send_expect("start", "testpmd> ", 60) > + > + # rule 0 test > + pcap_file =3D '/tmp/route_0.pcap' > + pkt =3D [Ether(dst=3Dself.dut_p0_mac)/IP(src=3D'1.10.11.0', dst= =3D'2.20.21.0', > proto=3D17)/UDP(sport=3D100, dport=3D200)/('X'*48)] > + self.send_and_check_packets(pcap_file, pkt, "ipv4", "dst", "2.20= .21.0", 0, 0) > + > + # rule 1 test > + pcap_file =3D '/tmp/route_1.pcap' > + pkt =3D [Ether(dst=3Dself.dut_p0_mac)/IP(src=3D'1.10.11.1', dst= =3D'2.20.21.1', > proto=3D17)/UDP(sport=3D100, dport=3D200)/('X'*48)] > + self.send_and_check_packets(pcap_file, pkt, "ipv4", "dst", "2.20= .21.1", 0, 1) > + > + # rule 2 test > + pcap_file =3D '/tmp/route_2.pcap' > + pkt =3D [Ether(dst=3Dself.dut_p0_mac)/IP(src=3D'1.10.11.0', dst= =3D'2.20.21.2', > proto=3D17)/UDP(sport=3D101, dport=3D200)/('X'*48)] > + self.write_pcap_file(pcap_file, pkt) > + self.send_pkts(0, pcap_file) > + > + # rule 3 test > + pcap_file =3D '/tmp/route_3.pcap' > + pkt =3D [Ether(dst=3Dself.dut_p0_mac)/IP(src=3D'1.10.11.1', dst= =3D'2.20.21.3', > proto=3D17)/UDP(sport=3D100, dport=3D201)/('X'*48)] > + self.write_pcap_file(pcap_file, pkt) > + self.send_pkts(0, pcap_file) > + > + self.check_status(4, 2, port_num) > + self.dut.send_expect("quit", "# ", 60) > + > + def test_ipv6_acl_jump(self): > + """ > + Set jump action with ipv6 acl table. > + """ > + filename =3D "flow_ipv6_acl_jump_firmware.cli" > + port_num =3D 2 > + self.start_testpmd(filename, port_num) > + > + # create rule > + self.generate_rules(port=3Dport_num, group=3D1, iptype=3D"ipv6", > dst_mask=3Dself.ipv6_mask, src_spec=3D"1001::1", dst_spec=3D"2001::1", > protomask=3Dself.protomask, sportmask=3Dself.portmask, dportmask=3Dself.p= ortmask, > sportspec=3D100, dportspec=3D200, index=3D[0]) > + self.generate_rules(port=3Dport_num, group=3D1, iptype=3D"ipv6", > src_mask=3Dself.ipv6_mask, dst_mask=3Dself.ipv6_mask, src_spec=3D"1001::1= ", > dst_spec=3D"2001::2", protomask=3Dself.protomask, sportmask=3Dself.portma= sk, > dportmask=3Dself.portmask, sportspec=3D100, dportspec=3D200, index=3D[1]) > + self.generate_rules(port=3Dport_num, iptype=3D"ipv6", > dst_mask=3Dself.ipv6_mask, src_spec=3D"1001::1", dst_spec=3D"2001::1", > protomask=3Dself.protomask, sportspec=3D100, dportspec=3D200, action=3D"j= ump", > index=3D[1]) > + self.generate_rules(port=3Dport_num, iptype=3D"ipv6", > dst_mask=3Dself.ipv6_mask, src_spec=3D"1001::1", dst_spec=3D"2001::2", > protomask=3Dself.protomask, sportspec=3D100, dportspec=3D200, action=3D"j= ump", > index=3D[1]) > + self.dut.send_expect("start", "testpmd> ", 60) > + > + # rule 0 test > + pcap_file =3D '/tmp/route_0.pcap' > + pkt =3D [Ether(dst=3Dself.dut_p0_mac)/IPv6(src=3D"1001::1", > dst=3D"2001::1")/UDP(sport=3D100, dport=3D200)/('X'*48)] > + self.send_and_check_packets(pcap_file, pkt, "ipv6", "dst", "2001= ::1", 0, 0) > + > + # rule 1 test > + pcap_file =3D '/tmp/route_1.pcap' > + pkt =3D [Ether(dst=3Dself.dut_p0_mac)/IPv6(src=3D"1001::1", > dst=3D"2001::2")/UDP(sport=3D100, dport=3D200)/('X'*48)] > + self.send_and_check_packets(pcap_file, pkt, "ipv6", "dst", "2001= ::2", 0, 1) > + > + pcap_file =3D '/tmp/route_2.pcap' > + pkt =3D [Ether(dst=3Dself.dut_p0_mac)/IPv6(src=3D"1001::2", > dst=3D"2001::1")/UDP(sport=3D100, dport=3D200)/('X'*48)] > + self.send_and_check_packets(pcap_file, pkt, "ipv6", "dst", "2001= ::1", 0, 0) > + > + pcap_file =3D '/tmp/route_3.pcap' > + pkt =3D [Ether(dst=3Dself.dut_p0_mac)/IPv6(src=3D"1001::2", > dst=3D"2001::2")/UDP(sport=3D100, dport=3D200)/('X'*48)] > + self.write_pcap_file(pcap_file, pkt) > + self.send_pkts(0, pcap_file) > + > + self.check_status(4, 3, port_num) > + self.dut.send_expect("quit", "# ", 60) > + > + def test_ipv6_hash_jump(self): > + """ > + Set jump action with ipv6 hash table. > + """ > + filename =3D "flow_ipv6_hash_jump_firmware.cli" > + port_num =3D 2 > + self.start_testpmd(filename, port_num) > + > + # create rule > + self.generate_rules(port=3Dport_num, group=3D1, iptype=3D"ipv6", > src_mask=3Dself.ipv6_mask, dst_mask=3Dself.ipv6_mask, src_spec=3D"1001::1= ", > dst_spec=3D"2001::1", protomask=3Dself.protomask, sportmask=3Dself.portma= sk, > dportmask=3Dself.portmask, sportspec=3D100, dportspec=3D200, index=3D[0]) > + self.generate_rules(port=3Dport_num, group=3D1, iptype=3D"ipv6", > src_mask=3Dself.ipv6_mask, dst_mask=3Dself.ipv6_mask, src_spec=3D"1001::2= ", > dst_spec=3D"2001::2", protomask=3Dself.protomask, protospec=3D6, l4type= =3D"tcp", > sportmask=3Dself.portmask, dportmask=3Dself.portmask, sportspec=3D100, > dportspec=3D200, index=3D[1]) > + self.generate_rules(port=3Dport_num, iptype=3D"ipv6", > src_mask=3Dself.ipv6_mask, dst_mask=3Dself.ipv6_mask, src_spec=3D"1001::1= ", > dst_spec=3D"2001::1", protomask=3Dself.protomask, sportmask=3Dself.portma= sk, > dportmask=3Dself.portmask, sportspec=3D100, dportspec=3D200, action=3D"ju= mp", > index=3D[1]) > + self.generate_rules(port=3Dport_num, iptype=3D"ipv6", > src_mask=3Dself.ipv6_mask, dst_mask=3Dself.ipv6_mask, src_spec=3D"1001::2= ", > dst_spec=3D"2001::2", protomask=3Dself.protomask, protospec=3D6, l4type= =3D"tcp", > sportmask=3Dself.portmask, dportmask=3Dself.portmask, sportspec=3D100, > dportspec=3D200, action=3D"jump", index=3D[1]) > + self.dut.send_expect("start", "testpmd> ", 60) > + > + # rule 0 test > + pcap_file =3D '/tmp/route_0.pcap' > + pkt =3D [Ether(dst=3Dself.dut_p0_mac)/IPv6(src=3D"1001::1", > dst=3D"2001::1")/UDP(sport=3D100, dport=3D200)/('X'*48)] > + self.send_and_check_packets(pcap_file, pkt, "ipv6", "dst", "2001= ::1", 0, 0) > + > + # rule 1 test > + pcap_file =3D '/tmp/route_1.pcap' > + pkt =3D [Ether(dst=3Dself.dut_p0_mac)/IPv6(src=3D"1001::2", > dst=3D"2001::2")/TCP(sport=3D100, dport=3D200)/('X'*48)] > + self.send_and_check_packets(pcap_file, pkt, "ipv6", "dst", "2001= ::2", 0, 1) > + > + # destroy rules of group 1 > + self.dut.send_expect("flow destroy 2 rule 0", "Flow rule #0 dest= royed", 60) > + self.dut.send_expect("flow destroy 2 rule 1", "Flow rule #1 dest= royed", 60) > + destroy_out =3D self.dut.send_expect("flow list 2", "testpmd> ",= 60) > + self.verify("QUEUE" not in destroy_out, "destroy rule fail") > + > + # rule 2 test > + pcap_file =3D '/tmp/route_2.pcap' > + pkt =3D [Ether(dst=3Dself.dut_p0_mac)/IPv6(src=3D"1001::1", > dst=3D"2001::1")/UDP(sport=3D100, dport=3D200)/('X'*48)] > + self.write_pcap_file(pcap_file, pkt) > + filters =3D "dst host 2001::1" > + sniff_pkts =3D self.send_and_sniff_pkts(0, 0, pcap_file, filters= ) > + dst_ip_list =3D [] > + for packet in sniff_pkts: > + dst_ip_list.append(packet.getlayer(1).dst) > + self.verify("2001::1" not in dst_ip_list, "rule 2 test fail") > + > + self.dut.send_expect("quit", "# ", 60) > + > + def test_ipv6_acl_hash_jump(self): > + """ > + Set jump action from ipv6 acl table to hash table. > + """ > + filename =3D "flow_ipv6_acl_hash_jump_firmware.cli" > + port_num =3D 2 > + self.start_testpmd(filename, port_num) > + > + # create rule > + self.generate_rules(port=3Dport_num, group=3D1, iptype=3D"ipv6", > src_mask=3Dself.ipv6_mask, dst_mask=3Dself.ipv6_mask, src_spec=3D"1001::1= ", > dst_spec=3D"2001::1", protomask=3Dself.protomask, sportmask=3Dself.portma= sk, > dportmask=3Dself.portmask, sportspec=3D100, dportspec=3D200, index=3D[0]) > + self.generate_rules(port=3Dport_num, group=3D1, iptype=3D"ipv6", > src_mask=3Dself.ipv6_mask, dst_mask=3Dself.ipv6_mask, src_spec=3D"1001::2= ", > dst_spec=3D"2001::2", protomask=3Dself.protomask, sportmask=3Dself.portma= sk, > dportmask=3Dself.portmask, sportspec=3D100, dportspec=3D200, index=3D[1]) > + self.generate_rules(port=3Dport_num, iptype=3D"ipv6", > dst_mask=3Dself.ipv6_mask, src_spec=3D"1001::1", dst_spec=3D"2001::1", > protomask=3Dself.protomask, sportspec=3D100, dportspec=3D200, action=3D"j= ump", > index=3D[1]) > + self.generate_rules(port=3Dport_num, iptype=3D"ipv6", > dst_mask=3Dself.ipv6_mask, src_spec=3D"1001::2", dst_spec=3D"2001::2", > protomask=3Dself.protomask, sportspec=3D100, dportspec=3D200, action=3D"j= ump", > index=3D[1]) > + self.dut.send_expect("start", "testpmd> ", 60) > + > + # rule 0 test > + pcap_file =3D '/tmp/route_0.pcap' > + pkt =3D [Ether(dst=3Dself.dut_p0_mac)/IPv6(src=3D"1001::1", > dst=3D"2001::1")/UDP(sport=3D100, dport=3D200)/('X'*48)] > + self.send_and_check_packets(pcap_file, pkt, "ipv6", "dst", "2001= ::1", 0, 0) > + > + # rule 1 test > + pcap_file =3D '/tmp/route_1.pcap' > + pkt =3D [Ether(dst=3Dself.dut_p0_mac)/IPv6(src=3D"1001::2", > dst=3D"2001::2")/UDP(sport=3D100, dport=3D200)/('X'*48)] > + self.send_and_check_packets(pcap_file, pkt, "ipv6", "dst", "2001= ::2", 0, 1) > + > + pcap_file =3D '/tmp/route_2.pcap' > + pkt =3D [Ether(dst=3Dself.dut_p0_mac)/IPv6(src=3D"1001::3", > dst=3D"2001::1")/UDP(sport=3D100, dport=3D200)/('X'*48)] > + self.write_pcap_file(pcap_file, pkt) > + self.send_pkts(0, pcap_file) > + > + pcap_file =3D '/tmp/route_3.pcap' > + pkt =3D [Ether(dst=3Dself.dut_p0_mac)/IPv6(src=3D"1001::4", > dst=3D"2001::2")/UDP(sport=3D100, dport=3D200)/('X'*48)] > + self.write_pcap_file(pcap_file, pkt) > + self.send_pkts(0, pcap_file) > + > + self.check_status(4, 2, port_num) > + self.dut.send_expect("quit", "# ", 60) > + > + def test_ipv6_hash_acl_jump(self): > + """ > + Set jump action from ipv6 hash table to acl table. > + """ > + filename =3D "flow_ipv6_hash_acl_jump_firmware.cli" > + port_num =3D 2 > + self.start_testpmd(filename, port_num) > + > + # create rule > + self.generate_rules(port=3Dport_num, group=3D1, iptype=3D"ipv6", > dst_mask=3Dself.ipv6_mask, src_spec=3D"1001::1", dst_spec=3D"2001::1", > protomask=3Dself.protomask, sportmask=3Dself.portmask, dportmask=3Dself.p= ortmask, > sportspec=3D100, dportspec=3D200, index=3D[0]) > + self.generate_rules(port=3Dport_num, group=3D1, iptype=3D"ipv6", > src_mask=3Dself.ipv6_mask, dst_mask=3Dself.ipv6_mask, src_spec=3D"1001::2= ", > dst_spec=3D"2001::2", protomask=3Dself.protomask, dportmask=3Dself.portma= sk, > sportspec=3D100, dportspec=3D200, index=3D[1]) > + self.generate_rules(port=3Dport_num, iptype=3D"ipv6", > src_mask=3Dself.ipv6_mask, dst_mask=3Dself.ipv6_mask, src_spec=3D"1001::1= ", > dst_spec=3D"2001::1", protomask=3Dself.protomask, sportmask=3Dself.portma= sk, > sportspec=3D100, dportspec=3D200, action=3D"jump", index=3D[1]) > + self.generate_rules(port=3Dport_num, iptype=3D"ipv6", > src_mask=3Dself.ipv6_mask, dst_mask=3Dself.ipv6_mask, src_spec=3D"1001::2= ", > dst_spec=3D"2001::2", protomask=3Dself.protomask, sportmask=3Dself.portma= sk, > sportspec=3D100, dportspec=3D200, action=3D"jump", index=3D[1]) > + self.dut.send_expect("start", "testpmd> ", 60) > + > + # rule 0 test > + pcap_file =3D '/tmp/route_0.pcap' > + pkt =3D [Ether(dst=3Dself.dut_p0_mac)/IPv6(src=3D"1001::1", > dst=3D"2001::1")/UDP(sport=3D100, dport=3D200)/('X'*48)] > + self.send_and_check_packets(pcap_file, pkt, "ipv6", "dst", "2001= ::1", 0, 0) > + > + # rule 1 test > + pcap_file =3D '/tmp/route_1.pcap' > + pkt =3D [Ether(dst=3Dself.dut_p0_mac)/IPv6(src=3D"1001::2", > dst=3D"2001::2")/UDP(sport=3D100, dport=3D200)/('X'*48)] > + self.send_and_check_packets(pcap_file, pkt, "ipv6", "dst", "2001= ::2", 0, 1) > + > + pcap_file =3D '/tmp/route_2.pcap' > + pkt =3D [Ether(dst=3Dself.dut_p0_mac)/IPv6(src=3D"1001::1", > dst=3D"2001::1")/UDP(sport=3D100, dport=3D201)/('X'*48)] > + self.write_pcap_file(pcap_file, pkt) > + self.send_pkts(0, pcap_file) > + > + pcap_file =3D '/tmp/route_3.pcap' > + pkt =3D [Ether(dst=3Dself.dut_p0_mac)/IPv6(src=3D"1001::2", > dst=3D"2001::2")/UDP(sport=3D100, dport=3D202)/('X'*48)] > + self.write_pcap_file(pcap_file, pkt) > + self.send_pkts(0, pcap_file) > + > + self.check_status(4, 2, port_num) > + self.dut.send_expect("quit", "# ", 60) > + > + def tear_down(self): > + > + """ > + Run after each test case. > + """ > + pass > + > + def tear_down_all(self): > + """ > + Run after each test suite. > + """ > + self.dut.kill_all() > -- > 2.5.0