def setup_1pf_2vf_1vm_env(self, driver='default'): self.used_dut_port = self.dut_ports[0] self.dut.generate_sriov_vfs_by_port(self.used_dut_port, 2, driver=driver) self.sriov_vfs_port = self.dut.ports_info[self.used_dut_port]['vfs_port'] try: for port in self.sriov_vfs_port: port.bind_driver(self.vf_driver) time.sleep(1) vf0_prop = {'opt_host': self.sriov_vfs_port[0].pci} vf1_prop = {'opt_host': self.sriov_vfs_port[1].pci} if driver == 'igb_uio': # start testpmd without the two VFs on the host self.host_testpmd = PmdOutput(self.dut) eal_param = '-b %(vf0)s -b %(vf1)s' % {'vf0': self.sriov_vfs_port[0].pci, 'vf1': self.sriov_vfs_port[1].pci} self.host_testpmd.start_testpmd("1S/2C/2T", eal_param=eal_param) # set up VM0 ENV self.vm0 = QEMUKvm(self.dut, 'vm0', 'vf_port_start_stop') self.vm0.set_vm_device(driver=self.vf_assign_method, **vf0_prop) self.vm0.set_vm_device(driver=self.vf_assign_method, **vf1_prop) self.vm_dut_0 = self.vm0.start() if self.vm_dut_0 is None: raise Exception("Set up VM0 ENV failed!") self.setup_1pf_2vf_1vm_env_flag = 1 except Exception as e: self.destroy_1pf_2vf_1vm_env() raise Exception(e)
def set_up_all(self): """ Run at the start of each test suite. New rx tx offload API Prerequisites """ self.verify( self.nic in [ "fortville_eagle", "fortville_spirit", "fortville_spirit_single", "niantic" ], "NIC Unsupported: " + str(self.nic)) # Based on h/w type, choose how many ports to use self.dut_ports = self.dut.get_ports(self.nic) # Verify that enough ports are available self.verify(len(self.dut_ports) >= 2, "Insufficient ports") localPort0 = self.tester.get_local_port(self.dut_ports[0]) localPort1 = self.tester.get_local_port(self.dut_ports[1]) self.tester_itf0 = self.tester.get_interface(localPort0) self.tester_itf1 = self.tester.get_interface(localPort1) self.tester_mac0 = self.tester.get_mac(localPort0) self.pf_interface = self.dut.ports_info[self.dut_ports[0]]['intf'] self.pf_mac = self.dut.get_mac_address(0) self.pf_pci = self.dut.ports_info[self.dut_ports[0]]['pci'] self.pmdout = PmdOutput(self.dut) self.cores = "1S/4C/1T" self.jumbo_pkt1 = r'sendp([Ether(dst="%s")/IP(dst="192.168.0.1",src="192.168.0.2", len=8981)/Raw(load="P"*8961)], iface="%s")' % ( self.pf_mac, self.tester_itf0) self.jumbo_pkt2 = r'sendp([Ether(dst="%s")/IP(dst="192.168.0.1",src="192.168.0.3", len=8981)/Raw(load="P"*8961)], iface="%s")' % ( self.pf_mac, self.tester_itf0) self.vlan_pkt1 = r'sendp([Ether(dst="%s")/Dot1Q(vlan=1)/IP(src="192.168.0.1",dst="192.168.0.3")/UDP(sport=33, dport=34)/Raw("x"*20)], iface="%s")' % ( self.pf_mac, self.tester_itf0) self.vlan_pkt2 = r'sendp([Ether(dst="%s")/Dot1Q(vlan=1)/IP(src="192.168.0.2",dst="192.168.0.3")/UDP(sport=33, dport=34)/Raw("x"*20)], iface="%s")' % ( self.pf_mac, self.tester_itf0)
def setup_vm_env(self, driver='igb_uio'): """ Create testing environment with VF generated from 1PF """ if self.env_done is False: self.bind_nic_driver(self.dut_ports[:1], driver="igb_uio") self.used_dut_port = self.dut_ports[0] tester_port = self.tester.get_local_port(self.used_dut_port) self.tester_intf = self.tester.get_interface(tester_port) self.dut.generate_sriov_vfs_by_port(self.used_dut_port, 1, driver=driver) self.sriov_vfs_port = self.dut.ports_info[ self.used_dut_port]['vfs_port'] for port in self.sriov_vfs_port: port.bind_driver('pci-stub') time.sleep(1) self.dut_testpmd = PmdOutput(self.dut) time.sleep(1) vf0_prop = {'opt_host': self.sriov_vfs_port[0].pci} # set up VM0 ENV self.vm0 = QEMUKvm(self.dut, 'vm0', 'ddp_gtp') self.vm0.set_vm_device(driver='pci-assign', **vf0_prop) try: self.vm0_dut = self.vm0.start() if self.vm0_dut is None: raise Exception("Set up VM0 ENV failed!") except Exception as e: self.destroy_vm_env() raise Exception(e) self.vm0_dut_ports = self.vm0_dut.get_ports('any') self.vm0_testpmd = PmdOutput(self.vm0_dut) self.env_done = True
def test_kernel_2pf_2vf_1vm_iplink_macfilter(self): self.setup_2pf_2vf_1vm_env(driver='') self.vm0_dut_ports = self.vm_dut_0.get_ports('any') self.vm0_testpmd = PmdOutput(self.vm_dut_0) self.vm0_testpmd.start_testpmd(VM_CORES_MASK) # Get VF's MAC pmd_vf0_mac = self.vm0_testpmd.get_port_mac(0) vf0_wrongmac = "00:11:22:33:48:55" self.vm0_testpmd.execute_cmd('set promisc all off') self.vm0_testpmd.execute_cmd('set fwd mac') self.vm0_testpmd.execute_cmd('start') time.sleep(2) tgen_ports = [] tx_port = self.tester.get_local_port(self.dut_ports[0]) rx_port = self.tester.get_local_port(self.dut_ports[1]) tgen_ports.append((tx_port, rx_port)) dst_mac = self.pf0_vf0_mac src_mac = self.tester.get_mac(tx_port) pkt_param=[("ether", {'dst': dst_mac, 'src': src_mac})] print "\nfirst send packets to the kernel PF set MAC, expected result is RX packets=TX packets\n" result1 = self.tester.check_random_pkts(tgen_ports, pktnum=100, allow_miss=False, params=pkt_param) print "\nshow port stats in testpmd for double check: \n", self.vm0_testpmd.execute_cmd('show port stats all') self.verify(result1 != False, "VF0 failed to forward packets to VF1") print "\nSecondly, negative test, send packets to a wrong MAC, expected result is RX packets=0\n" dst_mac = vf0_wrongmac pkt_param=[("ether", {'dst': dst_mac, 'src': src_mac})] result2 = self.tester.check_random_pkts(tgen_ports, pktnum=100, allow_miss=False, params=pkt_param) print "\nshow port stats in testpmd for double check: \n", self.vm0_testpmd.execute_cmd('show port stats all') self.verify(result2 != True, "VF0 failed to forward packets to VF1")
def set_up_all(self): """ Prerequisite steps for each test suit. """ self.dut_ports = self.dut.get_ports() self.verify(len(self.dut_ports) >= 1, "Insufficient ports") self.rx_port = self.dut_ports[0] self.tx_port = self.dut_ports[0] cores = self.dut.get_core_list("1S/2C/1T") self.coremask = utils.create_mask(cores) self.port_mask = utils.create_mask([self.rx_port, self.tx_port]) if self.kdriver == "fm10k": netobj = self.dut.ports_info[self.tx_port]['port'] netobj.enable_jumbo(framesize=ETHER_JUMBO_FRAME_MTU) netobj = self.dut.ports_info[self.rx_port]['port'] netobj.enable_jumbo(framesize=ETHER_JUMBO_FRAME_MTU) self.tester.send_expect( "ifconfig %s mtu %s" % (self.tester.get_interface(self.tester.get_local_port( self.rx_port)), ETHER_JUMBO_FRAME_MTU + 200), "# ") # self.tester.send_expect("ifconfig %s mtu %s" % (self.tester.get_interface(self.tester.get_local_port(self.tx_port)), ETHER_JUMBO_FRAME_MTU + 200), "# ") self.pmdout = PmdOutput(self.dut)
def set_up_all(self): """ Run at the start of each test suite. Whitelist Prerequistites: Two Ports testpmd can normally started """ self.frames_to_send = 1 # Based on h/w type, choose how many ports to use self.dutPorts = self.dut.get_ports() # Verify that enough ports are available self.verify(len(self.dutPorts) >= 1, "Insufficient ports") portMask = dts.create_mask(self.dutPorts[:2]) self.pmdout = PmdOutput(self.dut) self.pmdout.start_testpmd("1S/2C/1T", "--portmask=%s" % portMask) self.dut.send_expect("set verbose 1", "testpmd> ") # get dest address from self.target port out = self.dut.send_expect("show port info %d" % self.dutPorts[0], "testpmd> ") self.dest = self.dut.get_mac_address(self.dutPorts[0]) mac_scanner = r"MAC address: (([\dA-F]{2}:){5}[\dA-F]{2})" ret = dts.regexp(out, mac_scanner) self.verify(ret is not None, "MAC address not found") self.verify(cmp(ret.lower(), self.dest) == 0, "MAC address wrong") self.max_mac_addr = dts.regexp( out, "Maximum number of MAC addresses: ([0-9]+)")
def set_up_all(self): """ Run at the start of each test suite. Vlan Prerequistites """ global dutRxPortId global dutTxPortId # Based on h/w type, choose how many ports to use ports = self.dut.get_ports(self.nic) self.verify(len(ports) >= 2, "Insufficient ports") self.ports_socket = self.dut.get_numa_id(ports[0]) cores = self.dut.get_core_list('1S/2C/2T') coreMask = utils.create_mask(cores) ports = self.dut.get_ports(self.nic) valports = [_ for _ in ports if self.tester.get_local_port(_) != -1] portMask = utils.create_mask(valports[:2]) dutRxPortId = valports[0] dutTxPortId = valports[1] self.pmdout = PmdOutput(self.dut) self.pmdout.start_testpmd("Default", "--portmask=%s" % portMask, socket=self.ports_socket) if self.nic in ["fortville_eagle", "fortville_spirit", "fortville_spirit_single", "fortville_25g", "fortpark_TLV"]: self.dut.send_expect("vlan set filter on all", "testpmd> ") self.dut.send_expect("set promisc all off", "testpmd> ") out = self.dut.send_expect("set fwd mac", "testpmd> ") self.verify('Set mac packet forwarding mode' in out, "set fwd mac error") out = self.dut.send_expect("start", "testpmd> ", 120)
def set_up_all(self): """ Run at the start of each test suite. Scatter Prerequistites """ dutPorts = self.dut.get_ports(self.nic) # Verify that enough ports are available self.verify(len(dutPorts) >= 1, "Insufficient ports") self.port = dutPorts[0] tester_port = self.tester.get_local_port(self.port) self.intf = self.tester.get_interface(tester_port) self.pmdout = PmdOutput(self.dut) if self.nic in ["magnolia_park", "niantic", "sageville", "fortpark", "fortville_eagle", "fortville_spirit", "fortville_spirit_single", "redrockcanyou", "atwood", "boulderrapid", "ironpond", "twinpond", "springfountain", "fortpark_TLV"]: self.mbsize = 2048 else: self.mbsize = 1024 if self.kdriver == "fm10k": self.dut.ports_info[self.port]['port'].enable_jumbo(framesize=9000) self.tester.send_expect("ifconfig %s mtu 9000" % self.intf, "#")
def set_up_all(self): """ Run at the start of each test suite. Queue region Prerequisites """ self.verify( self.nic in [ "fortville_eagle", "fortville_spirit", "fortville_spirit_single", "fortpark_TLV" ], "NIC Unsupported: " + str(self.nic)) # Based on h/w type, choose how many ports to use self.dut_ports = self.dut.get_ports(self.nic) # Verify that enough ports are available self.verify(len(self.dut_ports) >= 1, "Insufficient ports") localPort = self.tester.get_local_port(self.dut_ports[0]) self.tester_intf = self.tester.get_interface(localPort) self.tester_mac = self.tester.get_mac(localPort) self.pf_interface = self.dut.ports_info[self.dut_ports[0]]['intf'] self.pf_mac = self.dut.get_mac_address(0) self.pf_pci = self.dut.ports_info[self.dut_ports[0]]['pci'] self.pmdout = PmdOutput(self.dut) self.cores = "1S/4C/1T" self.pmdout.start_testpmd("%s" % self.cores, "--rxq=16 --txq=16") self.dut.send_expect("port config all rss all", "testpmd> ", 120) self.dut.send_expect("set fwd rxonly", "testpmd> ", 120) self.dut.send_expect("set verbose 1", "testpmd> ", 120) self.dut.send_expect("start", "testpmd> ", 120) time.sleep(2)
def test_pvid_vf_tx(self): """ Add port based vlan on vf device and check vlan tx work """ random_vlan = random.randint(1, MAX_VLAN) self.dut.send_expect( "ip link set %s vf 0 vlan %d" % (self.host_intf0, random_vlan), "# ") out = self.dut.send_expect("ip link show %s" % self.host_intf0, "# ") self.verify("vlan %d" % random_vlan in out, "Failed to add pvid on VF0") self.vm0_dut_ports = self.vm_dut_0.get_ports('any') self.vm0_testpmd = PmdOutput(self.vm_dut_0) self.vm0_testpmd.start_testpmd(VM_CORES_MASK) self.vm0_testpmd.execute_cmd('set fwd mac') self.vm0_testpmd.execute_cmd('start') pkt = Packet(pkt_type='UDP') pkt.config_layer('ether', {'dst': self.vf1_mac}) inst = self.tester.tcpdump_sniff_packets(self.tester_intf0, timeout=5) pkt.send_pkt(tx_port=self.tester_intf1) pkts = self.tester.load_tcpdump_sniff_packets(inst) self.verify(len(pkts), "Not receive expected packet") self.vm0_testpmd.quit() # disable pvid self.dut.send_expect("ip link set %s vf 0 vlan 0" % (self.host_intf0), "# ")
def packet_rx_tx(self, driver='default'): if driver == 'igb_uio': self.setup_2pf_2vf_1vm_env(driver='igb_uio') else: self.setup_2pf_2vf_1vm_env(driver='') self.vm0_dut_ports = self.vm_dut_0.get_ports('any') port_id_0 = 0 self.vm0_testpmd = PmdOutput(self.vm_dut_0) out = self.vm0_testpmd.start_testpmd(VM_CORES_MASK) pmd_vf0_mac = self.vm0_testpmd.get_port_mac(port_id_0) self.vm0_testpmd.execute_cmd('set fwd mac') self.vm0_testpmd.execute_cmd('start') time.sleep(2) tgen_ports = [] tx_port = self.tester.get_local_port(self.dut_ports[0]) rx_port = self.tester.get_local_port(self.dut_ports[1]) tgen_ports.append((tx_port, rx_port)) dst_mac = pmd_vf0_mac src_mac = self.tester.get_mac(tx_port) pkt_param = [("ether", {'dst': dst_mac, 'src': src_mac})] result = self.tester.check_random_pkts(tgen_ports, allow_miss=False, params=pkt_param) print self.vm0_testpmd.execute_cmd('show port stats all') self.verify(result != False, "VF0 failed to forward packets to VF1")
def test_2vf_d2d_pktgen_stream(self): self.vm0_ports = self.vm0_dut.get_ports('any') self.vm0_pmd = PmdOutput(self.vm0_dut) self.vm0_pmd.start_testpmd('all') self.vm0_pmd.execute_cmd('set fwd rxonly') self.vm0_pmd.execute_cmd("set promisc all off") self.vm0_pmd.execute_cmd('start') self.vm1_ports = self.vm1_dut.get_ports('any') self.prepare_pktgen(self.vm1_dut) dst = {} dst['server'] = self.vm0_dut dst['ether'] = self.vm0_dut.ports_info[self.vm0_ports[0]]['mac'] src = {} src['server'] = self.vm1_dut src['ether'] = self.vm1_dut.ports_info[self.vm1_ports[0]]['mac'] load = {} load['content'] = "'X'*46" self.generate_pcap_pkt(dst, src, load) self.vm0_pmd.execute_cmd('clear port stats all') self.send_stream_pktgen(self.vm1_dut) recv_num = self.vm0_pmd.get_pmd_stats(0)['RX-packets'] time.sleep(1) self.stop_stream_pktgen(self.vm1_dut) self.vm0_pmd.execute_cmd('stop') self.vm0_pmd.execute_cmd('quit', '# ') self.verify(recv_num is SEND_PACKET, 'Rx port recv error: %d' % recv_num)
def test_vf_vlan_tx(self): self.verify(self.kdriver not in ["ixgbe"], "NIC Unsupported: " + str(self.nic)) random_vlan = random.randint(1, MAX_VLAN) tx_vlans = [1, random_vlan, MAX_VLAN] # start testpmd in VM self.vm0_dut_ports = self.vm_dut_0.get_ports('any') self.vm0_testpmd = PmdOutput(self.vm_dut_0) self.vm0_testpmd.start_testpmd(VM_CORES_MASK) self.vm0_testpmd.execute_cmd('set verbose 1') for tx_vlan in tx_vlans: # for fortville , # if you want insert tx_vlan, # please enable rx_vlan at the same time if self.kdriver == "i40e": self.vm0_testpmd.execute_cmd('rx_vlan add %d 0' % tx_vlan) self.vm0_testpmd.execute_cmd('stop') self.vm0_testpmd.execute_cmd('port stop all') self.vm0_testpmd.execute_cmd('tx_vlan set 0 %d' % tx_vlan) self.vm0_testpmd.execute_cmd('port start all') self.tx_and_check(tx_vlan=tx_vlan) self.vm0_testpmd.quit()
def set_up_all(self): """ Run at the start of each test suite. IEEE1588 Prerequisites """ dutPorts = self.dut.get_ports() self.verify(len(dutPorts) > 0, "No ports found for " + self.nic) # Change the config file to support IEEE1588 and recompile the package. if "bsdapp" in self.target: self.dut.send_expect( "sed -i -e 's/IEEE1588=n$/IEEE1588=y/' config/common_bsdapp", "# ", 30) else: self.dut.send_expect( "sed -i -e 's/IEEE1588=n$/IEEE1588=y/' config/common_linuxapp", "# ", 30) self.dut.skip_setup = False self.dut.build_install_dpdk(self.target) self.pmdout = PmdOutput(self.dut) self.pmdout.start_testpmd("all")
def test_2vf_k2d_scapy_stream(self): self.vm0_ports = self.vm0_dut.get_ports('any') self.vm0_pmd = PmdOutput(self.vm0_dut) self.vm0_pmd.start_testpmd('all') self.vm1_ports = self.vm1_dut.get_ports('any') self.vm1_dut.restore_interfaces() vf1_intf = self.vm1_dut.ports_info[self.vm1_ports[0]]['intf'] dst_mac = self.vm0_dut.ports_info[self.vm0_ports[0]]['mac'] src_mac = self.vm1_dut.ports_info[self.vm1_ports[0]]['mac'] pkt_content = 'Ether(dst="%s", src="%s")/IP()/Raw(load="X"*46)' % \ (dst_mac, src_mac) self.vm1_dut.send_expect('scapy', '>>> ', 10) self.vm0_pmd.execute_cmd('set promisc all off') self.vm0_pmd.execute_cmd('set fwd rxonly') self.vm0_pmd.execute_cmd('set verbose 1') self.vm0_pmd.execute_cmd('start') self.vm1_dut.send_expect('sendp([%s], iface="%s", count=%d)' % (pkt_content, vf1_intf, SEND_PACKET), '>>> ', 30) out = self.vm0_dut.get_session_output(timeout=60) rx_packets = re.findall("src=%s - dst=%s" % (src_mac, dst_mac), out) recv_num = len(rx_packets) self.vm1_dut.send_expect('quit()', '# ', 10) self.vm1_dut.bind_interfaces_linux(self.drivername) self.vm0_pmd.execute_cmd('stop') self.vm0_pmd.execute_cmd('quit', '# ') self.verify(recv_num is SEND_PACKET, 'Rx port recv error: %d' % recv_num)
def test_vf_vlan_strip(self): random_vlan = random.randint(1, MAX_VLAN - 1) rx_vlans = [1, random_vlan, MAX_VLAN] # start testpmd in VM self.vm0_dut_ports = self.vm_dut_0.get_ports('any') self.vm0_testpmd = PmdOutput(self.vm_dut_0) if self.kdriver == "i40e": self.vm0_testpmd.start_testpmd(VM_CORES_MASK, '') else: self.vm0_testpmd.start_testpmd(VM_CORES_MASK) self.vm0_testpmd.execute_cmd('set fwd rxonly') self.vm0_testpmd.execute_cmd('set verbose 1') self.vm0_testpmd.execute_cmd('start') for rx_vlan in rx_vlans: self.vm0_testpmd.execute_cmd('vlan set strip on 0') self.vm0_testpmd.execute_cmd('rx_vlan add %d 0' % rx_vlan) time.sleep(1) out = self.send_and_getout(vlan=rx_vlan, pkt_type="VLAN_UDP") # enable strip, vlan will be in mbuf vlan_hex = hex(rx_vlan) self.verify("VLAN tci=%s" % vlan_hex in out, "Failed to strip vlan packet!!!") self.verify("PKT_RX_VLAN_STRIPPED" in out, "Failed to strip vlan packet!") self.vm0_testpmd.execute_cmd('vlan set strip off 0') out = self.send_and_getout(vlan=rx_vlan, pkt_type="VLAN_UDP") self.verify( "received 1 packets" in out, "Not received vlan packet as expected!!!") self.verify( "PKT_RX_VLAN_STRIPPED" not in out, "Failed to disable strip vlan!!!") self.vm0_testpmd.quit()
def set_up_all(self): """ Run at the start of each test suite. Move RSS to rte_flow Prerequisites """ # Based on h/w type, choose how many ports to use self.dut_ports = self.dut.get_ports(self.nic) # Verify that enough ports are available self.verify(len(self.dut_ports) >= 1, "Insufficient ports") localPort = self.tester.get_local_port(self.dut_ports[0]) self.tester_itf = self.tester.get_interface(localPort) self.tester_mac = self.tester.get_mac(localPort) self.pf_interface = self.dut.ports_info[self.dut_ports[0]]['intf'] self.pf_mac = self.dut.get_mac_address(0) self.pf_pci = self.dut.ports_info[self.dut_ports[0]]['pci'] self.pmdout = PmdOutput(self.dut) self.cores = "1S/2C/1T" self.pkt1 = "Ether(dst='%s')/IP(src='10.0.0.1',dst='192.168.0.2')/SCTP(dport=80, sport=80)/('X'*48)" % self.pf_mac self.pkt2 = "Ether(dst='%s')/IP(src='10.0.0.1',dst='192.168.0.2')/UDP(dport=50, sport=50)/('X'*48)" % self.pf_mac self.pkt3 = "Ether(dst='%s')/IP(src='10.0.0.1',dst='192.168.0.3')/TCP(dport=50, sport=50)/('X'*48)" % self.pf_mac self.pkt4 = "Ether(dst='%s')/IP(src='10.0.0.1',dst='192.168.0.2')/('X'*48)" % self.pf_mac self.pkt5 = "Ether(dst='%s')/IPv6(src='2001::1',dst='2001::2',nh=132)/SCTP(dport=80, sport=80)/('X'*48)" % self.pf_mac self.pkt6 = "Ether(dst='%s')/IPv6(src='2001::1',dst='2001::2')/UDP(dport=50, sport=50)/('X'*48)" % self.pf_mac self.pkt7 = "Ether(dst='%s')/IPv6(src='2001::2',dst='2001::3')/TCP(dport=50, sport=50)/('X'*48)" % self.pf_mac self.pkt8 = "Ether(dst='%s')/IPv6(src='2001::2',dst='2001::3')/('X'*48)" % self.pf_mac self.prio_pkt1 = "Ether(dst='%s')/Dot1Q(prio=1)/IP(src='10.0.0.1',dst='192.168.0.2')/TCP(dport=80, sport=80)/('X'*48)" % self.pf_mac self.prio_pkt2 = "Ether(dst='%s')/Dot1Q(prio=2)/IP(src='10.0.0.1',dst='192.168.0.2')/TCP(dport=80, sport=80)/('X'*48)" % self.pf_mac self.prio_pkt3 = "Ether(dst='%s')/Dot1Q(prio=3)/IP(src='10.0.0.1',dst='192.168.0.2')/TCP(dport=80, sport=80)/('X'*48)" % self.pf_mac
def set_up_all(self): """ Run at the start of each test suite. Vlan Prerequistites """ # Based on h/w type, choose how many ports to use ports = self.dut.get_ports() # Verify that enough ports are available self.verify(len(ports) >= 2, "Insufficient ports") global valports valports = [_ for _ in ports if self.tester.get_local_port(_) != -1] portMask = dts.create_mask(valports[:2]) self.pmdout = PmdOutput(self.dut) self.pmdout.start_testpmd("all", "--portmask=%s" % portMask) self.dut.send_expect("set verbose 1", "testpmd> ") out = self.dut.send_expect("set fwd mac", "testpmd> ") self.dut.send_expect("vlan set strip off %s" % valports[0], "testpmd> ") self.verify('Set mac packet forwarding mode' in out, "set fwd rxonly error")
def setup_vm_env(self): """ Start One VM with one virtio device """ self.dut_testpmd = PmdOutput(self.dut) self.dut_testpmd.start_testpmd( "Default", "--rxq=4 --txq=4 --port-topology=chained") self.dut_testpmd.execute_cmd("start") vf0_prop_1 = {'opt_host': self.sriov_vfs_port_0[0].pci} vf0_prop_2 = {'opt_host': self.sriov_vfs_port_1[0].pci} self.vm0 = QEMUKvm(self.dut, 'vm0', 'vf_interrupt_pmd') self.vm0.set_vm_device(driver='pci-assign', **vf0_prop_1) self.vm0.set_vm_device(driver='pci-assign', **vf0_prop_2) try: self.vm0_dut = self.vm0.start() if self.vm0_dut is None: raise Exception("Set up VM ENV failed") else: self.verify(self.vm0_dut.ports_info[0]['intf'] != 'N/A', "Not interface") except Exception as e: self.destroy_vm_env() self.logger.error("Failure for %s" % str(e)) self.vm0_vf0_mac = self.vm0_dut.get_mac_address(0) self.vm0_vf1_mac = self.vm0_dut.get_mac_address(1) self.vm0_dut.send_expect("systemctl stop NetworkManager", "# ", 60)
def test_2vf_k2d_scapy_stream(self): self.vm0_ports = self.vm0_dut.get_ports('any') self.vm0_pmd = PmdOutput(self.vm0_dut) self.vm0_pmd.start_testpmd('all') self.vm0_pmd.execute_cmd('set fwd rxonly') self.vm0_pmd.execute_cmd('start') # disable promisc to filter misc packets from tester. self.vm0_pmd.execute_cmd('set promisc all off') self.vm0_pmd.execute_cmd('clear port stats all') self.vm1_ports = self.vm1_dut.get_ports('any') self.vm1_dut.restore_interfaces() vf1_intf = self.vm1_dut.ports_info[self.vm1_ports[0]]['intf'] dst_mac = self.vm0_dut.ports_info[self.vm0_ports[0]]['mac'] src_mac = self.vm1_dut.ports_info[self.vm1_ports[0]]['mac'] pkt_content = 'Ether(dst="%s", src="%s")/IP()/Raw(load="X"*46)' % \ (dst_mac, src_mac) self.vm1_dut.send_expect('scapy', '>>> ', 10) self.vm1_dut.send_expect( 'sendp([%s], iface="%s", count=%d)' % (pkt_content, vf1_intf, SEND_PACKET), '>>> ', 30) self.vm1_dut.send_expect('quit()', '# ', 10) self.vm1_dut.bind_interfaces_linux(self.drivername) recv_num = self.vm0_pmd.get_pmd_stats(0)['RX-packets'] self.vm0_pmd.execute_cmd('stop') self.vm0_pmd.execute_cmd('quit', '# ') self.verify(recv_num is SEND_PACKET, 'Rx port recv error: %d' % recv_num)
def setup_3vf_2vm_env(self, driver='default'): self.used_dut_port = self.dut_ports[0] self.dut.generate_sriov_vfs_by_port(self.used_dut_port, 3, driver=driver) self.sriov_vfs_port = self.dut.ports_info[ self.used_dut_port]['vfs_port'] try: for port in self.sriov_vfs_port: print port.pci port.bind_driver(self.vf_driver) time.sleep(1) vf0_prop = {'opt_host': self.sriov_vfs_port[0].pci} vf1_prop = {'opt_host': self.sriov_vfs_port[1].pci} vf2_prop = {'opt_host': self.sriov_vfs_port[2].pci} for port_id in self.dut_ports: if port_id == self.used_dut_port: continue port = self.dut.ports_info[port_id]['port'] port.bind_driver() if driver == 'igb_uio': self.host_testpmd = PmdOutput(self.dut) eal_param = '-b %(vf0)s -b %(vf1)s -b %(vf2)s' % { 'vf0': self.sriov_vfs_port[0].pci, 'vf1': self.sriov_vfs_port[1].pci, 'vf2': self.sriov_vfs_port[2].pci } if (self.nic in ["niantic", "sageville", "sagepond"]): self.host_testpmd.start_testpmd("1S/9C/1T", "--txq=4 --rxq=4 ", eal_param=eal_param) else: self.host_testpmd.start_testpmd("1S/2C/2T", eal_param=eal_param) # set up VM0 ENV self.vm0 = VM(self.dut, 'vm0', 'vf_packet_rxtx') self.vm0.set_vm_device(driver=self.vf_assign_method, **vf0_prop) self.vm0.set_vm_device(driver=self.vf_assign_method, **vf1_prop) self.vm_dut_0 = self.vm0.start() if self.vm_dut_0 is None: raise Exception("Set up VM0 ENV failed!") # set up VM1 ENV self.vm1 = VM(self.dut, 'vm1', 'vf_packet_rxtx') self.vm1.set_vm_device(driver=self.vf_assign_method, **vf2_prop) self.vm_dut_1 = self.vm1.start() if self.vm_dut_1 is None: raise Exception("Set up VM1 ENV failed!") self.setup_3vf_2vm_env_flag = 1 except Exception as e: self.destroy_3vf_2vm_env() raise Exception(e)
def get_stats(self, portid): """ Get packets number from port statistic. @param: stop -- stop forward before get stats """ output = PmdOutput(self.dut) stats = output.get_pmd_stats(portid) return stats
def set_up(self): """ Run before each test case. """ self.pmdout = PmdOutput(self.dut) self.pmdout.start_testpmd("Default", "--portmask=%s" % self.portmask) if self.kdriver == "i40e": self.dut.send_expect("set promisc all off", "testpmd> ")
def set_up_all(self): """ Run at the start of each test suite. """ ports = self.dut.get_ports() self.verify(len(ports) >= 2, "Not enough ports available") self.pmdout = PmdOutput(self.dut)
def set_up(self): """ Run before each test case. """ self.dut_testpmd = PmdOutput(self.dut) self.dut_testpmd.start_testpmd( "Default", "--port-topology=chained --txq=%s --rxq=%s" % (self.PF_QUEUE, self.PF_QUEUE)) self.load_profile()
def set_up_all(self): self.dut_ports = self.dut.get_ports(self.nic) self.verify(len(self.dut_ports) > 1, "Insufficient ports") self.vm0 = None self.setup_2pf_2vf_1vm_env_flag = 0 self.setup_2pf_2vf_1vm_env(driver='') self.vm0_dut_ports = self.vm_dut_0.get_ports('any') self.portMask = utils.create_mask([self.vm0_dut_ports[0]]) self.vm0_testpmd = PmdOutput(self.vm_dut_0)
def test_vf_reset(self): self.setup_3vf_2vm_env(driver='') self.vm0_dut_ports = self.vm_dut_0.get_ports('any') self.vm1_dut_ports = self.vm_dut_1.get_ports('any') port_id_0 = 0 port_id_1 = 1 self.vm0_testpmd = PmdOutput(self.vm_dut_0) self.vm0_testpmd.start_testpmd(VM_CORES_MASK) self.vm0_testpmd.execute_cmd('show port info all') pmd0_vf0_mac = self.vm0_testpmd.get_port_mac(port_id_0) self.vm0_testpmd.execute_cmd('set fwd mac') self.vm0_testpmd.execute_cmd('start') time.sleep(2) self.vm1_testpmd = PmdOutput(self.vm_dut_1) self.vm1_testpmd.start_testpmd(VM_CORES_MASK) self.vm1_testpmd.execute_cmd('show port info all') tx_port = self.tester.get_local_port(self.dut_ports[0]) rx_port = tx_port dst_mac = pmd0_vf0_mac self.tester.sendpkt_bg(tx_port, dst_mac) #vf port stop/start can trigger reset action for num in range(1000): self.vm1_testpmd.execute_cmd('port stop all') time.sleep(0.1) self.vm1_testpmd.execute_cmd('port start all') time.sleep(0.1) self.tester.stop_sendpkt_bg() pmd0_vf0_stats = self.vm0_testpmd.get_pmd_stats(port_id_0) pmd0_vf1_stats = self.vm0_testpmd.get_pmd_stats(port_id_1) vf0_rx_cnt = pmd0_vf0_stats['RX-packets'] self.verify(vf0_rx_cnt != 0, "no packet was received by vm0_VF0") vf0_rx_err = pmd0_vf0_stats['RX-errors'] self.verify(vf0_rx_err == 0, "vm0_VF0 rx-errors") vf1_tx_cnt = pmd0_vf1_stats['TX-packets'] self.verify(vf1_tx_cnt != 0, "no packet was transmitted by vm0_VF1") vf1_tx_err = pmd0_vf1_stats['TX-errors'] self.verify(vf1_tx_err == 0, "vm0_VF0 tx-errors") self.verify( vf0_rx_cnt == vf1_tx_cnt, "vm0_VF0 failed to forward packets to vm0_VF1 when reset vm1_VF0 frequently" )
def test_add_pvid_vf(self): random_vlan = random.randint(1, MAX_VLAN) self.dut.send_expect( "ip link set %s vf 0 vlan %d" % (self.host_intf0, random_vlan), "# ") out = self.dut.send_expect("ip link show %s" % self.host_intf0, "# ") self.verify("vlan %d" % random_vlan in out, "Failed to add pvid on VF0") # start testpmd in VM self.vm0_dut_ports = self.vm_dut_0.get_ports('any') self.vm0_testpmd = PmdOutput(self.vm_dut_0) self.vm0_testpmd.start_testpmd(VM_CORES_MASK) self.vm0_testpmd.execute_cmd('set fwd rxonly') self.vm0_testpmd.execute_cmd('set verbose 1') self.vm0_testpmd.execute_cmd('start') out = self.send_and_getout(vlan=random_vlan, pkt_type="VLAN_UDP") self.verify("received" in out, "Failed to received vlan packet!!!") # send packet without vlan out = self.send_and_getout(pkt_type="UDP") self.verify("received" not in out, "Received packet without vlan!!!") # send packet with vlan not matched wrong_vlan = (random_vlan + 1) % 4096 out = self.send_and_getout(vlan=wrong_vlan, pkt_type="VLAN_UDP") self.verify("received" not in out, "Received pacekt with wrong vlan!!!") # remove vlan self.dut.send_expect("ip link set %s vf 0 vlan 0" % self.host_intf0, "# ") # send packet with vlan out = self.send_and_getout(vlan=random_vlan, pkt_type="VLAN_UDP") if self.kdriver == "i40e": self.verify("received" in out, "Failed to received vlan packet!!!") else: self.verify("received" not in out, "Received vlan packet without pvid!!!") # send packet with vlan 0 out = self.send_and_getout(vlan=0, pkt_type="VLAN_UDP") self.verify("received" in out, "Not recevied packet with vlan 0!!!") # send packet without vlan out = self.send_and_getout(vlan=0, pkt_type="UDP") self.verify("received" in out, "Not received packet without vlan!!!") self.vm0_testpmd.quit() # disable pvid self.dut.send_expect("ip link set %s vf 0 vlan 0" % (self.host_intf0), "# ")
def set_up(self): """ Run before each test case. """ self.dut_testpmd = PmdOutput(self.dut) self.dut_testpmd.start_testpmd("Default", "--port-topology=chained") self.dut_testpmd.execute_cmd('set fwd rxonly') self.dut_testpmd.execute_cmd('set verbose 1') self.dut_testpmd.execute_cmd('start')
def send_packet_and_verify(self): self.vm0_dut_ports = self.vm_dut_0.get_ports('any') self.vm0_testpmd = PmdOutput(self.vm_dut_0) self.vm0_testpmd.start_testpmd(VM_CORES_MASK) # Get VF0 port MAC address pmd_vf0_mac = self.vm0_testpmd.get_port_mac(0) self.vm0_testpmd.execute_cmd('set promisc all off') ret = self.vm0_testpmd.execute_cmd('mac_addr add 0 %s' % self.vf0_setmac) # check the operation is supported or not. print ret self.vm0_testpmd.execute_cmd('set fwd mac') self.vm0_testpmd.execute_cmd('start') time.sleep(2) tgen_ports = [] tx_port = self.tester.get_local_port(self.dut_ports[0]) rx_port = self.tester.get_local_port(self.dut_ports[1]) tgen_ports.append((tx_port, rx_port)) src_mac = self.tester.get_mac(tx_port) dst_mac = pmd_vf0_mac pkt_param = [("ether", {'dst': dst_mac, 'src': src_mac})] print "\nfirst send packets to the random generated VF MAC, expected result is RX packets=TX packets\n" result1 = self.tester.check_random_pkts(tgen_ports, pktnum=100, allow_miss=False, params=pkt_param) print "\nshow port stats in testpmd for double check: \n", self.vm0_testpmd.execute_cmd( 'show port stats all') self.verify(result1 != False, "VF0 failed to forward packets to VF1") print "\nsecondly, send packets to the new added MAC, expected result is RX packets=TX packets\n" dst_mac = self.vf0_setmac pkt_param = [("ether", {'dst': dst_mac, 'src': src_mac})] result2 = self.tester.check_random_pkts(tgen_ports, pktnum=100, allow_miss=False, params=pkt_param) print "\nshow port stats in testpmd for double check: \n", self.vm0_testpmd.execute_cmd( 'show port stats all') self.verify(result2 != False, "VF0 failed to forward packets to VF1") print "\nThirdly, negative test, send packets to a wrong MAC, expected result is RX packets=0\n" dst_mac = self.vf0_wrongmac pkt_param = [("ether", {'dst': dst_mac, 'src': src_mac})] result3 = self.tester.check_random_pkts(tgen_ports, pktnum=100, allow_miss=False, params=pkt_param) print "\nshow port stats in testpmd for double check: \n", self.vm0_testpmd.execute_cmd( 'show port stats all') self.verify(result3 != True, "VF0 failed to forward packets to VF1")
def set_up_all(self): """ Run at the start of each test suite. Whitelist Prerequistites: Two Ports testpmd can normally started """ self.frames_to_send = 1 # Based on h/w type, choose how many ports to use self.dutPorts = self.dut.get_ports() # Verify that enough ports are available self.verify(len(self.dutPorts) >= 1, "Insufficient ports") portMask = dts.create_mask(self.dutPorts[:2]) self.pmdout = PmdOutput(self.dut) self.pmdout.start_testpmd("1S/2C/1T", "--portmask=%s" % portMask) self.dut.send_expect("set verbose 1", "testpmd> ") # get dest address from self.target port out = self.dut.send_expect("show port info %d" % self.dutPorts[0], "testpmd> ") self.dest = self.dut.get_mac_address(self.dutPorts[0]) mac_scanner = r"MAC address: (([\dA-F]{2}:){5}[\dA-F]{2})" ret = dts.regexp(out, mac_scanner) self.verify(ret is not None, "MAC address not found") self.verify(cmp(ret.lower(), self.dest) == 0, "MAC address wrong") self.max_mac_addr = dts.regexp(out, "Maximum number of MAC addresses: ([0-9]+)")
def set_up_all(self): """ Run at the start of each test suite. PMD prerequisites. """ self.frame_sizes = [64, 65, 128, 256, 512, 1024, 1280, 1518] self.rxfreet_values = [0, 8, 16, 32, 64, 128] self.test_cycles = [{'cores': '1S/1C/1T', 'Mpps': {}, 'pct': {}}, {'cores': '1S/1C/2T', 'Mpps': {}, 'pct': {}}, {'cores': '1S/2C/1T', 'Mpps': {}, 'pct': {}}, {'cores': '1S/2C/2T', 'Mpps': {}, 'pct': {}}, {'cores': '1S/4C/2T', 'Mpps': {}, 'pct': {}} ] self.table_header = ['Frame Size'] for test_cycle in self.test_cycles: self.table_header.append("%s Mpps" % test_cycle['cores']) self.table_header.append("% linerate") self.blacklist = "" # Based on h/w type, choose how many ports to use self.dut_ports = self.dut.get_ports() self.headers_size = HEADER_SIZE['eth'] + HEADER_SIZE[ 'ip'] + HEADER_SIZE['udp'] self.ports_socket = self.dut.get_numa_id(self.dut_ports[0]) self.plotting = Plotting(self.dut.crb['name'], self.target, self.nic) self.pmdout = PmdOutput(self.dut)
def set_up_all(self): """ Run at the start of each test suite. Blacklist Prerequisites. Requirements: Two Ports """ self.ports = self.dut.get_ports() self.verify(len(self.ports) >= 2, "Insufficient ports for testing") [arch, machine, self.env, toolchain] = self.target.split('-') if self.env == 'bsdapp': self.regexp_blacklisted_port = "EAL: PCI device 0000:%02x:%s on NUMA socket [-0-9]+[^\n]*\nEAL: probe driver[^\n]*\nEAL: Device is blacklisted, not initializing" else: self.regexp_blacklisted_port = "EAL: PCI device 0000:%s on NUMA socket [-0-9]+[^\n]*\nEAL: probe driver[^\n]*\nEAL: Device is blacklisted, not initializing" self.pmdout = PmdOutput(self.dut)
def set_up_all(self): """ Prerequisite steps for each test suit. """ self.dut_ports = self.dut.get_ports() self.verify(len(self.dut_ports) >= 2, "Insufficient ports") self.rx_port = self.dut_ports[0] self.tx_port = self.dut_ports[1] cores = self.dut.get_core_list('1S/2C/2T') self.coremask = dts.create_mask(cores) self.port_mask = dts.create_mask([self.rx_port, self.tx_port]) self.tester.send_expect("ifconfig %s mtu %s" % (self.tester.get_interface(self.tester.get_local_port(self.rx_port)), ETHER_JUMBO_FRAME_MTU + 200), "# ") self.tester.send_expect("ifconfig %s mtu %s" % (self.tester.get_interface(self.tester.get_local_port(self.tx_port)), ETHER_JUMBO_FRAME_MTU + 200), "# ") self.pmdout = PmdOutput(self.dut)
def set_up_all(self): """ Run at the start of each test suite. IEEE1588 Prerequisites """ dutPorts = self.dut.get_ports() self.verify(len(dutPorts) > 0, "No ports found for " + self.nic) # Change the config file to support IEEE1588 and recompile the package. if "bsdapp" in self.target: self.dut.send_expect("sed -i -e 's/IEEE1588=n$/IEEE1588=y/' config/common_bsdapp", "# ", 30) else: self.dut.send_expect("sed -i -e 's/IEEE1588=n$/IEEE1588=y/' config/common_linuxapp", "# ", 30) self.dut.skip_setup = False self.dut.build_install_dpdk(self.target) self.pmdout = PmdOutput(self.dut) self.pmdout.start_testpmd("all")
class TestIeee1588(TestCase): def set_up_all(self): """ Run at the start of each test suite. IEEE1588 Prerequisites """ dutPorts = self.dut.get_ports() self.verify(len(dutPorts) > 0, "No ports found for " + self.nic) # Change the config file to support IEEE1588 and recompile the package. if "bsdapp" in self.target: self.dut.send_expect("sed -i -e 's/IEEE1588=n$/IEEE1588=y/' config/common_bsdapp", "# ", 30) else: self.dut.send_expect("sed -i -e 's/IEEE1588=n$/IEEE1588=y/' config/common_linuxapp", "# ", 30) self.dut.skip_setup = False self.dut.build_install_dpdk(self.target) self.pmdout = PmdOutput(self.dut) self.pmdout.start_testpmd("all") def set_up(self): """ Run before each test case. """ pass def test_ieee1588_enable(self): """ IEEE1588 Enable test case. """ self.dut.send_expect("set fwd ieee1588", "testpmd> ") self.dut.send_expect("start", ">", 5) # Waiting for 'testpmd> ' Fails due to log messages, "Received non PTP packet", in the output time.sleep(1) # Allow the output from the "start" command to finish before looking for a regexp in expect # use the first port on that self.nic dutPorts = self.dut.get_ports() port = self.tester.get_local_port(dutPorts[0]) itf = self.tester.get_interface(port) self.tester.scapy_background() self.tester.scapy_append('p = sniff(iface="%s", count=2)' % itf) self.tester.scapy_append('RESULT = p[1].summary()') # this is the output of sniff # [<Ether dst=01:1b:19:00:00:00 src=00:00:00:00:00:00 type=0x88f7 |<Raw load='\x00\x02' |>>] self.tester.scapy_foreground() self.tester.scapy_append('nutmac="01:1b:19:00:00:00"') self.tester.scapy_append('sendp([Ether(dst=nutmac,type=0x88f7)/"\\x00\\x02"], iface="%s")' % itf) self.tester.scapy_append('time.sleep(1)') self.tester.scapy_execute() out = self.tester.scapy_get_result() self.verify("0x88f7" in out, "Ether type is not PTP") # self.verify("\\x00\\x02" in out, "Payload wrong in PTP") time.sleep(1) out = self.dut.send_expect("stop", "testpmd> ") text = dts.regexp(out, "(.*) by hardware") self.verify("IEEE1588 PTP V2 SYNC" in text, "Not filtered " + text) rx_time = dts.regexp(out, "RX timestamp value (0x[0-9a-fA-F]+)") tx_time = dts.regexp(out, "TX timestamp value (0x[0-9a-fA-F]+)") self.verify(rx_time is not None, "RX timestamp error ") self.verify(tx_time is not None, "TX timestamp error ") self.verify(int(tx_time, 16) > int(rx_time, 16), "Timestamp mismatch") def test_ieee1588_disable(self): """ IEEE1588 Disable test case. """ self.dut.send_expect("stop", "testpmd> ") time.sleep(3) # use the first port on that self.nic dutPorts = self.dut.get_ports() port = self.tester.get_local_port(dutPorts[0]) itf = self.tester.get_interface(port) self.tester.scapy_background() self.tester.scapy_append('p = sniff(iface="%s", count=2, timeout=1)' % itf) self.tester.scapy_append('RESULT = p[1].summary()') self.tester.scapy_foreground() self.tester.scapy_append('nutmac="01:1b:19:00:00:00"') self.tester.scapy_append('sendp([Ether(dst=nutmac,type=0x88f7)/"\\x00\\x02"], iface="%s")' % itf) self.tester.scapy_execute() time.sleep(2) out = self.tester.scapy_get_result() self.verify("Ether" not in out, "Ether type is not PTP") def tear_down(self): """ Run after each test case. """ pass def tear_down_all(self): """ Run after each test suite. """ self.dut.send_expect("quit", "# ", 30) # Restore the config file and recompile the package. if "bsdapp" in self.target: self.dut.send_expect("sed -i -e 's/IEEE1588=y$/IEEE1588=n/' config/common_bsdapp", "# ", 30) else: self.dut.send_expect("sed -i -e 's/IEEE1588=y$/IEEE1588=n/' config/common_linuxapp", "# ", 30) self.dut.build_install_dpdk(self.target)
class TestFdir(TestCase): def set_up_all(self): """ Run at the start of each test suite. """ ports = self.dut.get_ports() self.verify(len(ports) >= 2, "Not enough ports available") self.pmdout = PmdOutput(self.dut) def set_up(self): """ Run before each test case. """ pass def send_and_verify(self, condition, packet): """ Send packages and verify behavior. """ self.tester.scapy_foreground() self.tester.scapy_append('sys.path.append("./")') self.tester.scapy_append('from sctp import *') self.tester.scapy_append(packet) self.dut.send_expect("start", "testpmd>") self.tester.scapy_execute() time.sleep(.5) out = self.dut.send_expect("stop", "testpmd>") if condition: self.verify("PKT_RX_FDIR" in out, "FDIR hash not displayed when required") else: self.verify("PKT_RX_FDIR" not in out, "FDIR hash displayed when not required") def test_fdir_space(self): """ Setting memory reserved for FDir filters. """ dutPorts = self.dut.get_ports() self.pmdout.start_testpmd("all", "--rxq=2 --txq=2 --disable-rss --pkt-filter-mode=perfect --pkt-filter-size=64K") out = self.dut.send_expect("show port fdir %s" % dutPorts[0], "testpmd>") self.dut.send_expect("quit", "# ", 30) self.verify("free: 2048" in out, "Free space doesn't match the expected value") self.pmdout.start_testpmd("all", "--rxq=2 --txq=2 --disable-rss --pkt-filter-mode=perfect --pkt-filter-size=128K") out = self.dut.send_expect("show port fdir %s" % dutPorts[0], "testpmd>") self.dut.send_expect("quit", "# ", 30) self.verify("free: 4096" in out, "Free space doesn't match the expected value") self.pmdout.start_testpmd("all", "--rxq=2 --txq=2 --disable-rss --pkt-filter-mode=perfect --pkt-filter-size=256K") out = self.dut.send_expect("show port fdir %s" % dutPorts[0], "testpmd>") self.dut.send_expect("quit", "# ", 30) self.verify("free: 8192" in out, "Free space doesn't match the expected value") def test_fdir_signatures(self): """ FDir signature matching mode. There are three different reporting modes, that can be set in testpmd using the ``--pkt-filter-report-hash`` command line argument: --pkt-filter-report-hash=none --pkt-filter-report-hash=match --pkt-filter-report-hash=always The test for each mode is following the steps below. - Start the ``testpmd`` application by using paramter of each mode. - Send the ``p_udp`` packet with Scapy on the traffic generator and check that FDir information is printed """ dutPorts = self.dut.get_ports() localPort = self.tester.get_local_port(dutPorts[0]) itf = self.tester.get_interface(localPort) self.dut.kill_all() self.pmdout.start_testpmd("all", "--portmask=%s --rxq=2 --txq=2 --disable-rss --pkt-filter-mode=perfect --pkt-filter-report-hash=none" % dts.create_mask([dutPorts[0]])) self.dut.send_expect("set verbose 1", "testpmd>") self.dut.send_expect("set fwd rxonly", "testpmd>") self.dut.send_expect("set nbcore 3", "testpmd>") self.send_and_verify(False, 'sendp([Ether(src=get_if_hwaddr("%s"), dst="00:1B:21:8E:B2:30")/IP(src="192.168.0.1", dst="192.168.0.2")/UDP(sport=1024,dport=1024)], iface="%s")' % (itf, itf)) self.dut.send_expect("add_perfect_filter %s udp src 192.168.0.1 1024 dst 192.168.0.2 1024 flexbytes 0x800 vlan 0 queue 1 soft 0x14" % dutPorts[0], "testpmd>") self.send_and_verify(False, 'sendp([Ether(src=get_if_hwaddr("%s"), dst="00:1B:21:8E:B2:30")/IP(src="192.168.0.1", dst="192.168.0.2")/UDP(sport=1024,dport=1024)], iface="%s")' % (itf, itf)) self.dut.send_expect("quit", "# ", 30) self.pmdout.start_testpmd("all", "--portmask=%s --rxq=2 --txq=2 --disable-rss --pkt-filter-mode=perfect --pkt-filter-report-hash=match" % dts.create_mask([dutPorts[0]])) self.dut.send_expect("set verbose 1", "testpmd>") self.dut.send_expect("set fwd rxonly", "testpmd>") self.dut.send_expect("set nbcore 3", "testpmd>") self.send_and_verify(False, 'sendp([Ether(src=get_if_hwaddr("%s"), dst="00:1B:21:8E:B2:30")/IP(src="192.168.0.1", dst="192.168.0.2")/UDP(sport=1024,dport=1024)], iface="%s")' % (itf, itf)) self.dut.send_expect("add_perfect_filter %s udp src 192.168.0.1 1024 dst 192.168.0.2 1024 flexbytes 0x800 vlan 0 queue 1 soft 0x14" % dutPorts[0], "testpmd>") self.send_and_verify(True, 'sendp([Ether(src=get_if_hwaddr("%s"), dst="00:1B:21:8E:B2:30")/IP(src="192.168.0.1", dst="192.168.0.2")/UDP(sport=1024,dport=1024)], iface="%s")' % (itf, itf)) self.dut.send_expect("upd_perfect_filter %s udp src 192.168.1.1 0 dst 192.168.1.2 0 flexbytes 0x800 vlan 0 queue 1 soft 0x14" % dutPorts[0], "testpmd>") self.send_and_verify(True, 'sendp([Ether(src=get_if_hwaddr("%s"), dst="00:1B:21:8E:B2:30")/IP(src="192.168.0.1", dst="192.168.0.2")/UDP(sport=1024,dport=1024)], iface="%s")' % (itf, itf)) self.send_and_verify(True, 'sendp([Ether(src=get_if_hwaddr("%s"), dst="00:1B:21:8E:B2:30")/IP(src="192.168.1.1", dst="192.168.1.2")/UDP(sport=0,dport=0)], iface="%s")' % (itf, itf)) self.dut.send_expect("rm_perfect_filter %s udp src 192.168.1.1 0 dst 192.168.1.2 0 flexbytes 0x800 vlan 0 soft 0x14" % dutPorts[0], "testpmd>") self.send_and_verify(False, 'sendp([Ether(src=get_if_hwaddr("%s"), dst="00:1B:21:8E:B2:30")/IP(src="192.168.1.1", dst="192.168.1.2")/UDP(sport=0,dport=0)], iface="%s")' % (itf, itf)) self.dut.send_expect("quit", "# ", 30) self.pmdout.start_testpmd("all", "--portmask=%s --rxq=2 --txq=2 --disable-rss --pkt-filter-mode=perfect --pkt-filter-report-hash=always" % dts.create_mask([dutPorts[0]])) self.dut.send_expect("set verbose 1", "testpmd>") self.dut.send_expect("set fwd rxonly", "testpmd>") self.dut.send_expect("set nbcore 3", "testpmd>") self.send_and_verify(True, 'sendp([Ether(src=get_if_hwaddr("%s"), dst="00:1B:21:8E:B2:30")/IP(src="192.168.0.1", dst="192.168.0.2")/UDP(sport=1024,dport=1024)], iface="%s")' % (itf, itf)) self.dut.send_expect("add_perfect_filter %s udp src 192.168.0.1 1024 dst 192.168.0.2 1024 flexbytes 0x800 vlan 0 queue 1 soft 0x14" % dutPorts[0], "testpmd>") self.send_and_verify(True, 'sendp([Ether(src=get_if_hwaddr("%s"), dst="00:1B:21:8E:B2:30")/IP(src="192.168.0.1", dst="192.168.0.2")/UDP(sport=1024,dport=1024)], iface="%s")' % (itf, itf)) self.dut.send_expect("quit", "# ", 30) def test_fdir_matching(self): """ FDir matching mode This test adds signature filters to the hardware, and then checks whether sent packets match those filters. The test for each mode is following the steps below. - Start the ``testpmd`` application - Add filter with upd, tcp sctp, IP4 or IP6 - Send the packet and validate the filter function. """ dutPorts = self.dut.get_ports() localPort = self.tester.get_local_port(dutPorts[0]) itf = self.tester.get_interface(localPort) self.dut.kill_all() self.pmdout.start_testpmd("all", "--portmask=%s --rxq=2 --txq=2 --disable-rss --pkt-filter-mode=signature --pkt-filter-report-hash=match" % dts.create_mask([dutPorts[0]])) self.dut.send_expect("set verbose 1", "testpmd>") self.dut.send_expect("set fwd rxonly", "testpmd>") self.dut.send_expect("set nbcore 3", "testpmd>") self.send_and_verify(False, 'sendp([Ether(src=get_if_hwaddr("%s"), dst="00:1B:21:8E:B2:30")/IP(src="192.168.0.1", dst="192.168.0.2")/UDP(sport=1024,dport=1024)], iface="%s")' % (itf, itf)) self.dut.send_expect("add_signature_filter %s udp src 192.168.0.1 1024 dst 192.168.0.2 1024 flexbytes 0x800 vlan 0 queue 1" % dutPorts[0], "testpmd>") self.send_and_verify(True, 'sendp([Ether(src=get_if_hwaddr("%s"), dst="00:1B:21:8E:B2:30")/IP(src="192.168.0.1", dst="192.168.0.2")/UDP(sport=1024,dport=1024)], iface="%s")' % (itf, itf)) self.send_and_verify(False, 'sendp([Ether(src=get_if_hwaddr("%s"), dst="00:1B:21:8E:B2:30")/IP(src="192.168.0.1", dst="192.168.0.2")/TCP(sport=1024,dport=1024)], iface="%s")' % (itf, itf)) self.dut.send_expect("upd_signature_filter %s udp src 192.168.1.1 0 dst 192.168.1.2 0 flexbytes 0x800 vlan 0 queue 1" % dutPorts[0], "testpmd>") self.send_and_verify(True, 'sendp([Ether(src=get_if_hwaddr("%s"), dst="00:1B:21:8E:B2:30")/IP(src="192.168.0.1", dst="192.168.0.2")/UDP(sport=1024,dport=1024)], iface="%s")' % (itf, itf)) self.send_and_verify(True, 'sendp([Ether(src=get_if_hwaddr("%s"), dst="00:1B:21:8E:B2:30")/IP(src="192.168.1.1", dst="192.168.1.2")/UDP(sport=0,dport=0)], iface="%s")' % (itf, itf)) self.dut.send_expect("rm_signature_filter %s udp src 192.168.1.1 0 dst 192.168.1.2 0 flexbytes 0x800 vlan 0" % dutPorts[0], "testpmd>") self.send_and_verify(False, 'sendp([Ether(src=get_if_hwaddr("%s"), dst="00:1B:21:8E:B2:30")/IP(src="192.168.1.1", dst="192.168.1.2")/UDP(sport=0,dport=0)], iface="%s")' % (itf, itf)) self.dut.send_expect("add_signature_filter %s tcp src 192.168.0.1 1024 dst 192.168.0.2 1024 flexbytes 0x800 vlan 0 queue 1" % dutPorts[0], "testpmd>") self.send_and_verify(True, 'sendp([Ether(src=get_if_hwaddr("%s"), dst="00:1B:21:8E:B2:30")/IP(src="192.168.0.1", dst="192.168.0.2")/TCP(sport=1024,dport=1024)], iface="%s")' % (itf, itf)) self.send_and_verify(False, 'sendp([Ether(src=get_if_hwaddr("%s"), dst="00:1B:21:8E:B2:30")/IP(src="192.168.0.1", dst="192.168.0.2")/SCTP(sport=1024,dport=1024)], iface="%s")' % (itf, itf)) self.dut.send_expect("add_signature_filter %s sctp src 192.168.0.1 0 dst 192.168.0.2 0 flexbytes 0x800 vlan 0 queue 1" % dutPorts[0], "testpmd>") self.send_and_verify(True, 'sendp([Ether(src=get_if_hwaddr("%s"), dst="00:1B:21:8E:B2:30")/IP(src="192.168.0.1", dst="192.168.0.2")/SCTP(sport=1024,dport=1024)], iface="%s")' % (itf, itf)) self.send_and_verify(False, 'sendp([Ether(src=get_if_hwaddr("%s"), dst="00:1B:21:8E:B2:30")/IP(src="192.168.0.1", dst="192.168.0.2")], iface="%s")' % (itf, itf)) self.dut.send_expect("add_signature_filter %s ip src 192.168.0.1 0 dst 192.168.0.2 0 flexbytes 0x800 vlan 0 queue 1" % dutPorts[0], "testpmd>") self.send_and_verify(True, 'sendp([Ether(src=get_if_hwaddr("%s"), dst="00:1B:21:8E:B2:30")/IP(src="192.168.0.1", dst="192.168.0.2")], iface="%s")' % (itf, itf)) self.send_and_verify(False, 'sendp([Ether(src=get_if_hwaddr("%s"), dst="00:1B:21:8E:B2:30")/IPv6(src="2001:0db8:85a3:0000:0000:8a2e:0370:7000", dst="2001:0db8:85a3:0000:0000:8a2e:0370:7338")/UDP(sport=1024,dport=1024)], iface="%s")' % (itf, itf)) self.dut.send_expect("add_signature_filter %s udp src 2001:0db8:85a3:0000:0000:8a2e:0370:7000 1024 dst 2001:0db8:85a3:0000:0000:8a2e:0370:7338 1024 flexbytes 0x86dd vlan 0 queue 1" % dutPorts[0], "testpmd>") self.send_and_verify(True, 'sendp([Ether(src=get_if_hwaddr("%s"), dst="00:1B:21:8E:B2:30")/IPv6(src="2001:0db8:85a3:0000:0000:8a2e:0370:7000", dst="2001:0db8:85a3:0000:0000:8a2e:0370:7338")/UDP(sport=1024,dport=1024)], iface="%s")' % (itf, itf)) self.dut.send_expect("quit", "# ", 30) def test_fdir_perfect_matching(self): """ FDir perfect matching mode. This test adds perfect-match filters to the hardware, and then checks whether sent packets match those filters. The test for each mode is following the steps below. - Start the ``testpmd`` application with perfect match; - Add filter with upd, tcp sctp, IP4; - Send the packet and validate the perfect filter function. """ dutPorts = self.dut.get_ports() localPort = self.tester.get_local_port(dutPorts[0]) itf = self.tester.get_interface(localPort) self.dut.kill_all() self.pmdout.start_testpmd("all", "--portmask=%s --rxq=2 --txq=2 --disable-rss --pkt-filter-mode=perfect --pkt-filter-report-hash=match" % dts.create_mask([dutPorts[0]])) self.dut.send_expect("set verbose 1", "testpmd>") self.dut.send_expect("set fwd rxonly", "testpmd>") self.dut.send_expect("set nbcore 3", "testpmd>") self.dut.send_expect("add_perfect_filter %s udp src 192.168.0.1 1024 dst 192.168.0.2 1024 flexbytes 0x800 vlan 0 queue 1 soft 0x14" % dutPorts[0], "testpmd>") self.send_and_verify(True, 'sendp([Ether(src=get_if_hwaddr("%s"), dst="00:1B:21:8E:B2:30")/IP(src="192.168.0.1", dst="192.168.0.2")/UDP(sport=1024,dport=1024)], iface="%s")' % (itf, itf)) self.dut.send_expect("add_perfect_filter %s tcp src 192.168.0.1 1024 dst 192.168.0.2 1024 flexbytes 0x800 vlan 0 queue 1 soft 0x15" % dutPorts[0], "testpmd>") self.send_and_verify(True, 'sendp([Ether(src=get_if_hwaddr("%s"), dst="00:1B:21:8E:B2:30")/IP(src="192.168.0.1", dst="192.168.0.2")/TCP(sport=1024,dport=1024)], iface="%s")' % (itf, itf)) self.dut.send_expect("add_perfect_filter %s sctp src 192.168.0.1 0 dst 192.168.0.2 0 flexbytes 0x800 vlan 0 queue 1 soft 0x16" % dutPorts[0], "testpmd>") self.send_and_verify(True, 'sendp([Ether(src=get_if_hwaddr("%s"), dst="00:1B:21:8E:B2:30")/IP(src="192.168.0.1", dst="192.168.0.2")/SCTP(sport=1024,dport=1024)], iface="%s")' % (itf, itf)) self.dut.send_expect("add_perfect_filter %s ip src 192.168.0.1 0 dst 192.168.0.2 0 flexbytes 0x800 vlan 0 queue 1 soft 0x17" % dutPorts[0], "testpmd>") self.send_and_verify(True, 'sendp([Ether(src=get_if_hwaddr("%s"), dst="00:1B:21:8E:B2:30")/IP(src="192.168.0.1", dst="192.168.0.2")], iface="%s")' % (itf, itf)) self.dut.send_expect("quit", "# ", 30) def test_fdir_filter_masks(self): """ FDir filter masks. This tests the functionality of the setting FDir masks to to affect which fields, or parts of fields are used in the matching process. """ dutPorts = self.dut.get_ports() localPort = self.tester.get_local_port(dutPorts[0]) itf = self.tester.get_interface(localPort) self.dut.kill_all() self.pmdout.start_testpmd("all", "--portmask=%s --rxq=2 --txq=2 --disable-rss --pkt-filter-mode=perfect --pkt-filter-size=64K --pkt-filter-report-hash=match" % dts.create_mask([dutPorts[0]])) self.dut.send_expect("set verbose 1", "testpmd>") self.dut.send_expect("set fwd rxonly", "testpmd>") self.dut.send_expect("set nbcore 3", "testpmd>") self.dut.send_expect("set_masks_filter %s only_ip_flow 0 src_mask 0xffffff00 0xffff dst_mask 0xffffff00 0xffff flexbytes 1 vlan_id 1 vlan_prio 1" % dutPorts[0], "testpmd>") self.dut.send_expect("add_perfect_filter %s udp src 192.168.0.0 1024 dst 192.168.0.0 1024 flexbytes 0x800 vlan 0 queue 1 soft 0x17" % dutPorts[0], "testpmd>") self.send_and_verify(True, 'sendp([Ether(src=get_if_hwaddr("%s"), dst="00:1B:21:8E:B2:30")/IP(src="192.168.0.1", dst="192.168.0.2")/UDP(sport=1024,dport=1024)], iface="%s")' % (itf, itf)) self.send_and_verify(True, 'sendp([Ether(src=get_if_hwaddr("%s"), dst="00:1B:21:8E:B2:30")/IP(src="192.168.0.15", dst="192.168.0.15")/UDP(sport=1024,dport=1024)], iface="%s")' % (itf, itf)) self.send_and_verify(False, 'sendp([Ether(src=get_if_hwaddr("%s"), dst="00:1B:21:8E:B2:30")/IP(src="192.168.0.1", dst="192.168.1.1")/UDP(sport=1024,dport=1024)], iface="%s")' % (itf, itf)) self.dut.send_expect("set_masks_filter %s only_ip_flow 0 src_mask 0xffffffff 0xff00 dst_mask 0xffffffff 0xff00 flexbytes 1 vlan_id 1 vlan_prio 1" % dutPorts[0], "testpmd>") self.dut.send_expect("add_perfect_filter %s udp src 10.11.12.1 0x4400 dst 10.11.12.2 0x4500 flexbytes 0x800 vlan 0 queue 1 soft 0x4" % dutPorts[0], "testpmd>") self.send_and_verify(True, 'sendp([Ether(src=get_if_hwaddr("%s"), dst="00:1B:21:8E:B2:30")/IP(src="10.11.12.1", dst="10.11.12.2")/UDP(sport=0x4400,dport=0x4500)], iface="%s")' % (itf, itf)) self.send_and_verify(True, 'sendp([Ether(src=get_if_hwaddr("%s"), dst="00:1B:21:8E:B2:30")/IP(src="10.11.12.1", dst="10.11.12.2")/UDP(sport=0x4411,dport=0x4517)], iface="%s")' % (itf, itf)) self.send_and_verify(False, 'sendp([Ether(src=get_if_hwaddr("%s"), dst="00:1B:21:8E:B2:30")/IP(src="10.11.12.1", dst="10.11.12.2")/UDP(sport=0x4500,dport=0x5500)], iface="%s")' % (itf, itf)) self.dut.send_expect("set_masks_filter %s only_ip_flow 1 src_mask 0xffffffff 0x0 dst_mask 0xffffffff 0x0 flexbytes 1 vlan_id 1 vlan_prio 1" % dutPorts[0], "testpmd>") self.dut.send_expect("add_perfect_filter %s ip src 192.168.0.1 0 dst 192.168.0.2 0 flexbytes 0x800 vlan 0 queue 1 soft 0x42" % dutPorts[0], "testpmd>") self.send_and_verify(True, 'sendp([Ether(src=get_if_hwaddr("%s"), dst="00:1B:21:8E:B2:30")/IP(src="192.168.0.1", dst="192.168.0.2")/UDP(sport=1024, dport=1024)], iface="%s")' % (itf, itf)) self.send_and_verify(True, 'sendp([Ether(src=get_if_hwaddr("%s"), dst="00:1B:21:8E:B2:30")/IP(src="192.168.0.1", dst="192.168.0.2")/TCP(sport=1024, dport=1024)], iface="%s")' % (itf, itf)) self.send_and_verify(True, 'sendp([Ether(src=get_if_hwaddr("%s"), dst="00:1B:21:8E:B2:30")/IP(src="192.168.0.1", dst="192.168.0.2")/SCTP(sport=1024, dport=1024)], iface="%s")' % (itf, itf)) self.dut.send_expect("quit", "# ", 30) def test_fdir_flexbytes_filtering(self): """ FDir flexbytes filtering The FDir feature supports setting up filters that can match on any two byte field within the first 64 bytes of a packet. Which byte offset to use is set by passing command line arguments to ``testpmd``. In this test a value of ``18`` corresponds to the bytes at offset 36 and 37, as the offset is in 2-byte units """ dutPorts = self.dut.get_ports() localPort = self.tester.get_local_port(dutPorts[0]) itf = self.tester.get_interface(localPort) self.dut.kill_all() self.pmdout.start_testpmd("all", "--portmask=%s --rxq=2 --txq=2 --disable-rss --pkt-filter-mode=perfect --pkt-filter-size=64K --pkt-filter-report-hash=match --pkt-filter-flexbytes-offset=18" % dts.create_mask([dutPorts[0]])) self.dut.send_expect("set verbose 1", "testpmd>") self.dut.send_expect("set fwd rxonly", "testpmd>") self.dut.send_expect("set nbcore 3", "testpmd>") self.dut.send_expect("add_perfect_filter %s ip src 192.168.0.1 0 dst 192.168.0.2 0 flexbytes 0x1 vlan 0 queue 1 soft 0x1" % dutPorts[0], "testpmd>") self.send_and_verify(True, 'sendp([Ether(src=get_if_hwaddr("%s"), dst="00:1B:21:8E:B2:30")/IP(src="192.168.0.1", dst="192.168.0.2")/GRE(proto=0x1)/IP()/UDP()], iface="%s")' % (itf, itf)) self.dut.send_expect("add_perfect_filter %s ip src 192.168.0.1 0 dst 192.168.0.2 0 flexbytes 0xff vlan 0 queue 1 soft 0xff" % dutPorts[0], "testpmd>") self.send_and_verify(True, 'sendp([Ether(src=get_if_hwaddr("%s"), dst="00:1B:21:8E:B2:30")/IP(src="192.168.0.1", dst="192.168.0.2")/GRE(proto=0xff)/IP()/UDP()], iface="%s")' % (itf, itf)) self.dut.send_expect("set_masks_filter %s only_ip_flow 0 src_mask 0xffffffff 0xffff dst_mask 0xffffffff 0xffff flexbytes 0 vlan_id 1 vlan_prio 1" % dutPorts[0], "testpmd>") self.dut.send_expect("add_perfect_filter %s ip src 192.168.0.1 0 dst 192.168.0.2 0 flexbytes 0x0 vlan 0 queue 1 soft 0x42" % dutPorts[0], "testpmd>") self.send_and_verify(True, 'sendp([Ether(src=get_if_hwaddr("%s"), dst="00:1B:21:8E:B2:30")/IP(src="192.168.0.1", dst="192.168.0.2")/GRE(proto=0x1)/IP()/UDP()], iface="%s")' % (itf, itf)) self.send_and_verify(True, 'sendp([Ether(src=get_if_hwaddr("%s"), dst="00:1B:21:8E:B2:30")/IP(src="192.168.0.1", dst="192.168.0.2")/GRE(proto=0xFF)/IP()/UDP()], iface="%s")' % (itf, itf)) self.dut.send_expect("quit", "# ", 30) def test_fdir_vlanfiltering(self): """ FDir VLAN field filtering """ dutPorts = self.dut.get_ports() localPort = self.tester.get_local_port(dutPorts[0]) itf = self.tester.get_interface(localPort) self.dut.kill_all() self.pmdout.start_testpmd("all", "--portmask=%s --nb-cores=2 --rxq=2 --txq=2 --disable-rss --pkt-filter-mode=perfect" % dts.create_mask([dutPorts[0]])) self.dut.send_expect("set verbose 1", "testpmd>") self.dut.send_expect("set fwd rxonly", "testpmd>") # "rx_vlan add all" has been removed from testpmd self.dut.send_expect("rx_vlan add 0xFFF %s" % dutPorts[0], "testpmd>") self.dut.send_expect("rx_vlan add 0x001 %s" % dutPorts[0], "testpmd>") self.dut.send_expect("rx_vlan add 0x017 %s" % dutPorts[0], "testpmd>") self.send_and_verify(False, 'sendp([Ether(src=get_if_hwaddr("%s"), dst="00:1B:21:8E:B2:30")/Dot1Q(vlan=0x0FFF)/IP(src="192.168.0.1", dst="192.168.0.2")/UDP(sport=1024, dport=1024)], iface="%s")' % (itf, itf)) self.dut.send_expect("add_perfect_filter %s udp src 192.168.0.1 1024 dst 192.168.0.2 1024 flexbytes 0x8100 vlan 0xfff queue 1 soft 0x47" % dutPorts[0], "testpmd>") self.send_and_verify(True, 'sendp([Ether(src=get_if_hwaddr("%s"), dst="00:1B:21:8E:B2:30")/Dot1Q(vlan=0x0FFF)/IP(src="192.168.0.1", dst="192.168.0.2")/UDP(sport=1024, dport=1024)], iface="%s")' % (itf, itf)) self.dut.send_expect("set_masks_filter %s only_ip_flow 0 src_mask 0xffffffff 0xffff dst_mask 0xffffffff 0xffff flexbytes 1 vlan_id 0 vlan_prio 0" % dutPorts[0], "testpmd>") self.dut.send_expect("add_perfect_filter %s udp src 192.168.0.1 1024 dst 192.168.0.2 1024 flexbytes 0x8100 vlan 0 queue 1 soft 0x47" % dutPorts[0], "testpmd>") self.send_and_verify(True, 'sendp([Ether(src=get_if_hwaddr("%s"), dst="00:1B:21:8E:B2:30")/Dot1Q(vlan=0x001)/IP(src="192.168.0.1", dst="192.168.0.2")/UDP(sport=1024, dport=1024)], iface="%s")' % (itf, itf)) self.send_and_verify(True, 'sendp([Ether(src=get_if_hwaddr("%s"), dst="00:1B:21:8E:B2:30")/Dot1Q(vlan=0x0017)/IP(src="192.168.0.1", dst="192.168.0.2")/UDP(sport=1024, dport=1024)], iface="%s")' % (itf, itf)) self.dut.send_expect("quit", "# ", 30) def tear_down(self): """ Run after each test case. """ pass def tear_down_all(self): """ Run after each test suite. """ pass
class TestWhitelist(TestCase): def set_up_all(self): """ Run at the start of each test suite. Whitelist Prerequistites: Two Ports testpmd can normally started """ self.frames_to_send = 1 # Based on h/w type, choose how many ports to use self.dutPorts = self.dut.get_ports() # Verify that enough ports are available self.verify(len(self.dutPorts) >= 1, "Insufficient ports") portMask = dts.create_mask(self.dutPorts[:2]) self.pmdout = PmdOutput(self.dut) self.pmdout.start_testpmd("1S/2C/1T", "--portmask=%s" % portMask) self.dut.send_expect("set verbose 1", "testpmd> ") # get dest address from self.target port out = self.dut.send_expect("show port info %d" % self.dutPorts[0], "testpmd> ") self.dest = self.dut.get_mac_address(self.dutPorts[0]) mac_scanner = r"MAC address: (([\dA-F]{2}:){5}[\dA-F]{2})" ret = dts.regexp(out, mac_scanner) self.verify(ret is not None, "MAC address not found") self.verify(cmp(ret.lower(), self.dest) == 0, "MAC address wrong") self.max_mac_addr = dts.regexp(out, "Maximum number of MAC addresses: ([0-9]+)") def set_up(self): """ Run before each test case. Nothing to do. """ pass def whitelist_send_packet(self, portid, destMac="00:11:22:33:44:55"): """ Send 1 packet to portid. """ itf = self.tester.get_interface(self.tester.get_local_port(portid)) self.tester.scapy_foreground() self.tester.scapy_append('sendp([Ether(dst="%s", src="52:00:00:00:00:00")], iface="%s", count=%d)' % (destMac, itf, self.frames_to_send)) self.tester.scapy_execute() time.sleep(5) def test_whitelist_add_remove_mac_address(self): """ Add mac address and check packet can received Remove mac address and check packet can't received """ # initialise first port without promiscuous mode fake_mac_addr = "01:01:01:00:00:00" portid = self.dutPorts[0] self.dut.send_expect("set promisc %d off" % portid, "testpmd> ") out = self.dut.send_expect("show port stats %d" % portid, "testpmd> ") pre_rxpkt = dts.regexp(out, "RX-packets: ([0-9]+)") # send one packet with the portid MAC address self.whitelist_send_packet(portid, self.dest) out = self.dut.send_expect("show port stats %d" % portid, "testpmd> ") cur_rxpkt = dts.regexp(out, "RX-packets: ([0-9]+)") # check the packet increase self.verify(int(cur_rxpkt) == int(pre_rxpkt) + self.frames_to_send, "Packet has not been received on default address") # send one packet to a different MAC address # new_mac = self.dut.get_mac_address(portid) self.whitelist_send_packet(portid, fake_mac_addr) pre_rxpkt = cur_rxpkt out = self.dut.send_expect("show port stats %d" % portid, "testpmd> ") cur_rxpkt = dts.regexp(out, "RX-packets: ([0-9]+)") # check the packet DO NOT increase self.verify(int(cur_rxpkt) == int(pre_rxpkt), "Packet has been received on a new MAC address that has not been added yet") # add the different MAC address out = self.dut.send_expect("mac_addr add %d" % portid + " %s" % fake_mac_addr, "testpmd>") # send again one packet to a different MAC address self.whitelist_send_packet(portid, fake_mac_addr) pre_rxpkt = cur_rxpkt out = self.dut.send_expect("show port stats %d" % portid, "testpmd> ") cur_rxpkt = dts.regexp(out, "RX-packets: ([0-9]+)") # check the packet increase self.verify(int(cur_rxpkt) == int(pre_rxpkt) + self.frames_to_send, "Packet has not been received on a new MAC address that has been added to the port") # remove the fake MAC address out = self.dut.send_expect("mac_addr remove %d" % portid + " %s" % fake_mac_addr, "testpmd>") # send again one packet to a different MAC address self.whitelist_send_packet(portid, fake_mac_addr) pre_rxpkt = cur_rxpkt out = self.dut.send_expect("show port stats %d" % portid, "testpmd> ") cur_rxpkt = dts.regexp(out, "RX-packets: ([0-9]+)") # check the packet increase self.verify(int(cur_rxpkt) == int(pre_rxpkt), "Packet has been received on a new MAC address that has been removed from the port") self.dut.send_expect("stop", "testpmd> ") def test_whitelist_invalid_addresses(self): """ Invalid operation: Add NULL MAC should not be added Remove using MAC will be failed Add Same MAC twice will be failed Add more than MAX number will be failed """ portid = self.dutPorts[0] fake_mac_addr = "00:00:00:00:00:00" # add an address with all zeroes to the port (-EINVAL) out = self.dut.send_expect("mac_addr add %d" % portid + " %s" % fake_mac_addr, "testpmd>") self.verify("Invalid argument" in out, "Added a NULL MAC address") # remove the default MAC address (-EADDRINUSE) out = self.dut.send_expect("mac_addr remove %d" % portid + " %s" % self.dest, "testpmd>") self.verify("Address already in use" in out, "default address removed") # add same address 2 times fake_mac_addr = "00:00:00:00:00:01" out = self.dut.send_expect("mac_addr add %d" % portid + " %s" % fake_mac_addr, "testpmd>") out = self.dut.send_expect("mac_addr add %d" % portid + " %s" % fake_mac_addr, "testpmd>") self.verify("error" not in out, "added 2 times the same address with an error") # add 1 address more that max number i = 0 base_addr = "01:00:00:00:00:" while i <= int(self.max_mac_addr): new_addr = base_addr + "%0.2X" % i out = self.dut.send_expect("mac_addr add %d" % portid + " %s" % new_addr, "testpmd>") i = i + 1 self.verify("No space left on device" in out, "added 1 address more than max MAC addresses") def tear_down(self): """ Run after each test case. Nothing to do. """ pass def tear_down_all(self): """ Run after each test suite. """ self.dut.send_expect("quit", "# ", 10)
class TestPmd(TestCase): def plot_results(self, number_ports): cores_configs = [] percent_values = [] # Append the percentage results for the all the cores configs for test_cycle in self.test_cycles: cores_configs.append(test_cycle['cores']) config_results = [] for frame_size in self.frame_sizes: config_results.append(test_cycle['pct'][frame_size]) percent_values.append(config_results) image_path = self.plotting.create_bars_plot( 'test_perf_pmd_%sports' % number_ports, 'PMD, %d ports' % number_ports, self.frame_sizes, percent_values, ylabel='% linerate', legend=cores_configs) dts.results_plot_print(image_path) def set_up_all(self): """ Run at the start of each test suite. PMD prerequisites. """ self.frame_sizes = [64, 65, 128, 256, 512, 1024, 1280, 1518] self.rxfreet_values = [0, 8, 16, 32, 64, 128] self.test_cycles = [{'cores': '1S/1C/1T', 'Mpps': {}, 'pct': {}}, {'cores': '1S/1C/2T', 'Mpps': {}, 'pct': {}}, {'cores': '1S/2C/1T', 'Mpps': {}, 'pct': {}}, {'cores': '1S/2C/2T', 'Mpps': {}, 'pct': {}}, {'cores': '1S/4C/2T', 'Mpps': {}, 'pct': {}} ] self.table_header = ['Frame Size'] for test_cycle in self.test_cycles: self.table_header.append("%s Mpps" % test_cycle['cores']) self.table_header.append("% linerate") self.blacklist = "" # Based on h/w type, choose how many ports to use self.dut_ports = self.dut.get_ports() self.headers_size = HEADER_SIZE['eth'] + HEADER_SIZE[ 'ip'] + HEADER_SIZE['udp'] self.ports_socket = self.dut.get_numa_id(self.dut_ports[0]) self.plotting = Plotting(self.dut.crb['name'], self.target, self.nic) self.pmdout = PmdOutput(self.dut) def set_up(self): """ Run before each test case. """ pass def test_perf_pmd_performance_4ports(self): """ PMD Performance Benchmarking with 4 ports. """ all_cores_mask = dts.create_mask(self.dut.get_core_list("all")) # prepare traffic generator input self.verify(len(self.dut_ports) >= 4, "Insufficient ports for 4 ports performance") tgen_input = [] tgen_input.append((self.tester.get_local_port(self.dut_ports[0]), self.tester.get_local_port(self.dut_ports[1]), "test.pcap")) tgen_input.append((self.tester.get_local_port(self.dut_ports[2]), self.tester.get_local_port(self.dut_ports[3]), "test.pcap")) tgen_input.append((self.tester.get_local_port(self.dut_ports[1]), self.tester.get_local_port(self.dut_ports[0]), "test.pcap")) tgen_input.append((self.tester.get_local_port(self.dut_ports[3]), self.tester.get_local_port(self.dut_ports[2]), "test.pcap")) # run testpmd for each core config for test_cycle in self.test_cycles: core_config = test_cycle['cores'] core_list = self.dut.get_core_list(core_config, socket=self.ports_socket) if len(core_list) > 4: queues = len(core_list) / 4 else: queues = 1 core_mask = dts.create_mask(core_list) port_mask = dts.create_mask(self.dut.get_ports()) self.pmdout.start_testpmd("all", "--coremask=%s --rxq=%d --txq=%d --portmask=%s" % (core_mask, queues, queues, port_mask)) info = "Executing PMD (mac fwd) using %s\n" % test_cycle['cores'] dts.report(info, annex=True) self.logger.info(info) dts.report(commandLine + "\n\n", frame=True, annex=True) # self.dut.send_expect("set fwd mac", "testpmd> ", 100) self.dut.send_expect("start", "testpmd> ") for frame_size in self.frame_sizes: wirespeed = self.wirespeed(self.nic, frame_size, 4) # create pcap file self.logger.info("Running with frame size %d " % frame_size) payload_size = frame_size - self.headers_size self.tester.scapy_append( 'wrpcap("test.pcap", [Ether(src="52:00:00:00:00:00")/IP()/UDP()/("X"*%d)])' % payload_size) self.tester.scapy_execute() # run traffic generator _, pps = self.tester.traffic_generator_throughput(tgen_input) pps /= 1000000.0 test_cycle['Mpps'][frame_size] = pps test_cycle['pct'][frame_size] = pps * 100 / wirespeed self.dut.send_expect("stop", "testpmd> ") self.dut.send_expect("quit", "# ", 30) sleep(5) for n in range(len(self.test_cycles)): for frame_size in self.frame_sizes: self.verify(self.test_cycles[n]['Mpps'][ frame_size] is not 0, "No traffic detected") # Print results dts.results_table_add_header(self.table_header) for frame_size in self.frame_sizes: table_row = [frame_size] for test_cycle in self.test_cycles: table_row.append(test_cycle['Mpps'][frame_size]) table_row.append(test_cycle['pct'][frame_size]) dts.results_table_add_row(table_row) self.plot_results(number_ports=4) dts.results_table_print() def test_perf_pmd_performance_2ports(self): """ PMD Performance Benchmarking with 2 ports. """ all_cores_mask = dts.create_mask(self.dut.get_core_list("all")) # prepare traffic generator input tgen_input = [] tgen_input.append((self.tester.get_local_port(self.dut_ports[0]), self.tester.get_local_port(self.dut_ports[1]), "test.pcap")) tgen_input.append((self.tester.get_local_port(self.dut_ports[1]), self.tester.get_local_port(self.dut_ports[0]), "test.pcap")) # run testpmd for each core config for test_cycle in self.test_cycles: core_config = test_cycle['cores'] core_list = self.dut.get_core_list(core_config, socket=self.ports_socket) if len(core_list) > 2: queues = len(core_list) / 2 else: queues = 1 core_mask = dts.create_mask(core_list) port_mask = dts.create_mask([self.dut_ports[0], self.dut_ports[1]]) self.pmdout.start_testpmd("all", "--coremask=%s --rxq=%d --txq=%d --portmask=%s" % (core_mask, queues, queues, port_mask)) command_line = self.pmdout.get_pmd_cmd() info = "Executing PMD using %s\n" % test_cycle['cores'] self.logger.info(info) dts.report(info, annex=True) dts.report(command_line + "\n\n", frame=True, annex=True) self.dut.send_expect("start", "testpmd> ") for frame_size in self.frame_sizes: wirespeed = self.wirespeed(self.nic, frame_size, 2) # create pcap file self.logger.info("Running with frame size %d " % frame_size) payload_size = frame_size - self.headers_size self.tester.scapy_append( 'wrpcap("test.pcap", [Ether(src="52:00:00:00:00:00")/IP()/UDP()/("X"*%d)])' % payload_size) self.tester.scapy_execute() # run traffic generator _, pps = self.tester.traffic_generator_throughput(tgen_input) pps /= 1000000.0 test_cycle['Mpps'][frame_size] = pps test_cycle['pct'][frame_size] = pps * 100 / wirespeed self.dut.send_expect("stop", "testpmd> ") self.dut.send_expect("quit", "# ", 30) sleep(5) for n in range(len(self.test_cycles)): for frame_size in self.frame_sizes: self.verify(self.test_cycles[n]['Mpps'][ frame_size] > 0, "No traffic detected") # Print results dts.results_table_add_header(self.table_header) for frame_size in self.frame_sizes: table_row = [frame_size] for test_cycle in self.test_cycles: table_row.append(test_cycle['Mpps'][frame_size]) table_row.append(test_cycle['pct'][frame_size]) dts.results_table_add_row(table_row) self.plot_results(number_ports=2) dts.results_table_print() def test_checksum_checking(self): """ Packet forwarding checking test """ self.dut.kill_all() all_cores_mask = dts.create_mask(self.dut.get_core_list("all")) core_mask = dts.create_mask(self.dut.get_core_list('1S/1C/1T', socket=self.ports_socket)) port_mask = dts.create_mask([self.dut_ports[0], self.dut_ports[1]]) for rxfreet_value in self.rxfreet_values: self.pmdout.start_testpmd("all", "--coremask=%s --portmask=%s --nb-cores=2 --enable-rx-cksum --disable-hw-vlan --disable-rss --crc-strip --rxd=1024 --txd=1024 --rxfreet=%d" % (core_mask, port_mask, rxfreet_value)) self.dut.send_expect("set fwd csum", "testpmd> ") self.dut.send_expect("start", "testpmd> ") self.send_packet(self.frame_sizes[0], checksum_test=True) l4csum_error = self.stop_and_get_l4csum_errors() # Check the l4 checksum errors reported for Rx port self.verify(1 == int(l4csum_error[1]), "Wrong l4 checksum error count using rxfreet=%d (expected 1, reported %s)" % (rxfreet_value, l4csum_error[1])) self.dut.send_expect("quit", "# ", 30) sleep(5) def test_packet_checking(self): """ Packet forwarding checking test """ self.dut.kill_all() all_cores_mask = dts.create_mask(self.dut.get_core_list("all")) core_mask = dts.create_mask(self.dut.get_core_list('1S/1C/1T', socket=self.ports_socket)) port_mask = dts.create_mask([self.dut_ports[0], self.dut_ports[1]]) self.pmdout.start_testpmd("all", "--coremask=%s --portmask=%s" % (core_mask, port_mask)) self.dut.send_expect("start", "testpmd> ") for size in self.frame_sizes: self.send_packet(size) self.dut.send_expect("stop", "testpmd> ") self.dut.send_expect("quit", "# ", 30) sleep(5) def stop_and_get_l4csum_errors(self): """ Stop forwarding and get Bad-l4csum number from stop statistic """ out = self.dut.send_expect("stop", "testpmd> ") result_scanner = r"Bad-l4csum: ([0-9]+) \s*" scanner = re.compile(result_scanner, re.DOTALL) m = scanner.findall(out) return m def get_stats(self, portid): """ Get packets number from port statistic """ stats = self.pmdout.get_pmd_stats(portid) return stats def send_packet(self, frame_size, checksum_test=False): """ Send 1 packet to portid """ port0_stats = self.get_stats(self.dut_ports[0]) gp0tx_pkts, gp0tx_bytes = [port0_stats['TX-packets'], port0_stats['TX-bytes']] port1_stats = self.get_stats(self.dut_ports[1]) gp1rx_pkts, gp1rx_err, gp1rx_bytes = [port1_stats['RX-packets'], port1_stats['RX-errors'], port1_stats['RX-bytes']] interface = self.tester.get_interface( self.tester.get_local_port(self.dut_ports[1])) mac = self.dut.get_mac_address(self.dut_ports[1]) load_size = frame_size - HEADER_SIZE['eth'] padding = frame_size - HEADER_SIZE['eth'] - HEADER_SIZE['ip'] - \ HEADER_SIZE['udp'] checksum = '' if checksum_test: checksum = 'chksum=0x0' self.tester.scapy_foreground() self.tester.scapy_append('nutmac="%s"' % mac) self.tester.scapy_append('sendp([Ether(dst=nutmac, src="52:00:00:00:00:00")/IP(len=%s)/UDP(%s)/Raw(load="\x50"*%s)], iface="%s")' % ( load_size, checksum, padding, interface)) out = self.tester.scapy_execute() time.sleep(.5) port0_stats = self.get_stats(self.dut_ports[0]) p0tx_pkts, p0tx_bytes = [port0_stats['TX-packets'], port0_stats['TX-bytes']] port1_stats = self.get_stats(self.dut_ports[1]) p1rx_pkts, p1rx_err, p1rx_bytes = [port1_stats['RX-packets'], port1_stats['RX-errors'], port1_stats['RX-bytes']] p0tx_pkts -= gp0tx_pkts p0tx_bytes -= gp0tx_bytes p1rx_pkts -= gp1rx_pkts p1rx_bytes -= gp1rx_bytes p1rx_err -= gp1rx_err time.sleep(5) self.verify(p0tx_pkts == p1rx_pkts, "packet pass assert error, %d RX packets, %d TX packets" % (p1rx_pkts, p0tx_pkts)) if checksum_test: self.verify(p1rx_bytes == frame_size - 4, "packet pass assert error, expected %d RX bytes, actual %d" % (frame_size - 4, p1rx_bytes)) else: self.verify(p1rx_bytes == frame_size, "packet pass assert error, expected %d RX bytes, actual %d" % (frame_size, p1rx_bytes)) self.verify(p0tx_bytes == frame_size, "packet pass assert error, expected %d TX bytes, actual %d" % (frame_size, p0tx_bytes)) return out def tear_down(self): """ Run after each test case. """ pass def tear_down_all(self): """ Run after each test suite. """ self.dut.kill_all()
class TestVlan(TestCase): def set_up_all(self): """ Run at the start of each test suite. Vlan Prerequistites """ # Based on h/w type, choose how many ports to use ports = self.dut.get_ports() # Verify that enough ports are available self.verify(len(ports) >= 2, "Insufficient ports") global valports valports = [_ for _ in ports if self.tester.get_local_port(_) != -1] portMask = dts.create_mask(valports[:2]) self.pmdout = PmdOutput(self.dut) self.pmdout.start_testpmd("all", "--portmask=%s" % portMask) self.dut.send_expect("set verbose 1", "testpmd> ") out = self.dut.send_expect("set fwd mac", "testpmd> ") self.dut.send_expect("vlan set strip off %s" % valports[0], "testpmd> ") self.verify('Set mac packet forwarding mode' in out, "set fwd rxonly error") def vlan_send_packet(self, vid, num=1): """ Send $num of packet to portid """ port = self.tester.get_local_port(valports[0]) txItf = self.tester.get_interface(port) port = self.tester.get_local_port(valports[1]) rxItf = self.tester.get_interface(port) mac = self.dut.get_mac_address(valports[0]) # FIXME send a burst with only num packet self.tester.scapy_background() self.tester.scapy_append('p=sniff(iface="%s",count=1,timeout=5)' % rxItf) self.tester.scapy_append('RESULT=str(p)') self.tester.scapy_foreground() self.tester.scapy_append('sendp([Ether(dst="%s")/Dot1Q(vlan=%s)/IP(len=46)], iface="%s")' % (mac, vid, txItf)) self.tester.scapy_execute() def set_up(self): """ Run before each test case. """ pass def test_vlan_enable_receipt(self): """ Enable receipt of VLAN packets """ self.dut.send_expect("set promisc all off", "testpmd> ") self.dut.send_expect("rx_vlan add 1 %s" % valports[0], "testpmd> ") self.dut.send_expect("start", "testpmd> ", 120) self.vlan_send_packet(1) out = self.tester.scapy_get_result() self.verify("vlan=1L" in out, "Wrong vlan:" + out) self.dut.send_expect("stop", "testpmd> ") def test_vlan_disable_receipt(self): """ Disable receipt of VLAN packets """ self.dut.send_expect("rx_vlan rm 1 %s" % valports[0], "testpmd> ") self.dut.send_expect("start", "testpmd> ", 120) self.vlan_send_packet(1) out = self.tester.scapy_get_result() self.verify("vlan=1L" not in out, "Wrong vlan:" + out) out = self.dut.send_expect("stop", "testpmd> ") def test_vlan_strip_config_on(self): """ Set vlan strip on """ self.dut.send_expect("vlan set strip on %s" % valports[0], "testpmd> ", 20) self.dut.send_expect("set promisc all off", "testpmd> ", 20) out = self.dut.send_expect("vlan set strip on %s" % valports[0], "testpmd> ", 20) self.verify("strip on" in out, "Wrong strip:" + out) self.dut.send_expect("start", "testpmd> ", 120) self.vlan_send_packet(1) out = self.tester.scapy_get_result() self.verify("vlan=1L" not in out, "Wrong vlan:" + out) out = self.dut.send_expect("quit", "#", 120) def test_vlan_strip_config_off(self): """ Set vlan strip off """ self.dut.send_expect("vlan set strip off %s" % valports[0], "testpmd> ", 20) out = self.dut.send_expect("show port info %s" % valports[0], "testpmd> ", 20) self.verify("strip off" in out, "Wrong strip:" + out) self.dut.send_expect("set nbport 2", "testpmd> ") self.dut.send_expect("start", "testpmd> ", 120) self.vlan_send_packet(1) out = self.tester.scapy_get_result() self.verify("vlan=1L" in out, "Wrong strip vlan:" + out) out = self.dut.send_expect("stop", "testpmd> ", 120) def FAILING_test_vlan_enable_vlan_insertion(self): """ Enable VLAN header insertion in transmitted packets """ port = self.tester.get_local_port(valports[0]) intf = self.tester.get_interface(port) self.dut.send_expect("set nbport 2", "testpmd> ") self.dut.send_expect("tx_vlan set 1 %s" % valports[0], "testpmd> ") self.dut.send_expect("set promisc all on", "testpmd> ") if self.nic == 'hartwell': self.dut.send_expect("vlan set strip on %s" % valports[0], "testpmd> ") self.tester.scapy_background() self.tester.scapy_append('p = sniff(iface="%s", count=1, timeout=5)' % intf) self.tester.scapy_append('RESULT=str(p)') self.tester.scapy_foreground() self.tester.scapy_execute() time.sleep(2) self.dut.send_expect("start tx_first", "testpmd> ") time.sleep(2) out = self.tester.scapy_get_result() self.verify("vlan=1L" in out, "Wrong vlan: " + out) self.dut.send_expect("quit", "# ", 30) def tear_down(self): """ Run after each test case. """ pass def tear_down_all(self): """ Run after each test suite. """ pass
class TestJumboframes(TestCase): def jumboframes_get_stat(self, portid, rx_tx): """ Get packets number from port statistic """ stats = self.pmdout.get_pmd_stats(portid) if rx_tx == "rx": return [stats['RX-packets'], stats['RX-errors'], stats['RX-bytes']] elif rx_tx == "tx": return [stats['TX-packets'], stats['TX-errors'], stats['TX-bytes']] else: return None def jumboframes_send_packet(self, pktsize, received=True): """ Send 1 packet to portid """ gp0tx_pkts, _, gp0tx_bytes = [int(_) for _ in self.jumboframes_get_stat(self.rx_port, "tx")] gp1rx_pkts, gp1rx_err, gp1rx_bytes = [int(_) for _ in self.jumboframes_get_stat(self.tx_port, "rx")] itf = self.tester.get_interface(self.tester.get_local_port(self.tx_port)) mac = self.dut.get_mac_address(self.tx_port) # The packet total size include ethernet header, ip header, and payload. # ethernet header length is 18 bytes, ip standard header length is 20 bytes. pktlen = pktsize - ETHER_HEADER_LEN padding = pktlen - IP_HEADER_LEN self.tester.scapy_foreground() self.tester.scapy_append('nutmac="%s"' % mac) self.tester.scapy_append('sendp([Ether(dst=nutmac, src="52:00:00:00:00:00")/IP(len=%s)/Raw(load="\x50"*%s)], iface="%s")' % (pktlen, padding, itf)) out = self.tester.scapy_execute() sleep(5) p0tx_pkts, _, p0tx_bytes = [int(_) for _ in self.jumboframes_get_stat(self.rx_port, "tx")] # p0tx_pkts, p0tx_err, p0tx_bytes p1rx_pkts, p1rx_err, p1rx_bytes = [int(_) for _ in self.jumboframes_get_stat(self.tx_port, "rx")] p0tx_pkts -= gp0tx_pkts p0tx_bytes -= gp0tx_bytes p1rx_pkts -= gp1rx_pkts p1rx_bytes -= gp1rx_bytes p1rx_err -= gp1rx_err if received: self.verify(p0tx_pkts == p1rx_pkts and p0tx_bytes == pktsize and p1rx_bytes == pktsize, "packet pass assert error") else: self.verify(p0tx_pkts == p1rx_pkts and (p1rx_err == 1 or p1rx_pkts == 0), "packet drop assert error") return out # # # # Test cases. # def set_up_all(self): """ Prerequisite steps for each test suit. """ self.dut_ports = self.dut.get_ports() self.verify(len(self.dut_ports) >= 2, "Insufficient ports") self.rx_port = self.dut_ports[0] self.tx_port = self.dut_ports[1] cores = self.dut.get_core_list('1S/2C/2T') self.coremask = dts.create_mask(cores) self.port_mask = dts.create_mask([self.rx_port, self.tx_port]) self.tester.send_expect("ifconfig %s mtu %s" % (self.tester.get_interface(self.tester.get_local_port(self.rx_port)), ETHER_JUMBO_FRAME_MTU + 200), "# ") self.tester.send_expect("ifconfig %s mtu %s" % (self.tester.get_interface(self.tester.get_local_port(self.tx_port)), ETHER_JUMBO_FRAME_MTU + 200), "# ") self.pmdout = PmdOutput(self.dut) def set_up(self): """ This is to clear up environment before the case run. """ self.dut.kill_all() def test_jumboframes_normal_nojumbo(self): """ This case aims to test transmitting normal size packet without jumbo frame on testpmd app. """ self.dut.kill_all() self.pmdout.start_testpmd("all", "--max-pkt-len=%d" % (ETHER_STANDARD_MTU)) self.dut.send_expect("start", "testpmd> ") self.jumboframes_send_packet(ETHER_STANDARD_MTU - 1) self.jumboframes_send_packet(ETHER_STANDARD_MTU) self.dut.send_expect("stop", "testpmd> ") self.dut.send_expect("quit", "# ", 30) def test_jumboframes_jumbo_nojumbo(self): """ This case aims to test transmitting jumbo frame packet on testpmd without jumbo frame support. """ self.dut.kill_all() self.pmdout.start_testpmd("all", "--max-pkt-len=%d" % (ETHER_STANDARD_MTU)) self.dut.send_expect("start", "testpmd> ") self.jumboframes_send_packet(ETHER_STANDARD_MTU + 1, False) self.dut.send_expect("stop", "testpmd> ") self.dut.send_expect("quit", "# ", 30) def test_jumboframes_normal_jumbo(self): """ When jumbo frame supported, this case is to verify that the normal size packet forwrding should be support correct. """ self.dut.kill_all() self.pmdout.start_testpmd("all", "--max-pkt-len=%s" % (ETHER_JUMBO_FRAME_MTU)) self.dut.send_expect("start", "testpmd> ") self.jumboframes_send_packet(1517) self.jumboframes_send_packet(1518) self.dut.send_expect("stop", "testpmd> ") self.dut.send_expect("quit", "# ", 30) def test_jumboframes_jumbo_jumbo(self): """ When jumbo frame supported, this case is to verify that jumbo frame packet can be forwarded correct. """ self.dut.kill_all() self.pmdout.start_testpmd("all", "--max-pkt-len=%s" % (ETHER_JUMBO_FRAME_MTU)) self.dut.send_expect("start", "testpmd> ") self.jumboframes_send_packet(ETHER_STANDARD_MTU + 1) self.jumboframes_send_packet(ETHER_JUMBO_FRAME_MTU - 1) self.jumboframes_send_packet(ETHER_JUMBO_FRAME_MTU) self.dut.send_expect("stop", "testpmd> ") self.dut.send_expect("quit", "# ", 30) def test_jumboframes_bigger_jumbo(self): """ When the jubmo frame MTU set as 9000, this case is to verify that the packet which the length bigger than MTU can not be forwarded. """ self.dut.kill_all() self.pmdout.start_testpmd("1S/2C/1T", "--max-pkt-len=%s" % (ETHER_JUMBO_FRAME_MTU)) self.dut.send_expect("start", "testpmd> ") self.jumboframes_send_packet(ETHER_JUMBO_FRAME_MTU + 1, False) self.dut.send_expect("quit", "# ", 30) def tear_down(self): """ Run after each test case. """ pass def tear_down_all(self): """ When the case of this test suite finished, the enviroment should clear up. """ self.tester.send_expect("ifconfig %s mtu %s" % (self.tester.get_interface(self.tester.get_local_port(self.rx_port)), ETHER_STANDARD_MTU), "# ") self.tester.send_expect("ifconfig %s mtu %s" % (self.tester.get_interface(self.tester.get_local_port(self.tx_port)), ETHER_STANDARD_MTU), "# ")
class TestBlackList(TestCase): def set_up_all(self): """ Run at the start of each test suite. Blacklist Prerequisites. Requirements: Two Ports """ self.ports = self.dut.get_ports() self.verify(len(self.ports) >= 2, "Insufficient ports for testing") [arch, machine, self.env, toolchain] = self.target.split('-') if self.env == 'bsdapp': self.regexp_blacklisted_port = "EAL: PCI device 0000:%02x:%s on NUMA socket [-0-9]+[^\n]*\nEAL: probe driver[^\n]*\nEAL: Device is blacklisted, not initializing" else: self.regexp_blacklisted_port = "EAL: PCI device 0000:%s on NUMA socket [-0-9]+[^\n]*\nEAL: probe driver[^\n]*\nEAL: Device is blacklisted, not initializing" self.pmdout = PmdOutput(self.dut) def set_up(self): """ Run before each test case. Nothing to do. """ pass def check_blacklisted_ports(self, output, ports, blacklisted=False): """ Check if any of the ports in `ports` have been blacklisted, if so, raise exception. If `blacklisted` is True, then raise an exception if any of the ports in `ports` have not been blacklisted. """ for port in ports: # Look for the PCI ID of each card followed by # "Device is blacklisted, not initializing" but avoid to consume more # than one device. if self.env == 'bsdapp': pci = self.dut.ports_info[port]['pci'] regexp_blacklisted_port = self.regexp_blacklisted_port % (int(pci.split(':')[0], 16), pci.split(':')[1]) else: regexp_blacklisted_port = self.regexp_blacklisted_port % self.dut.ports_info[port]['pci'] matching_ports = dts.regexp(output, regexp_blacklisted_port, True) if blacklisted: self.verify(len(matching_ports) == 1, "Blacklisted port is being initialized") else: self.verify(len(matching_ports) == 0, "Not blacklisted port is being blacklisted") def test_bl_noblacklisted(self): """ Run testpmd with no blacklisted device. """ out = self.pmdout.start_testpmd("Default") rexp = r"Link" match_status = dts.regexp(out, rexp, True) self.check_blacklisted_ports(out, self.ports) def test_bl_oneportblacklisted(self): """ Run testpmd with one port blacklisted. """ self.dut.kill_all() out = self.pmdout.start_testpmd("Default", eal_param="-b 0000:%s -- -i" % self.dut.ports_info[0]['pci']) self.check_blacklisted_ports(out, self.ports[1:]) def test_bl_allbutoneportblacklisted(self): """ Run testpmd with all but one port blacklisted. """ self.dut.kill_all() ports_to_blacklist = self.ports[:-1] cmdline = "" for port in ports_to_blacklist: cmdline += " -b 0000:%s" % self.dut.ports_info[port]['pci'] out = self.pmdout.start_testpmd("Default", eal_param=cmdline) blacklisted_ports = self.check_blacklisted_ports(out, ports_to_blacklist, True) def tear_down(self): """ Run after each test case. Quit testpmd. """ self.dut.send_expect("quit", "# ", 10) def tear_down_all(self): """ Run after each test suite. Nothing to do. """ pass