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 config.skip_netns_tests, "netns not available or disabled from cli"
70 self.logger.debug(f"Starting unittest:{test_name}")
71 self.setUpTestToplogy(test=test, ip_version=ip_version)
72 result = self.set_interfaces_mtu(
74 ip_version=ip_version,
75 vpp_interfaces=self.vpp_interfaces,
76 linux_interfaces=self.linux_interfaces,
78 # Start the Iperf server in dual stack mode & run iperf client
80 start_iperf(ip_version=6, server_only=True, logger=self.logger)
83 ip_version=ip_version,
84 server_ipv4_address=self.server_ip4_address,
85 server_ipv6_address=self.server_ip6_address,
93 f"Skipping test:{test_name} as mtu:{mtu} is "
94 f"invalid for TCP/IPv{ip_version}"
97 test_func.__name__ = test_name
101 def generate_vpp_interface_tests():
102 """Generate unittests for testing vpp interfaces."""
103 if config.skip_netns_tests:
104 print("Skipping netns tests")
106 for ip_version in test_config["ip_versions"]:
107 for mtu in test_config["mtus"]:
109 f"test_id_{test['id']}_"
110 + f"client_{test['client_if_type']}"
111 + f"_v{test['client_if_version']}_"
112 + f"gso_{test.get('client_if_gso', 0)}_"
113 + f"gro_{test.get('client_if_gro', 0)}_"
114 + f"to_server_{test['server_if_type']}"
115 + f"_v{test['server_if_version']}_"
116 + f"gso_{test.get('server_if_gso', 0)}_"
117 + f"gro_{test.get('server_if_gro', 0)}_"
118 + f"mtu_{mtu}_mode_{test['x_connect_mode']}_"
119 + f"tcp_ipv{ip_version}"
121 test_func = create_test(
122 test_name=test_name, test=test, ip_version=ip_version, mtu=mtu
124 setattr(TestVPPInterfacesQemu, test_name, test_func)
127 class TestVPPInterfacesQemu(VppTestCase):
128 """Test VPP interfaces inside a QEMU VM for IPv4/v6.
131 Linux_ns1--iperfClient--host-int1--vpp-af_packet-int1--VPP-BD
132 --vppaf_packet_int2--host-int2--iperfServer--Linux_ns2
137 super(TestVPPInterfacesQemu, cls).setUpClass()
140 def tearDownClass(cls):
141 super(TestVPPInterfacesQemu, cls).tearDownClass()
143 def setUpTestToplogy(self, test, ip_version):
144 """Setup the test topology.
146 1. Create Linux Namespaces for iPerf Client & Server.
147 2. Create VPP iPerf client and server virtual interfaces.
148 3. Enable desired vif features such as GSO & GRO.
149 3. Cross-Connect interfaces in VPP using L2 or L3.
151 super(TestVPPInterfacesQemu, self).setUp()
152 client_if_type = test["client_if_type"]
153 server_if_type = test["server_if_type"]
154 client_if_version = test["client_if_version"]
155 server_if_version = test["server_if_version"]
156 x_connect_mode = test["x_connect_mode"]
157 # server ip4/ip6 addresses required by iperf client
158 server_ip4_prefix = (
159 layer2["server_ip4_prefix"]
160 if x_connect_mode == "L2"
161 else layer3["server_ip4_prefix"]
163 server_ip6_prefix = (
164 layer2["server_ip6_prefix"]
165 if x_connect_mode == "L2"
166 else layer3["server_ip6_prefix"]
168 self.server_ip4_address = str(ip_interface(server_ip4_prefix).ip)
169 self.server_ip6_address = str(ip_interface(server_ip6_prefix).ip)
170 # next-hop IP address on VPP for routing from client & server namespaces
171 vpp_client_prefix = (
172 layer3["vpp_client_ip4_prefix"]
174 else layer3["vpp_client_ip6_prefix"]
176 vpp_client_nexthop = str(ip_interface(vpp_client_prefix).ip)
177 vpp_server_prefix = (
178 layer3["vpp_server_ip4_prefix"]
180 else layer3["vpp_server_ip6_prefix"]
182 vpp_server_nexthop = str(ip_interface(vpp_server_prefix).ip)
183 create_namespace([client_namespace, server_namespace])
184 self.vpp_interfaces = []
185 self.linux_interfaces = []
186 enable_client_if_gso = test.get("client_if_gso", 0)
187 enable_server_if_gso = test.get("server_if_gso", 0)
188 enable_client_if_gro = test.get("client_if_gro", 0)
189 enable_server_if_gro = test.get("server_if_gro", 0)
190 ## Handle client interface types
191 if client_if_type == "af_packet":
192 create_host_interface(
193 af_packet_config["iprf_client_interface_on_linux"],
194 af_packet_config["iprf_client_interface_on_vpp"],
196 layer2["client_ip4_prefix"]
197 if x_connect_mode == "L2"
198 else layer3["client_ip4_prefix"],
199 layer2["client_ip6_prefix"]
200 if x_connect_mode == "L2"
201 else layer3["client_ip6_prefix"],
203 self.ingress_if_idx = self.create_af_packet(
204 version=client_if_version,
205 host_if_name=af_packet_config["iprf_client_interface_on_vpp"],
206 enable_gso=enable_client_if_gso,
208 self.vpp_interfaces.append(self.ingress_if_idx)
209 self.linux_interfaces.append(
210 ["", af_packet_config["iprf_client_interface_on_vpp"]]
212 self.linux_interfaces.append(
213 [client_namespace, af_packet_config["iprf_client_interface_on_linux"]]
215 if enable_client_if_gso == 0:
216 disable_interface_gso(
217 "", af_packet_config["iprf_client_interface_on_vpp"]
219 disable_interface_gso(
220 client_namespace, af_packet_config["iprf_client_interface_on_linux"]
222 elif client_if_type == "tap" or client_if_type == "tun":
223 self.ingress_if_idx = self.create_tap_tun(
225 host_namespace=client_namespace,
226 ip_version=ip_version,
227 host_ip4_prefix=layer2["client_ip4_prefix"]
228 if x_connect_mode == "L2"
229 else layer3["client_ip4_prefix"],
230 host_ip6_prefix=layer2["client_ip6_prefix"]
231 if x_connect_mode == "L2"
232 else layer3["client_ip6_prefix"],
233 host_ip4_gw=vpp_client_nexthop
234 if x_connect_mode == "L3" and ip_version == 4
236 host_ip6_gw=vpp_client_nexthop
237 if x_connect_mode == "L3" and ip_version == 6
239 int_type=client_if_type,
240 host_if_name=f"{client_if_type}0",
241 enable_gso=enable_client_if_gso,
242 enable_gro=enable_client_if_gro,
244 self.vpp_interfaces.append(self.ingress_if_idx)
245 self.linux_interfaces.append([client_namespace, f"{client_if_type}0"])
246 # Seeing TCP timeouts if tx=on & rx=on Linux tap & tun interfaces
247 disable_interface_gso(client_namespace, f"{client_if_type}0")
250 f"Unsupported client interface type: {client_if_type} "
251 f"for test - ID={test['id']}"
255 if server_if_type == "af_packet":
256 create_host_interface(
257 af_packet_config["iprf_server_interface_on_linux"],
258 af_packet_config["iprf_server_interface_on_vpp"],
263 self.egress_if_idx = self.create_af_packet(
264 version=server_if_version,
265 host_if_name=af_packet_config["iprf_server_interface_on_vpp"],
266 enable_gso=enable_server_if_gso,
268 self.vpp_interfaces.append(self.egress_if_idx)
269 self.linux_interfaces.append(
270 ["", af_packet_config["iprf_server_interface_on_vpp"]]
272 self.linux_interfaces.append(
273 [server_namespace, af_packet_config["iprf_server_interface_on_linux"]]
275 if enable_server_if_gso == 0:
276 disable_interface_gso(
277 "", af_packet_config["iprf_server_interface_on_vpp"]
279 disable_interface_gso(
280 server_namespace, af_packet_config["iprf_server_interface_on_linux"]
282 elif server_if_type == "tap" or server_if_type == "tun":
283 self.egress_if_idx = self.create_tap_tun(
285 host_namespace=server_namespace,
286 ip_version=ip_version,
287 host_ip4_prefix=layer2["server_ip4_prefix"]
288 if x_connect_mode == "L2"
289 else layer3["server_ip4_prefix"],
290 host_ip6_prefix=layer2["server_ip6_prefix"]
291 if x_connect_mode == "L2"
292 else layer3["server_ip6_prefix"],
293 int_type=server_if_type,
294 host_if_name=f"{server_if_type}0",
295 enable_gso=enable_server_if_gso,
296 enable_gro=enable_server_if_gro,
298 self.vpp_interfaces.append(self.egress_if_idx)
299 self.linux_interfaces.append([server_namespace, f"{server_if_type}0"])
300 # Seeing TCP timeouts if tx=on & rx=on Linux tap & tun interfaces
301 disable_interface_gso(server_namespace, f"{server_if_type}0")
304 f"Unsupported server interface type: {server_if_type} "
305 f"for test - ID={test['id']}"
309 if x_connect_mode == "L2":
310 self.l2_connect_interfaces(1, self.ingress_if_idx, self.egress_if_idx)
311 elif x_connect_mode == "L3":
312 # L3 connect client & server side
313 vrf_id = layer3["ip4_vrf"] if ip_version == 4 else layer3["ip6_vrf"]
314 self.l3_connect_interfaces(
317 (self.ingress_if_idx, vpp_client_prefix),
318 (self.egress_if_idx, vpp_server_prefix),
320 # Setup namespace routing
322 add_namespace_route(client_namespace, "0.0.0.0/0", vpp_client_nexthop)
323 add_namespace_route(server_namespace, "0.0.0.0/0", vpp_server_nexthop)
325 add_namespace_route(client_namespace, "::/0", vpp_client_nexthop)
326 add_namespace_route(server_namespace, "::/0", vpp_server_nexthop)
327 # Wait for Linux IPv6 stack to become ready
333 self.vapi.tap_delete_v2(self.ingress_if_idx)
337 self.vapi.tap_delete_v2(self.egress_if_idx)
341 for interface in self.vapi.af_packet_dump():
343 interface.host_if_name
344 == af_packet_config["iprf_client_interface_on_vpp"]
346 self.vapi.af_packet_delete(
347 af_packet_config["iprf_client_interface_on_vpp"]
350 interface.host_if_name
351 == af_packet_config["iprf_server_interface_on_vpp"]
353 self.vapi.af_packet_delete(
354 af_packet_config["iprf_server_interface_on_vpp"]
359 delete_host_interfaces(
360 af_packet_config["iprf_client_interface_on_linux"],
361 af_packet_config["iprf_server_interface_on_linux"],
362 af_packet_config["iprf_client_interface_on_vpp"],
363 af_packet_config["iprf_server_interface_on_vpp"],
368 self.vapi.ip_table_add_del(is_add=0, table={"table_id": layer3["ip4_vrf"]})
372 self.vapi.ip_table_add_del(is_add=0, table={"table_id": layer3["ip6_vrf"]})
389 def create_af_packet(self, version, host_if_name, enable_gso=0):
390 """Create an af_packetv3 interface in VPP.
393 version -- 2 for af_packet_create_v2
394 -- 3 for af_packet_create_v3
395 host_if_name -- host interface name
396 enable_gso -- Enable GSO on the interface when True
398 af_packet_mode = VppEnum.vl_api_af_packet_mode_t
399 af_packet_interface_mode = af_packet_mode.AF_PACKET_API_MODE_ETHERNET
400 af_packet_flags = VppEnum.vl_api_af_packet_flags_t
401 af_packet_interface_flags = af_packet_flags.AF_PACKET_API_FLAG_QDISC_BYPASS
403 af_packet_interface_flags = (
404 af_packet_interface_flags | af_packet_flags.AF_PACKET_API_FLAG_CKSUM_GSO
407 af_packet_interface_flags = (
408 af_packet_interface_flags | af_packet_flags.AF_PACKET_API_FLAG_VERSION_2
411 "use_random_hw_addr": True,
412 "host_if_name": host_if_name,
413 "flags": af_packet_interface_flags,
415 api_args["mode"] = af_packet_interface_mode
416 result = self.vapi.af_packet_create_v3(**api_args)
417 sw_if_index = result.sw_if_index
418 # Enable software GSO chunking when interface doesn't support GSO offload
420 self.vapi.feature_gso_enable_disable(
421 sw_if_index=sw_if_index, enable_disable=1
424 self.vapi.feature_gso_enable_disable(
425 sw_if_index=sw_if_index, enable_disable=0
427 self.vapi.sw_interface_set_flags(sw_if_index=sw_if_index, flags=1)
435 host_ip4_prefix=None,
436 host_ip6_prefix=None,
444 """Create a tapv2 or tunv2 interface in VPP and attach to host.
448 host_namespace -- host namespace to attach the tap/tun interface to
450 host_ip4_prefix -- ipv4 host interface address in CIDR notation
452 host_ip6_prefix -- ipv6 host interface address in CIDR notation
454 host_ip4_gw -- host IPv4 default gateway IP Address
455 host_ip6_gw -- host IPv6 default gateway IP address
456 int_type -- "tap" for tapv2 & "tun" for tunv2 interface
457 host_if_name -- host side interface name
458 enable_gso -- enable GSO
459 enable_gro -- enable GSO/GRO-Coalesce
461 TapFlags = VppEnum.vl_api_tap_flags_t
463 if int_type == "tun":
464 tap_flags = TapFlags.TAP_API_FLAG_TUN
466 tap_flags = tap_flags | (
467 TapFlags.TAP_API_FLAG_GSO | TapFlags.TAP_API_FLAG_GRO_COALESCE
470 tap_flags = tap_flags | TapFlags.TAP_API_FLAG_GSO
471 elif int_type == "tap":
474 TapFlags.TAP_API_FLAG_GSO | TapFlags.TAP_API_FLAG_GRO_COALESCE
477 tap_flags = TapFlags.TAP_API_FLAG_GSO
481 "host_namespace_set": True,
482 "host_namespace": host_namespace,
483 "host_if_name_set": False,
484 "host_bridge_set": False,
485 "host_mac_addr_set": False,
488 api_args["tap_flags"] = tap_flags
490 api_args["host_ip4_prefix"] = ip_interface(host_ip4_prefix)
491 api_args["host_ip4_prefix_set"] = True
493 api_args["host_ip4_gw"] = ip_address(host_ip4_gw)
494 api_args["host_ip4_gw_set"] = True
496 api_args["host_ip6_prefix"] = ip_interface(host_ip6_prefix)
497 api_args["host_ip6_prefix_set"] = True
499 api_args["host_ip6_gw"] = ip_address(host_ip6_gw)
500 api_args["host_ip6_gw_set"] = True
502 api_args["host_if_name"] = host_if_name
503 api_args["host_if_name_set"] = True
505 result = self.vapi.tap_create_v2(**api_args)
506 sw_if_index = result.sw_if_index
507 # Enable software GSO chunking when interface doesn't support GSO offload and
509 if enable_gso == 0 and enable_gro == 0:
510 self.vapi.feature_gso_enable_disable(
511 sw_if_index=sw_if_index, enable_disable=1
514 self.vapi.feature_gso_enable_disable(
515 sw_if_index=sw_if_index, enable_disable=0
518 self.vapi.sw_interface_set_flags(sw_if_index=sw_if_index, flags=1)
521 def dump_bridge_domain_details(self, bd_id):
522 return self.vapi.bridge_domain_dump(bd_id=bd_id)
524 def l2_connect_interfaces(self, bridge_id, *sw_if_idxs):
525 for if_idx in sw_if_idxs:
526 self.vapi.sw_interface_set_l2_bridge(
527 rx_sw_if_index=if_idx, bd_id=bridge_id, shg=0, port_type=0, enable=True
530 def l3_connect_interfaces(self, ip_version, vrf_id, *if_idx_ip_prefixes):
531 """Setup routing for (if_idx, ip_prefix) inside VPP.
534 if_idx_ip_prefixes -- sequence of (if_idx, ip_prefix) tuples
538 is_ipv6 = 0 if ip_version == 4 else 1
539 self.vapi.ip_table_add_del(
540 is_add=1, table={"table_id": vrf_id, "is_ip6": is_ipv6}
542 for sw_if_index, ip_prefix in if_idx_ip_prefixes:
543 self.vapi.sw_interface_set_table(
544 sw_if_index=sw_if_index, is_ipv6=is_ipv6, vrf_id=vrf_id
546 self.vapi.sw_interface_add_del_address(
547 sw_if_index=sw_if_index, is_add=1, prefix=ip_interface(ip_prefix)
550 def set_interfaces_mtu(self, mtu, ip_version, **kwargs):
551 """Set MTUs on VPP and Linux interfaces.
556 kwargs['vpp_interfaces'] -- list of vpp interface if indexes
557 kwargs['linux_interfaces'] -- list of tuples (namespace, interface_names)
558 return True if mtu is set, else False
560 vpp_interfaces = kwargs.get("vpp_interfaces")
561 linux_interfaces = kwargs.get("linux_interfaces")
562 # IPv6 on Linux requires an MTU value >=1280
563 if (ip_version == 6 and mtu >= 1280) or ip_version == 4:
564 for sw_if_idx in vpp_interfaces:
565 self.vapi.sw_interface_set_mtu(
566 sw_if_index=sw_if_idx, mtu=[mtu, 0, 0, 0]
568 for namespace, interface_name in linux_interfaces:
571 interface=interface_name,
580 generate_vpp_interface_tests()
582 if __name__ == "__main__":
583 unittest.main(testRunner=VppTestRunner)