def send_packet_pctype(self, mac, pkt_type="udp", frag=0, flags=None, tag=None, ethertype=None): """ send different PCTYPE packets. """ if (pkt_type == "udp"): pkt = Packet(pkt_type='UDP') pkt.config_layer('ether', {'dst': mac, 'src': self.tester_mac}) elif (pkt_type == "tcp"): pkt = Packet(pkt_type='TCP') pkt.config_layer('ether', {'dst': mac, 'src': self.tester_mac}) pkt.config_layer('tcp', {'flags': flags}) elif (pkt_type == "sctp"): pkt = Packet(pkt_type='SCTP') pkt.config_layer('ether', {'dst': mac, 'src': self.tester_mac}) pkt.config_layer('sctp', {'tag': tag}) elif (pkt_type == "ipv4"): pkt = Packet(pkt_type='IP_RAW') pkt.config_layer('ether', {'dst': mac, 'src': self.tester_mac}) pkt.config_layer('ipv4', {'frag': frag}) elif (pkt_type == "ipv6_udp"): pkt = Packet(pkt_type='IPv6_UDP') pkt.config_layer('ether', {'dst': mac, 'src': self.tester_mac}) elif (pkt_type == "ipv6_tcp"): pkt = Packet(pkt_type='IPv6_TCP') pkt.config_layer('ether', {'dst': mac, 'src': self.tester_mac}) elif (pkt_type == "ipv6_sctp"): pkt = Packet(pkt_type='IPv6_SCTP') pkt.config_layer('ether', {'dst': mac, 'src': self.tester_mac}) pkt.config_layer('sctp', {'tag': tag}) elif (pkt_type == "ipv6"): pkt = Packet() pkt.assign_layers(['ether', 'ipv6', 'raw']) pkt.config_layer('ether', {'dst': mac, 'src': self.tester_mac}) elif (pkt_type == "L2"): pkt = Packet() pkt.assign_layers(['ether', 'raw']) pkt.config_layer('ether', { 'dst': mac, 'src': self.tester_mac, 'type': ethertype }) pkt.send_pkt(tx_port=self.tester_intf)
def run_nvgre_cope(self, pkt_nvgre): time.sleep(1) for pkts in pkt_nvgre: pkt = Packet() pkt.assign_layers(pkts[2]) if 'inner_icmp' in pkts[2]: pkt.config_layers([('ipv6',{'nh':47}), ('inner_ipv6', {'nh': 58})]) else: pkt.config_layers([('ipv6',{'nh':47}),('inner_ipv6', {'nh': 132})]) pkt.send_pkt(tx_port=self.tester_iface) out = self.dut.get_session_output(timeout=2) for pkt_layer_name in pkts[1]: if pkt_layer_name not in out: print utils.RED("Fail to detect %s" % pkt_layer_name) raise VerifyFailure("Failed to detect %s" % pkt_layer_name) print utils.GREEN("Detected %s successfully" % pkts[0])
def send_packet_up(self, mac, pkt_type="udp", prio=0): """ send different User Priority packets. """ if (pkt_type == "ipv4"): pkt = Packet() pkt.assign_layers(['ether', 'vlan', 'ipv4', 'raw']) pkt.config_layer('ether', {'dst': mac, 'src': self.tester_mac}) pkt.config_layer('vlan', {'vlan': 0, 'prio': prio}) elif (pkt_type == "udp"): pkt = Packet(pkt_type='VLAN_UDP') pkt.config_layer('ether', {'dst': mac, 'src': self.tester_mac}) pkt.config_layer('vlan', {'vlan': 0, 'prio': prio}) elif (pkt_type == "tcp"): pkt = Packet() pkt.assign_layers(['ether', 'vlan', 'ipv4', 'tcp', 'raw']) pkt.config_layer('ether', {'dst': mac, 'src': self.tester_mac}) pkt.config_layer('vlan', {'vlan': 0, 'prio': prio}) elif (pkt_type == "ipv6_udp"): pkt = Packet() pkt.assign_layers(['ether', 'vlan', 'ipv6', 'udp', 'raw']) pkt.config_layer('ether', {'dst': mac, 'src': self.tester_mac}) pkt.config_layer('vlan', {'vlan': 0, 'prio': prio}) pkt.send_pkt(tx_port=self.tester_intf)
def _execute_ipsec_gw_test(self, ipsec_gw_opt_str): result = True eal_opt_str = cc.get_eal_opt_str(self) cmd_str = cc.get_dpdk_app_cmd_str(self._app_path, eal_opt_str, ipsec_gw_opt_str) self.logger.info("IPsec-gw cmd: " + cmd_str) self.dut.send_expect(cmd_str, "IPSEC:", 30) time.sleep(3) inst = self.tester.tcpdump_sniff_packets(self.rx_interface, timeout=25) PACKET_COUNT = 65 payload = 256 * ['11'] case_cfgs = self.get_case_cfg() dst_ip = case_cfgs["dst_ip"] src_ip = case_cfgs["src_ip"] expected_dst_ip = case_cfgs["expected_dst_ip"] expected_src_ip = case_cfgs["expected_src_ip"] expected_spi = case_cfgs["expected_spi"] expected_length = case_cfgs["expected_length"] #expected_data = case_cfgs["expected_data"] pkt = Packet() if len(dst_ip) <= 15: pkt.assign_layers(["ether", "ipv4", "udp", "raw"]) pkt.config_layer("ether", { "src": "52:00:00:00:00:00", "dst": "52:00:00:00:00:01" }) pkt.config_layer("ipv4", {"src": src_ip, "dst": dst_ip}) else: pkt.assign_layers(["ether", "ipv6", "udp", "raw"]) pkt.config_layer("ether", { "src": "52:00:00:00:00:00", "dst": "52:00:00:00:00:01" }) pkt.config_layer("ipv6", {"src": src_ip, "dst": dst_ip}) pkt.config_layer("udp", {"dst": 0}) pkt.config_layer("raw", {"payload": payload}) pkt.send_pkt(tx_port=self.tx_interface, count=PACKET_COUNT) pkt_rec = self.tester.load_tcpdump_sniff_packets(inst) pcap_filename = "output/{0}.pcap".format(self.pcap_filename) self.logger.info("Save pkts to {0}".format(pcap_filename)) save_packets(pkt_rec, pcap_filename) self._pcap_idx = self._pcap_idx + 1 if len(pkt_rec) == 0: self.logger.error("IPsec forwarding failed") result = False for pkt_r in pkt_rec: pkt_src_ip = pkt_r.pktgen.strip_layer3("src") if pkt_src_ip != expected_src_ip: pkt_r.pktgen.pkt.show() self.logger.error( "SRC IP does not match. Pkt:{0}, Expected:{1}".format( pkt_src_ip, expected_src_ip)) result = False break pkt_dst_ip = pkt_r.pktgen.strip_layer3("dst") self.logger.debug(pkt_dst_ip) if pkt_dst_ip != expected_dst_ip: pkt_r.pktgen.pkt.show() self.logger.error( "DST IP does not match. Pkt:{0}, Expected:{1}".format( pkt_dst_ip, expected_dst_ip)) result = False break packet_hex = pkt_r.pktgen.pkt["ESP"].getfieldval("data") if packet_hex is None: self.logger.error("NO Payload !") result = False break payload_str = binascii.b2a_hex(packet_hex) self.logger.debug(payload_str) pkt_spi = hex(pkt_r.pktgen.pkt["ESP"].getfieldval("spi")) self.logger.debug(pkt_spi) if pkt_spi != expected_spi: self.logger.error( "SPI does not match. Pkt:{0}, Expected:{1}".format( pkt_spi, expected_spi)) result = False break pkt_len = len(payload_str) / 2 self.logger.debug(pkt_len) if pkt_len != int(expected_length): self.logger.error( "Packet length does not match. Pkt:{0}, Expected:{1}". format(pkt_len, expected_length)) result = False break self.dut.kill_all() return result
class CloudFilterConfig(object): """ Module for config/verify cloud filter rule """ RULE_TYPE = [ 'iip', 'imac', 'omac+imac+vni', 'imac+ivlan+vni', 'imac+ivlan' ] def __init__(self, test_case, pf_intf=""): self.case = test_case # make sure pf existed out = self.case.dut.send_expect('ifconfig %s' % pf_intf, "#", alt_session=True) self.case.verify("Device not found" not in out, "Cloud filter need PF interface!!!") self.pf_intf = pf_intf self.pkt = Packet() def config_rule(self, **kwargs): """ Configure cloud filter rule settings, must check rule format """ self.rule_idx = 1 self.case.verify('type' in kwargs, "Cloud filter rule must configure filter type") rule_type = kwargs['type'] self.case.verify(rule_type in self.RULE_TYPE, "Cloud filter rule type not correct") self.case.verify('vf' in kwargs, "Cloud filter rule must configure device!!!") self.case.verify('queue' in kwargs, "Cloud filter rule must configure queue index") if 'loc' in kwargs: self.rule_idx = kwargs['loc'] self.cf_rule = {} self.cf_rule['type'] = rule_type self.cf_rule['vf'] = kwargs['vf'] self.cf_rule['queue'] = kwargs['queue'] required_args = rule_type.split('+') for required_arg in required_args: self.case.verify(required_arg in kwargs, "Argument for [%s] missing!!!" % required_arg) self.cf_rule[required_arg] = kwargs[required_arg] if 'ivlan' in self.cf_rule: self.pkt.assign_layers([ 'ether', 'ipv4', 'udp', 'vxlan', 'inner_mac', 'inner_vlan', 'inner_ipv4', 'inner_tcp', 'raw' ]) else: self.pkt.assign_layers([ 'ether', 'ipv4', 'udp', 'vxlan', 'inner_mac', 'inner_ipv4', 'inner_tcp', 'raw' ]) def ethtool_add(self): """ Add cloud filter rule by ethtool and return rule index """ ip_fmt = "ethtool -N %(PF)s flow-type ip4 dst-ip %(IP)s user-def " + \ "%(VNI_VF)s action %(QUEUE)d loc %(ID)d" ether_fmt = "ethtool -N %(PF)s flow-type ether dst %(OMAC)s m " + \ "%(OMASK)s src %(IMAC)s m %(IMASK)s user-def %(VNI_VF)s " + \ "action %(QUEUE)d loc %(ID)d" ether_vlan_fmt = "ethtool -N %(PF)s flow-type ether dst %(OMAC)s m " + \ "%(OMASK)s src %(IMAC)s m %(IMASK)s vlan %(VLAN)d " + \ "user-def %(VNI_VF)s action %(QUEUE)d loc %(ID)d" # generate user define field vni_vf = '0x' if 'vni' in self.cf_rule: vni_str = hex(self.cf_rule['vni'])[2:] else: vni_str = 'ffffffff' # without vni vni_vf += vni_str vf_str = "%08x" % self.cf_rule['vf'] vni_vf += vf_str if 'omac' in self.cf_rule: omac_str = self.cf_rule['omac'] omac_mask = '00:00:00:00:00:00' else: omac_str = '00:00:00:00:00:00' omac_mask = 'ff:ff:ff:ff:ff:ff' if 'imac' in self.cf_rule: imac_str = self.cf_rule['imac'] imac_mask = '00:00:00:00:00:00' else: imac_str = '00:00:00:00:00:00' imac_mask = 'ff:ff:ff:ff:ff:ff' if 'iip' in self.cf_rule: ip_str = self.cf_rule['iip'] if self.cf_rule['type'] == 'iip': ethtool_cmd = ip_fmt % { 'PF': self.pf_intf, 'IP': ip_str, 'VNI_VF': vni_vf, 'QUEUE': self.cf_rule['queue'], 'ID': self.rule_idx } elif 'ivlan' in self.cf_rule: ethtool_cmd = ether_vlan_fmt % { 'PF': self.pf_intf, 'OMAC': omac_str, 'OMASK': omac_mask, 'IMAC': imac_str, 'IMASK': imac_mask, 'VLAN': self.cf_rule['ivlan'], 'VNI_VF': vni_vf, 'QUEUE': self.cf_rule['queue'], 'ID': self.rule_idx } else: ethtool_cmd = ether_fmt % { 'PF': self.pf_intf, 'OMAC': omac_str, 'OMASK': omac_mask, 'IMAC': imac_str, 'IMASK': imac_mask, 'VNI_VF': vni_vf, 'QUEUE': self.cf_rule['queue'], 'ID': self.rule_idx } print ethtool_cmd out = self.case.dut.send_expect(ethtool_cmd, "# ", alt_session=True) self.case.verify("ethtool" not in out, "Add cloud filter failed!!!") return self.rule_idx def ethtool_delete(self): """ Delete cloud filter rule by index and return whether success """ self.case.dut.send_expect("ethtool -N %s delete %d" % (self.pf_intf, self.rule_idx), "# ", alt_session=True) def ethtool_dumprule(self): """ Dump cloud filter rule according to index value """ pass def transmit_packet(self, match=True): """ Send packet match or not matched cloud filter rules """ ether_cfg = {'src': self.case.tester_mac} if match: if 'iip' in self.cf_rule.keys(): self.pkt.config_layer('inner_ipv4', {'dst': self.cf_rule['iip']}) if 'imac' in self.cf_rule.keys(): self.pkt.config_layer('inner_mac', {'dst': self.cf_rule['imac']}) if 'omac' in self.cf_rule.keys(): ether_cfg['dst'] = self.cf_rule['omac'] if 'ivlan' in self.cf_rule.keys(): self.pkt.config_layer('inner_vlan', {'vlan': self.cf_rule['ivlan']}) if 'vni' in self.cf_rule.keys(): self.pkt.config_layer('vxlan', {'vni': self.cf_rule['vni']}) self.pkt.config_layer('ether', ether_cfg) self.pkt.config_layer('raw', {'payload': ['01'] * 18}) self.pkt.send_pkt(tx_port=self.case.tester_intf)
def send_and_verify(self, verify_type): """ Verify the virtio-pmd can receive the data before/after change queue size While verify_type is "vhost queue = virtio queue", the vhost should forward all set of data While verify_type is "vhost queue < virtio queue", the vhost should forward all set of data While verify_type is "vhost queue > virtio queue", the vhost should forward at least one set of data """ for frame_size in self.frame_sizes: info = "Running test %s, and %d frame size." % (self.running_case, frame_size) self.logger.info(info) self.dut.send_expect("clear port stats all", "testpmd> ", 120) payload_size = frame_size - HEADER_SIZE['eth'] - HEADER_SIZE[ 'ip'] - HEADER_SIZE['udp'] pkt1 = Packet() pkt1.assign_layers(['ether', 'ipv4', 'udp', 'raw']) pkt1.config_layers([('ether', { 'dst': '%s' % self.virtio1_mac }), ('ipv4', { 'dst': '1.1.1.1' }), ('udp', { 'src': 4789, 'dst': 4789 }), ('raw', { 'payload': ['01'] * int('%d' % payload_size) })]) pkt2 = Packet() pkt2.assign_layers(['ether', 'ipv4', 'udp', 'raw']) pkt2.config_layers([('ether', { 'dst': '%s' % self.virtio1_mac }), ('ipv4', { 'dst': '1.1.1.20' }), ('udp', { 'src': 4789, 'dst': 4789 }), ('raw', { 'payload': ['01'] * int('%d' % payload_size) })]) pkt3 = Packet() pkt3.assign_layers(['ether', 'ipv4', 'udp', 'raw']) pkt3.config_layers([('ether', { 'dst': '%s' % self.virtio1_mac }), ('ipv4', { 'dst': '1.1.1.7' }), ('udp', { 'src': 4789, 'dst': 4789 }), ('raw', { 'payload': ['01'] * int('%d' % payload_size) })]) pkt4 = Packet() pkt4.assign_layers(['ether', 'ipv4', 'udp', 'raw']) pkt4.config_layers([('ether', { 'dst': '%s' % self.virtio1_mac }), ('ipv4', { 'dst': '1.1.1.8' }), ('udp', { 'src': 4789, 'dst': 4789 }), ('raw', { 'payload': ['01'] * int('%d' % payload_size) })]) pkt = [pkt1, pkt2, pkt3, pkt4] * 10 send_packets(self.tx_interface, pkt) out = self.dut.send_expect("show port stats 0", "testpmd> ", 120) print out rx_packet = re.search("RX-packets:\s*(\d*)", out) rx_num = int(rx_packet.group(1)) tx_packet = re.search("TX-packets:\s*(\d*)", out) tx_num = int(tx_packet.group(1)) if verify_type == "vhost queue = virtio queue" or verify_type == "vhost queue < virtio queue": verify_rx_num = 40 verify_tx_num = 40 elif verify_type == "vhost queue > virtio queue": verify_rx_num = 40 verify_tx_num = 10 self.verify( rx_num >= verify_rx_num and tx_num >= verify_tx_num, "The rx or tx lost some packets of frame-size:%d" % frame_size)
def vhost_performance(self): """ Verify the testpmd can receive and forward the data """ self.result_table_create(self.header_row) for frame_size in self.frame_sizes: info = "Running test %s, and %d frame size." % (self.running_case, frame_size) self.logger.info(info) payload_size = frame_size - HEADER_SIZE['eth'] - HEADER_SIZE[ 'ip'] - HEADER_SIZE['udp'] tgenInput = [] pkt1 = Packet() pkt1.assign_layers(['ether', 'ipv4', 'udp', 'raw']) pkt1.config_layers([('ether', { 'dst': '%s' % self.virtio1_mac }), ('ipv4', { 'dst': '1.1.1.1' }), ('udp', { 'src': 4789, 'dst': 4789 }), ('raw', { 'payload': ['01'] * int('%d' % payload_size) })]) pkt2 = Packet() pkt2.assign_layers(['ether', 'ipv4', 'udp', 'raw']) pkt2.config_layers([('ether', { 'dst': '%s' % self.virtio1_mac }), ('ipv4', { 'dst': '1.1.1.20' }), ('udp', { 'src': 4789, 'dst': 4789 }), ('raw', { 'payload': ['01'] * int('%d' % payload_size) })]) pkt3 = Packet() pkt3.assign_layers(['ether', 'ipv4', 'udp', 'raw']) pkt3.config_layers([('ether', { 'dst': '%s' % self.virtio1_mac }), ('ipv4', { 'dst': '1.1.1.7' }), ('udp', { 'src': 4789, 'dst': 4789 }), ('raw', { 'payload': ['01'] * int('%d' % payload_size) })]) pkt4 = Packet() pkt4.assign_layers(['ether', 'ipv4', 'udp', 'raw']) pkt4.config_layers([('ether', { 'dst': '%s' % self.virtio1_mac }), ('ipv4', { 'dst': '1.1.1.8' }), ('udp', { 'src': 4789, 'dst': 4789 }), ('raw', { 'payload': ['01'] * int('%d' % payload_size) })]) pkt = [pkt1, pkt2, pkt3, pkt4] save_packets(pkt, "/root/multiqueue_2.pcap") port = self.tester.get_local_port(self.pf) tgenInput.append((port, port, "multiqueue_2.pcap")) _, pps = self.tester.traffic_generator_throughput(tgenInput, delay=30) Mpps = pps / 1000000.0 pct = Mpps * 100 / float( self.wirespeed(self.nic, frame_size, self.number_of_ports)) data_row = [ frame_size, str(Mpps), str(pct), "Mergeable Multiqueue Performance" ] self.result_table_add(data_row) self.verify(Mpps != 0, "The receive data of frame-size: %d is 0" % frame_size) self.result_table_print()