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()
