3 from ipaddress import ip_address, ip_interface
4 from vpp_qemu_utils import (
8 delete_host_interfaces,
10 disable_interface_gso,
13 from vpp_iperf import start_iperf, stop_iperf
14 from framework import VppTestCase, VppTestRunner
15 from config import config
16 from vpp_papi import VppEnum
19 from vm_test_config import test_config
23 # - tapv2, tunv2 & af_packet_v2 & v3 interfaces.
24 # - reads test config from the file vm_test_config.py
25 # - Uses iPerf to send TCP/IP streams to VPP
26 # - VPP ingress interface runs the iperf client
27 # - VPP egress interface runs the iperf server
28 # - Runs tests specified in the vm_test_config module and verifies that:
29 # - TCP over IPv4 and IPv6 is enabled correctly for Bridged and Routed topologies.
30 # sending jumbo frames (9000/9001 MTUs) with GSO/GRO is enabled correctly.
31 # sending VPP buffer-sized frames(2048 MTU) with GSO/GRO is enabled correctly.
32 # sending standard frames (1500 MTU) with GSO/GRO is enabled correctly.
33 # sending smaller frames (512 MTU) with GSO/GRO is enabled correctly for IPv4
34 # sending odd sized frames (9001, 2049 MTU) with GSO/GRO is enabled correctly.
38 def filter_tests(test):
39 """Filter test IDs to include only those selected to run."""
40 selection = test_config["tests_to_run"]
41 if not selection or selection == " ":
45 for test_id in selection.split(","):
46 if "-" in test_id.strip():
47 start, end = map(int, test_id.split("-"))
48 test_ids_to_run.extend(list(range(start, end + 1)))
50 test_ids_to_run.append(int(test_id))
51 return test["id"] in test_ids_to_run
54 # Test Config variables
55 client_namespace = test_config["client_namespace"]
56 server_namespace = test_config["server_namespace"]
57 tests = filter(filter_tests, test_config["tests"])
58 af_packet_config = test_config["af_packet"]
59 layer2 = test_config["L2"]
60 layer3 = test_config["L3"]
63 def create_test(test_name, test, ip_version, mtu):
64 """Create and return a unittest method for a test."""
67 self.logger.debug(f"Starting unittest:{test_name}")
68 self.setUpTestToplogy(test=test, ip_version=ip_version)
69 result = self.set_interfaces_mtu(
71 ip_version=ip_version,
72 vpp_interfaces=self.vpp_interfaces,
73 linux_interfaces=self.linux_interfaces,
75 # Start the Iperf server in dual stack mode & run iperf client
77 start_iperf(ip_version=6, server_only=True, logger=self.logger)
80 ip_version=ip_version,
81 server_ipv4_address=self.server_ip4_address,
82 server_ipv6_address=self.server_ip6_address,
90 f"Skipping test:{test_name} as mtu:{mtu} is "
91 f"invalid for TCP/IPv{ip_version}"
94 test_func.__name__ = test_name
98 def generate_vpp_interface_tests():
99 """Generate unittests for testing vpp interfaces."""
101 for ip_version in test_config["ip_versions"]:
102 for mtu in test_config["mtus"]:
104 f"test_id_{test['id']}_"
105 + f"client_{test['client_if_type']}"
106 + f"_v{test['client_if_version']}_"
107 + f"gso_{test.get('client_if_gso', 0)}_"
108 + f"gro_{test.get('client_if_gro', 0)}_"
109 + f"to_server_{test['server_if_type']}"
110 + f"_v{test['server_if_version']}_"
111 + f"gso_{test.get('server_if_gso', 0)}_"
112 + f"gro_{test.get('server_if_gro', 0)}_"
113 + f"mtu_{mtu}_mode_{test['x_connect_mode']}_"
114 + f"tcp_ipv{ip_version}"
116 test_func = create_test(
117 test_name=test_name, test=test, ip_version=ip_version, mtu=mtu
119 setattr(TestVPPInterfacesQemu, test_name, test_func)
122 class TestVPPInterfacesQemu(VppTestCase):
123 """Test VPP interfaces inside a QEMU VM for IPv4/v6.
126 Linux_ns1--iperfClient--host-int1--vpp-af_packet-int1--VPP-BD
127 --vppaf_packet_int2--host-int2--iperfServer--Linux_ns2
132 super(TestVPPInterfacesQemu, cls).setUpClass()
135 def tearDownClass(cls):
136 super(TestVPPInterfacesQemu, cls).tearDownClass()
138 def setUpTestToplogy(self, test, ip_version):
139 """Setup the test topology.
141 1. Create Linux Namespaces for iPerf Client & Server.
142 2. Create VPP iPerf client and server virtual interfaces.
143 3. Enable desired vif features such as GSO & GRO.
144 3. Cross-Connect interfaces in VPP using L2 or L3.
146 super(TestVPPInterfacesQemu, self).setUp()
147 client_if_type = test["client_if_type"]
148 server_if_type = test["server_if_type"]
149 client_if_version = test["client_if_version"]
150 server_if_version = test["server_if_version"]
151 x_connect_mode = test["x_connect_mode"]
152 # server ip4/ip6 addresses required by iperf client
153 server_ip4_prefix = (
154 layer2["server_ip4_prefix"]
155 if x_connect_mode == "L2"
156 else layer3["server_ip4_prefix"]
158 server_ip6_prefix = (
159 layer2["server_ip6_prefix"]
160 if x_connect_mode == "L2"
161 else layer3["server_ip6_prefix"]
163 self.server_ip4_address = str(ip_interface(server_ip4_prefix).ip)
164 self.server_ip6_address = str(ip_interface(server_ip6_prefix).ip)
165 # next-hop IP address on VPP for routing from client & server namespaces
166 vpp_client_prefix = (
167 layer3["vpp_client_ip4_prefix"]
169 else layer3["vpp_client_ip6_prefix"]
171 vpp_client_nexthop = str(ip_interface(vpp_client_prefix).ip)
172 vpp_server_prefix = (
173 layer3["vpp_server_ip4_prefix"]
175 else layer3["vpp_server_ip6_prefix"]
177 vpp_server_nexthop = str(ip_interface(vpp_server_prefix).ip)
178 create_namespace([client_namespace, server_namespace])
179 self.vpp_interfaces = []
180 self.linux_interfaces = []
181 enable_client_if_gso = test.get("client_if_gso", 0)
182 enable_server_if_gso = test.get("server_if_gso", 0)
183 enable_client_if_gro = test.get("client_if_gro", 0)
184 enable_server_if_gro = test.get("server_if_gro", 0)
185 ## Handle client interface types
186 if client_if_type == "af_packet":
187 create_host_interface(
188 af_packet_config["iprf_client_interface_on_linux"],
189 af_packet_config["iprf_client_interface_on_vpp"],
191 layer2["client_ip4_prefix"]
192 if x_connect_mode == "L2"
193 else layer3["client_ip4_prefix"],
194 layer2["client_ip6_prefix"]
195 if x_connect_mode == "L2"
196 else layer3["client_ip6_prefix"],
198 self.ingress_if_idx = self.create_af_packet(
199 version=client_if_version,
200 host_if_name=af_packet_config["iprf_client_interface_on_vpp"],
201 enable_gso=enable_client_if_gso,
203 self.vpp_interfaces.append(self.ingress_if_idx)
204 self.linux_interfaces.append(
205 ["", af_packet_config["iprf_client_interface_on_vpp"]]
207 self.linux_interfaces.append(
208 [client_namespace, af_packet_config["iprf_client_interface_on_linux"]]
210 if enable_client_if_gso == 0:
211 disable_interface_gso(
212 "", af_packet_config["iprf_client_interface_on_vpp"]
214 disable_interface_gso(
215 client_namespace, af_packet_config["iprf_client_interface_on_linux"]
217 elif client_if_type == "tap" or client_if_type == "tun":
218 self.ingress_if_idx = self.create_tap_tun(
220 host_namespace=client_namespace,
221 ip_version=ip_version,
222 host_ip4_prefix=layer2["client_ip4_prefix"]
223 if x_connect_mode == "L2"
224 else layer3["client_ip4_prefix"],
225 host_ip6_prefix=layer2["client_ip6_prefix"]
226 if x_connect_mode == "L2"
227 else layer3["client_ip6_prefix"],
228 host_ip4_gw=vpp_client_nexthop
229 if x_connect_mode == "L3" and ip_version == 4
231 host_ip6_gw=vpp_client_nexthop
232 if x_connect_mode == "L3" and ip_version == 6
234 int_type=client_if_type,
235 host_if_name=f"{client_if_type}0",
236 enable_gso=enable_client_if_gso,
237 enable_gro=enable_client_if_gro,
239 self.vpp_interfaces.append(self.ingress_if_idx)
240 self.linux_interfaces.append([client_namespace, f"{client_if_type}0"])
241 # Seeing TCP timeouts if tx=on & rx=on Linux tap & tun interfaces
242 disable_interface_gso(client_namespace, f"{client_if_type}0")
245 f"Unsupported client interface type: {client_if_type} "
246 f"for test - ID={test['id']}"
250 if server_if_type == "af_packet":
251 create_host_interface(
252 af_packet_config["iprf_server_interface_on_linux"],
253 af_packet_config["iprf_server_interface_on_vpp"],
258 self.egress_if_idx = self.create_af_packet(
259 version=server_if_version,
260 host_if_name=af_packet_config["iprf_server_interface_on_vpp"],
261 enable_gso=enable_server_if_gso,
263 self.vpp_interfaces.append(self.egress_if_idx)
264 self.linux_interfaces.append(
265 ["", af_packet_config["iprf_server_interface_on_vpp"]]
267 self.linux_interfaces.append(
268 [server_namespace, af_packet_config["iprf_server_interface_on_linux"]]
270 if enable_server_if_gso == 0:
271 disable_interface_gso(
272 "", af_packet_config["iprf_server_interface_on_vpp"]
274 disable_interface_gso(
275 server_namespace, af_packet_config["iprf_server_interface_on_linux"]
277 elif server_if_type == "tap" or server_if_type == "tun":
278 self.egress_if_idx = self.create_tap_tun(
280 host_namespace=server_namespace,
281 ip_version=ip_version,
282 host_ip4_prefix=layer2["server_ip4_prefix"]
283 if x_connect_mode == "L2"
284 else layer3["server_ip4_prefix"],
285 host_ip6_prefix=layer2["server_ip6_prefix"]
286 if x_connect_mode == "L2"
287 else layer3["server_ip6_prefix"],
288 int_type=server_if_type,
289 host_if_name=f"{server_if_type}0",
290 enable_gso=enable_server_if_gso,
291 enable_gro=enable_server_if_gro,
293 self.vpp_interfaces.append(self.egress_if_idx)
294 self.linux_interfaces.append([server_namespace, f"{server_if_type}0"])
295 # Seeing TCP timeouts if tx=on & rx=on Linux tap & tun interfaces
296 disable_interface_gso(server_namespace, f"{server_if_type}0")
299 f"Unsupported server interface type: {server_if_type} "
300 f"for test - ID={test['id']}"
304 if x_connect_mode == "L2":
305 self.l2_connect_interfaces(1, self.ingress_if_idx, self.egress_if_idx)
306 elif x_connect_mode == "L3":
307 # L3 connect client & server side
308 vrf_id = layer3["ip4_vrf"] if ip_version == 4 else layer3["ip6_vrf"]
309 self.l3_connect_interfaces(
312 (self.ingress_if_idx, vpp_client_prefix),
313 (self.egress_if_idx, vpp_server_prefix),
315 # Setup namespace routing
317 add_namespace_route(client_namespace, "0.0.0.0/0", vpp_client_nexthop)
318 add_namespace_route(server_namespace, "0.0.0.0/0", vpp_server_nexthop)
320 add_namespace_route(client_namespace, "::/0", vpp_client_nexthop)
321 add_namespace_route(server_namespace, "::/0", vpp_server_nexthop)
322 # Wait for Linux IPv6 stack to become ready
328 self.vapi.tap_delete_v2(self.ingress_if_idx)
332 self.vapi.tap_delete_v2(self.egress_if_idx)
336 for interface in self.vapi.af_packet_dump():
338 interface.host_if_name
339 == af_packet_config["iprf_client_interface_on_vpp"]
341 self.vapi.af_packet_delete(
342 af_packet_config["iprf_client_interface_on_vpp"]
345 interface.host_if_name
346 == af_packet_config["iprf_server_interface_on_vpp"]
348 self.vapi.af_packet_delete(
349 af_packet_config["iprf_server_interface_on_vpp"]
354 delete_host_interfaces(
355 af_packet_config["iprf_client_interface_on_linux"],
356 af_packet_config["iprf_server_interface_on_linux"],
357 af_packet_config["iprf_client_interface_on_vpp"],
358 af_packet_config["iprf_server_interface_on_vpp"],
363 self.vapi.ip_table_add_del(is_add=0, table={"table_id": layer3["ip4_vrf"]})
367 self.vapi.ip_table_add_del(is_add=0, table={"table_id": layer3["ip6_vrf"]})
384 def create_af_packet(self, version, host_if_name, enable_gso=0):
385 """Create an af_packetv3 interface in VPP.
388 version -- 2 for af_packet_create_v2
389 -- 3 for af_packet_create_v3
390 host_if_name -- host interface name
391 enable_gso -- Enable GSO on the interface when True
393 af_packet_mode = VppEnum.vl_api_af_packet_mode_t
394 af_packet_interface_mode = af_packet_mode.AF_PACKET_API_MODE_ETHERNET
395 af_packet_flags = VppEnum.vl_api_af_packet_flags_t
396 af_packet_interface_flags = af_packet_flags.AF_PACKET_API_FLAG_QDISC_BYPASS
398 af_packet_interface_flags = (
399 af_packet_interface_flags | af_packet_flags.AF_PACKET_API_FLAG_CKSUM_GSO
402 af_packet_interface_flags = (
403 af_packet_interface_flags | af_packet_flags.AF_PACKET_API_FLAG_VERSION_2
406 "use_random_hw_addr": True,
407 "host_if_name": host_if_name,
408 "flags": af_packet_interface_flags,
410 api_args["mode"] = af_packet_interface_mode
411 result = self.vapi.af_packet_create_v3(**api_args)
412 sw_if_index = result.sw_if_index
413 # Enable software GSO chunking when interface doesn't support GSO offload
415 self.vapi.feature_gso_enable_disable(
416 sw_if_index=sw_if_index, enable_disable=1
419 self.vapi.feature_gso_enable_disable(
420 sw_if_index=sw_if_index, enable_disable=0
422 self.vapi.sw_interface_set_flags(sw_if_index=sw_if_index, flags=1)
430 host_ip4_prefix=None,
431 host_ip6_prefix=None,
439 """Create a tapv2 or tunv2 interface in VPP and attach to host.
443 host_namespace -- host namespace to attach the tap/tun interface to
445 host_ip4_prefix -- ipv4 host interface address in CIDR notation
447 host_ip6_prefix -- ipv6 host interface address in CIDR notation
449 host_ip4_gw -- host IPv4 default gateway IP Address
450 host_ip6_gw -- host IPv6 default gateway IP address
451 int_type -- "tap" for tapv2 & "tun" for tunv2 interface
452 host_if_name -- host side interface name
453 enable_gso -- enable GSO
454 enable_gro -- enable GSO/GRO-Coalesce
456 TapFlags = VppEnum.vl_api_tap_flags_t
458 if int_type == "tun":
459 tap_flags = TapFlags.TAP_API_FLAG_TUN
461 tap_flags = tap_flags | (
462 TapFlags.TAP_API_FLAG_GSO | TapFlags.TAP_API_FLAG_GRO_COALESCE
465 tap_flags = tap_flags | TapFlags.TAP_API_FLAG_GSO
466 elif int_type == "tap":
469 TapFlags.TAP_API_FLAG_GSO | TapFlags.TAP_API_FLAG_GRO_COALESCE
472 tap_flags = TapFlags.TAP_API_FLAG_GSO
476 "host_namespace_set": True,
477 "host_namespace": host_namespace,
478 "host_if_name_set": False,
479 "host_bridge_set": False,
480 "host_mac_addr_set": False,
483 api_args["tap_flags"] = tap_flags
485 api_args["host_ip4_prefix"] = ip_interface(host_ip4_prefix)
486 api_args["host_ip4_prefix_set"] = True
488 api_args["host_ip4_gw"] = ip_address(host_ip4_gw)
489 api_args["host_ip4_gw_set"] = True
491 api_args["host_ip6_prefix"] = ip_interface(host_ip6_prefix)
492 api_args["host_ip6_prefix_set"] = True
494 api_args["host_ip6_gw"] = ip_address(host_ip6_gw)
495 api_args["host_ip6_gw_set"] = True
497 api_args["host_if_name"] = host_if_name
498 api_args["host_if_name_set"] = True
500 result = self.vapi.tap_create_v2(**api_args)
501 sw_if_index = result.sw_if_index
502 # Enable software GSO chunking when interface doesn't support GSO offload and
504 if enable_gso == 0 and enable_gro == 0:
505 self.vapi.feature_gso_enable_disable(
506 sw_if_index=sw_if_index, enable_disable=1
509 self.vapi.feature_gso_enable_disable(
510 sw_if_index=sw_if_index, enable_disable=0
513 self.vapi.sw_interface_set_flags(sw_if_index=sw_if_index, flags=1)
516 def dump_bridge_domain_details(self, bd_id):
517 return self.vapi.bridge_domain_dump(bd_id=bd_id)
519 def l2_connect_interfaces(self, bridge_id, *sw_if_idxs):
520 for if_idx in sw_if_idxs:
521 self.vapi.sw_interface_set_l2_bridge(
522 rx_sw_if_index=if_idx, bd_id=bridge_id, shg=0, port_type=0, enable=True
525 def l3_connect_interfaces(self, ip_version, vrf_id, *if_idx_ip_prefixes):
526 """Setup routing for (if_idx, ip_prefix) inside VPP.
529 if_idx_ip_prefixes -- sequence of (if_idx, ip_prefix) tuples
533 is_ipv6 = 0 if ip_version == 4 else 1
534 self.vapi.ip_table_add_del(
535 is_add=1, table={"table_id": vrf_id, "is_ip6": is_ipv6}
537 for sw_if_index, ip_prefix in if_idx_ip_prefixes:
538 self.vapi.sw_interface_set_table(
539 sw_if_index=sw_if_index, is_ipv6=is_ipv6, vrf_id=vrf_id
541 self.vapi.sw_interface_add_del_address(
542 sw_if_index=sw_if_index, is_add=1, prefix=ip_interface(ip_prefix)
545 def set_interfaces_mtu(self, mtu, ip_version, **kwargs):
546 """Set MTUs on VPP and Linux interfaces.
551 kwargs['vpp_interfaces'] -- list of vpp interface if indexes
552 kwargs['linux_interfaces'] -- list of tuples (namespace, interface_names)
553 return True if mtu is set, else False
555 vpp_interfaces = kwargs.get("vpp_interfaces")
556 linux_interfaces = kwargs.get("linux_interfaces")
557 # IPv6 on Linux requires an MTU value >=1280
558 if (ip_version == 6 and mtu >= 1280) or ip_version == 4:
559 for sw_if_idx in vpp_interfaces:
560 self.vapi.sw_interface_set_mtu(
561 sw_if_index=sw_if_idx, mtu=[mtu, 0, 0, 0]
563 for namespace, interface_name in linux_interfaces:
566 interface=interface_name,
575 generate_vpp_interface_tests()
577 if __name__ == "__main__":
578 unittest.main(testRunner=VppTestRunner)