3 from ipaddress import ip_address, ip_interface
4 from vpp_qemu_utils import (
8 delete_host_interfaces,
10 disable_interface_gso,
14 from vpp_iperf import start_iperf, stop_iperf
15 from framework import VppTestCase
16 from asfframework import VppTestRunner, tag_fixme_debian11, is_distro_debian11
17 from config import config
18 from vpp_papi import VppEnum
21 from vm_test_config import test_config
25 # - tapv2, tunv2, af_packet_v2/v3 & memif interfaces.
26 # - reads test config from the file vm_test_config.py
27 # - Uses iPerf to send TCP/IP streams to VPP
28 # - VPP ingress interface runs the iperf client
29 # - VPP egress interface runs the iperf server
30 # - Runs tests specified in the vm_test_config module and verifies that:
31 # - TCP over IPv4 and IPv6 is enabled correctly for Bridged and Routed topologies.
32 # sending jumbo frames (9000/9001 MTUs) with GSO/GRO is enabled correctly.
33 # sending VPP buffer-sized frames(2048 MTU) with GSO/GRO is enabled correctly.
34 # sending standard frames (1500 MTU) with GSO/GRO is enabled correctly.
35 # sending smaller frames (512 MTU) with GSO/GRO is enabled correctly for IPv4
36 # sending odd sized frames (9001, 2049 MTU) with GSO/GRO is enabled correctly.
41 """Selects specified test(s) from vm_test_config to run
43 The selected_test field specifies a comma separated or range(s) of
44 tests to run (default='' i.e all_tests) e.g. setting the selected_tests
45 attribute to "1,3-4,19-23" runs tests with ID's 1, 3, 4, 19, 20, 21,
46 22 & 23 from the spec file vm_test_config
49 def __init__(self, selected_tests="") -> None:
50 self.selected_tests = selected_tests
52 def filter_tests(self, test):
53 """Works with the filter fn. to include only selected tests."""
55 if self.selected_tests:
56 selection = self.selected_tests
58 selection = test_config["tests_to_run"]
60 if not selection or selection == " ":
64 for test_id in selection.split(","):
65 if "-" in test_id.strip():
66 start, end = map(int, test_id.split("-"))
67 test_ids_to_run.extend(list(range(start, end + 1)))
69 test_ids_to_run.append(int(test_id))
70 return test["id"] in test_ids_to_run
73 # Test Config variables
74 af_packet_config = test_config["af_packet"]
75 layer2 = test_config["L2"]
76 layer3 = test_config["L3"]
79 def create_test(test_name, test, ip_version, mtu):
80 """Create and return a unittest method for a test."""
83 is_distro_debian11, "FIXME intermittent test failures on debian11 distro"
86 config.skip_netns_tests, "netns not available or disabled from cli"
89 self.logger.debug(f"Starting unittest:{test_name}")
90 self.setUpTestToplogy(test=test, ip_version=ip_version)
91 result = self.set_interfaces_mtu(
93 ip_version=ip_version,
94 vpp_interfaces=self.vpp_interfaces,
95 linux_interfaces=self.linux_interfaces,
97 if "memif" in self.if_types:
98 self.logger.debug("Starting libmemif test_app for memif test")
99 self.memif_process = libmemif_test_app(
100 memif_sock_path=self.get_memif_sock_path(), logger=self.logger
103 # Start an instance of an iperf server using
104 # a unique port. Save the iperf cmdline for
105 # terminating the iperf_server process after the test.
106 self.iperf_cmd = start_iperf(
108 client_ns=self.client_namespace,
109 server_ns=self.server_namespace,
111 server_args=f"-p {self.iperf_port}",
114 # Send traffic between iperf client & server
117 ip_version=ip_version,
118 client_ns=self.client_namespace,
119 server_ns=self.server_namespace,
120 server_ipv4_address=self.server_ip4_address,
121 server_ipv6_address=self.server_ip6_address,
122 client_args=f"-p {self.iperf_port}",
130 f"Skipping test:{test_name} as mtu:{mtu} is "
131 f"invalid for TCP/IPv{ip_version}"
134 test_func.__name__ = test_name
138 def generate_vpp_interface_tests(tests, test_class):
139 """Generate unittests for testing vpp interfaces
141 Generates unittests from test spec. and sets them as attributes
144 tests : list of test specs from vm_test_config['tests']
145 test_class : the name of the test class to which the
146 generated tests are set as attributes.
149 if config.skip_netns_tests:
150 print("Skipping netns tests")
152 for ip_version in test_config["ip_versions"]:
153 for mtu in test_config["mtus"]:
155 f"test_id_{test['id']}_"
156 + f"client_{test['client_if_type']}"
157 + f"_v{test['client_if_version']}_"
158 + f"gso_{test.get('client_if_gso', 0)}_"
159 + f"gro_{test.get('client_if_gro', 0)}_"
160 + f"checksum_{test.get('client_if_checksum_offload', 0)}_"
161 + f"to_server_{test['server_if_type']}"
162 + f"_v{test['server_if_version']}_"
163 + f"gso_{test.get('server_if_gso', 0)}_"
164 + f"gro_{test.get('server_if_gro', 0)}_"
165 + f"checksum_{test.get('server_if_checksum_offload', 0)}_"
166 + f"mtu_{mtu}_mode_{test['x_connect_mode']}_"
167 + f"tcp_ipv{ip_version}"
169 test_func = create_test(
170 test_name=test_name, test=test, ip_version=ip_version, mtu=mtu
172 setattr(test_class, test_name, test_func)
176 class TestVPPInterfacesQemu:
177 """Test VPP interfaces inside a QEMU VM for IPv4/v6.
180 Linux_ns1--iperfClient--host-int1--vpp-af_packet-int1--VPP-BD
181 --vppaf_packet_int2--host-int2--iperfServer--Linux_ns2
184 def setUpTestToplogy(self, test, ip_version):
185 """Setup the test topology.
187 1. Create Linux Namespaces for iPerf Client & Server.
188 2. Create VPP iPerf client and server virtual interfaces.
189 3. Enable desired vif features such as GSO & GRO.
190 3. Cross-Connect interfaces in VPP using L2 or L3.
193 # Need to support multiple interface types as the memif interface
194 # in VPP is connected to the iPerf client & server by x-connecting
195 # to a tap interface in their respective namespaces.
196 client_if_types = test["client_if_type"].split(",")
197 server_if_types = test["server_if_type"].split(",")
198 client_if_version = test["client_if_version"]
199 server_if_version = test["server_if_version"]
200 x_connect_mode = test["x_connect_mode"]
201 # server ip4/ip6 addresses required by iperf client
202 server_ip4_prefix = (
203 layer2["server_ip4_prefix"]
204 if x_connect_mode == "L2"
205 else layer3["server_ip4_prefix"]
207 server_ip6_prefix = (
208 layer2["server_ip6_prefix"]
209 if x_connect_mode == "L2"
210 else layer3["server_ip6_prefix"]
212 self.server_ip4_address = str(ip_interface(server_ip4_prefix).ip)
213 self.server_ip6_address = str(ip_interface(server_ip6_prefix).ip)
214 # next-hop IP address on VPP for routing from client & server namespaces
215 vpp_client_prefix = (
216 layer3["vpp_client_ip4_prefix"]
218 else layer3["vpp_client_ip6_prefix"]
220 vpp_client_nexthop = str(ip_interface(vpp_client_prefix).ip)
221 vpp_server_prefix = (
222 layer3["vpp_server_ip4_prefix"]
224 else layer3["vpp_server_ip6_prefix"]
226 vpp_server_nexthop = str(ip_interface(vpp_server_prefix).ip)
227 # Create unique namespaces for iperf client & iperf server to
228 # prevent conflicts when TEST_JOBS > 1
229 self.client_namespace = test_config["client_namespace"] + str(test["id"])
230 self.server_namespace = test_config["server_namespace"] + str(test["id"])
231 create_namespace([self.client_namespace, self.server_namespace])
232 # Set a unique iPerf port for parallel server and client runs
233 self.iperf_port = 5000 + test["id"]
234 # IPerf client & server ingress/egress interface indexes in VPP
235 self.tap_interfaces = []
236 self.memif_interfaces = []
237 self.ingress_if_idxes = []
238 self.egress_if_idxes = []
239 self.vpp_interfaces = []
240 self.linux_interfaces = []
241 enable_client_if_gso = test.get("client_if_gso", 0)
242 enable_server_if_gso = test.get("server_if_gso", 0)
243 enable_client_if_gro = test.get("client_if_gro", 0)
244 enable_server_if_gro = test.get("server_if_gro", 0)
245 enable_client_if_checksum_offload = test.get("client_if_checksum_offload", 0)
246 enable_server_if_checksum_offload = test.get("server_if_checksum_offload", 0)
248 # Create unique host interfaces in Linux and VPP for connecting to iperf
249 # client & iperf server to prevent conflicts when TEST_JOBS > 1
250 self.iprf_client_host_interface_on_linux = af_packet_config[
251 "iprf_client_interface_on_linux"
253 self.iprf_client_host_interface_on_vpp = af_packet_config[
254 "iprf_client_interface_on_vpp"
256 self.iprf_server_host_interface_on_linux = af_packet_config[
257 "iprf_server_interface_on_linux"
259 self.iprf_server_host_interface_on_vpp = af_packet_config[
260 "iprf_server_interface_on_vpp"
262 # Handle client interface types
263 for client_if_type in client_if_types:
264 if client_if_type == "af_packet":
265 create_host_interface(
266 self.iprf_client_host_interface_on_linux,
267 self.iprf_client_host_interface_on_vpp,
268 self.client_namespace,
269 layer2["client_ip4_prefix"]
270 if x_connect_mode == "L2"
271 else layer3["client_ip4_prefix"],
272 layer2["client_ip6_prefix"]
273 if x_connect_mode == "L2"
274 else layer3["client_ip6_prefix"],
276 self.ingress_if_idx = self.create_af_packet(
277 version=client_if_version,
278 host_if_name=self.iprf_client_host_interface_on_vpp,
279 enable_gso=enable_client_if_gso,
281 self.ingress_if_idxes.append(self.ingress_if_idx)
282 self.vpp_interfaces.append(self.ingress_if_idx)
283 self.linux_interfaces.append(
284 ["", self.iprf_client_host_interface_on_vpp]
286 self.linux_interfaces.append(
288 self.client_namespace,
289 self.iprf_client_host_interface_on_linux,
292 if enable_client_if_gso == 0:
293 disable_interface_gso("", self.iprf_client_host_interface_on_vpp)
294 disable_interface_gso(
295 self.client_namespace,
296 self.iprf_client_host_interface_on_linux,
298 elif client_if_type == "tap" or client_if_type == "tun":
299 self.ingress_if_idx = self.create_tap_tun(
301 host_namespace=self.client_namespace,
302 ip_version=ip_version,
303 host_ip4_prefix=layer2["client_ip4_prefix"]
304 if x_connect_mode == "L2"
305 else layer3["client_ip4_prefix"],
306 host_ip6_prefix=layer2["client_ip6_prefix"]
307 if x_connect_mode == "L2"
308 else layer3["client_ip6_prefix"],
309 host_ip4_gw=vpp_client_nexthop
310 if x_connect_mode == "L3" and ip_version == 4
312 host_ip6_gw=vpp_client_nexthop
313 if x_connect_mode == "L3" and ip_version == 6
315 int_type=client_if_type,
316 host_if_name=f"{client_if_type}0",
317 enable_gso=enable_client_if_gso,
318 enable_gro=enable_client_if_gro,
319 enable_checksum_offload=enable_client_if_checksum_offload,
321 self.tap_interfaces.append(self.ingress_if_idx)
322 self.ingress_if_idxes.append(self.ingress_if_idx)
323 self.vpp_interfaces.append(self.ingress_if_idx)
324 self.linux_interfaces.append(
325 [self.client_namespace, f"{client_if_type}0"]
327 # Seeing TCP timeouts if tx=on & rx=on Linux tap & tun interfaces
328 disable_interface_gso(self.client_namespace, f"{client_if_type}0")
329 elif client_if_type == "memif":
330 self.ingress_if_idx = self.create_memif(
331 memif_id=0, mode=0 if x_connect_mode == "L2" else 1
333 self.memif_interfaces.append(self.ingress_if_idx)
334 self.ingress_if_idxes.append(self.ingress_if_idx)
335 self.vpp_interfaces.append(self.ingress_if_idx)
338 f"Unsupported client interface type: {client_if_type} "
339 f"for test - ID={test['id']}"
342 for server_if_type in server_if_types:
343 if server_if_type == "af_packet":
344 create_host_interface(
345 self.iprf_server_host_interface_on_linux,
346 self.iprf_server_host_interface_on_vpp,
347 self.server_namespace,
351 self.egress_if_idx = self.create_af_packet(
352 version=server_if_version,
353 host_if_name=self.iprf_server_host_interface_on_vpp,
354 enable_gso=enable_server_if_gso,
356 self.egress_if_idxes.append(self.egress_if_idx)
357 self.vpp_interfaces.append(self.egress_if_idx)
358 self.linux_interfaces.append(
359 ["", self.iprf_server_host_interface_on_vpp]
361 self.linux_interfaces.append(
363 self.server_namespace,
364 self.iprf_server_host_interface_on_linux,
367 if enable_server_if_gso == 0:
368 disable_interface_gso("", self.iprf_server_host_interface_on_vpp)
369 disable_interface_gso(
370 self.server_namespace,
371 self.iprf_server_host_interface_on_linux,
373 elif server_if_type == "tap" or server_if_type == "tun":
374 self.egress_if_idx = self.create_tap_tun(
376 host_namespace=self.server_namespace,
377 ip_version=ip_version,
378 host_ip4_prefix=layer2["server_ip4_prefix"]
379 if x_connect_mode == "L2"
380 else layer3["server_ip4_prefix"],
381 host_ip6_prefix=layer2["server_ip6_prefix"]
382 if x_connect_mode == "L2"
383 else layer3["server_ip6_prefix"],
384 int_type=server_if_type,
385 host_if_name=f"{server_if_type}0",
386 enable_gso=enable_server_if_gso,
387 enable_gro=enable_server_if_gro,
388 enable_checksum_offload=enable_server_if_checksum_offload,
390 self.tap_interfaces.append(self.egress_if_idx)
391 self.egress_if_idxes.append(self.egress_if_idx)
392 self.vpp_interfaces.append(self.egress_if_idx)
393 self.linux_interfaces.append(
394 [self.server_namespace, f"{server_if_type}0"]
396 # Seeing TCP timeouts if tx=on & rx=on Linux tap & tun interfaces
397 disable_interface_gso(self.server_namespace, f"{server_if_type}0")
398 elif server_if_type == "memif":
399 self.egress_if_idx = self.create_memif(
400 memif_id=1, mode=0 if x_connect_mode == "L2" else 1
402 self.memif_interfaces.append(self.egress_if_idx)
403 self.egress_if_idxes.append(self.egress_if_idx)
404 self.vpp_interfaces.append(self.egress_if_idx)
407 f"Unsupported server interface type: {server_if_type} "
408 f"for test - ID={test['id']}"
411 self.if_types = set(client_if_types).union(set(server_if_types))
412 # for memif testing: tapv2, memif & libmemif_app are connected
413 if "memif" not in self.if_types:
414 if x_connect_mode == "L2":
415 self.l2_connect_interfaces(1, self.ingress_if_idx, self.egress_if_idx)
416 elif x_connect_mode == "L3":
417 # L3 connect client & server side
418 vrf_id = layer3["ip4_vrf"] if ip_version == 4 else layer3["ip6_vrf"]
419 self.l3_connect_interfaces(
422 (self.ingress_if_idx, vpp_client_prefix),
423 (self.egress_if_idx, vpp_server_prefix),
425 # Setup namespace routing
428 self.client_namespace, "0.0.0.0/0", vpp_client_nexthop
431 self.server_namespace, "0.0.0.0/0", vpp_server_nexthop
435 self.client_namespace, "::/0", vpp_client_nexthop
438 self.server_namespace, "::/0", vpp_server_nexthop
441 # connect: ingress tap & memif & egress tap and memif interfaces
442 if x_connect_mode == "L2":
443 self.l2_connect_interfaces(1, *self.ingress_if_idxes)
444 self.l2_connect_interfaces(2, *self.egress_if_idxes)
445 # Wait for Linux IPv6 stack to become ready
451 for interface_if_idx in self.tap_interfaces:
452 self.vapi.tap_delete_v2(sw_if_index=interface_if_idx)
456 for interface_if_idx in self.memif_interfaces:
457 self.vapi.memif_delete(sw_if_index=interface_if_idx)
461 for interface in self.vapi.af_packet_dump():
462 if interface.host_if_name == self.iprf_client_host_interface_on_vpp:
463 self.vapi.af_packet_delete(self.iprf_client_host_interface_on_vpp)
464 elif interface.host_if_name == self.iprf_server_host_interface_on_vpp:
465 self.vapi.af_packet_delete(self.iprf_server_host_interface_on_vpp)
469 delete_host_interfaces(
470 self.iprf_client_host_interface_on_linux,
471 self.iprf_server_host_interface_on_linux,
472 self.iprf_client_host_interface_on_vpp,
473 self.iprf_server_host_interface_on_vpp,
478 self.vapi.ip_table_add_del(is_add=0, table={"table_id": layer3["ip4_vrf"]})
482 self.vapi.ip_table_add_del(is_add=0, table={"table_id": layer3["ip6_vrf"]})
486 self.vapi.bridge_domain_add_del_v2(bd_id=1, is_add=0)
487 self.vapi.bridge_domain_add_del_v2(bd_id=2, is_add=0)
493 self.client_namespace,
494 self.server_namespace,
500 if hasattr(self, "iperf_cmd"):
501 stop_iperf(" ".join(self.iperf_cmd))
505 if self.memif_process:
506 self.memif_process.terminate()
507 self.memif_process.join()
511 def create_af_packet(self, version, host_if_name, enable_gso=0):
512 """Create an af_packetv3 interface in VPP.
515 version -- 2 for af_packet_create_v2
516 -- 3 for af_packet_create_v3
517 host_if_name -- host interface name
518 enable_gso -- Enable GSO on the interface when True
520 af_packet_mode = VppEnum.vl_api_af_packet_mode_t
521 af_packet_interface_mode = af_packet_mode.AF_PACKET_API_MODE_ETHERNET
522 af_packet_flags = VppEnum.vl_api_af_packet_flags_t
523 af_packet_interface_flags = af_packet_flags.AF_PACKET_API_FLAG_QDISC_BYPASS
525 af_packet_interface_flags = (
526 af_packet_interface_flags | af_packet_flags.AF_PACKET_API_FLAG_CKSUM_GSO
529 af_packet_interface_flags = (
530 af_packet_interface_flags | af_packet_flags.AF_PACKET_API_FLAG_VERSION_2
533 "use_random_hw_addr": True,
534 "host_if_name": host_if_name,
535 "flags": af_packet_interface_flags,
537 api_args["mode"] = af_packet_interface_mode
538 result = self.vapi.af_packet_create_v3(**api_args)
539 sw_if_index = result.sw_if_index
540 # Enable software GSO chunking when interface doesn't support GSO offload
542 self.vapi.feature_gso_enable_disable(
543 sw_if_index=sw_if_index, enable_disable=1
546 self.vapi.feature_gso_enable_disable(
547 sw_if_index=sw_if_index, enable_disable=0
549 self.vapi.sw_interface_set_flags(sw_if_index=sw_if_index, flags=1)
557 host_ip4_prefix=None,
558 host_ip6_prefix=None,
565 enable_checksum_offload=0,
567 """Create a tapv2 or tunv2 interface in VPP and attach to host.
571 host_namespace -- host namespace to attach the tap/tun interface to
573 host_ip4_prefix -- ipv4 host interface address in CIDR notation
575 host_ip6_prefix -- ipv6 host interface address in CIDR notation
577 host_ip4_gw -- host IPv4 default gateway IP Address
578 host_ip6_gw -- host IPv6 default gateway IP address
579 int_type -- "tap" for tapv2 & "tun" for tunv2 interface
580 host_if_name -- host side interface name
581 enable_gso -- enable GSO
582 enable_gro -- enable GSO/GRO-Coalesce
583 enable_checksum_offload -- enable checksum offload without gso
585 TapFlags = VppEnum.vl_api_tap_flags_t
587 if int_type == "tun":
588 tap_flags = TapFlags.TAP_API_FLAG_TUN
590 tap_flags = tap_flags | (
591 TapFlags.TAP_API_FLAG_GSO | TapFlags.TAP_API_FLAG_GRO_COALESCE
594 tap_flags = tap_flags | TapFlags.TAP_API_FLAG_GSO
595 elif enable_checksum_offload:
596 tap_flags = tap_flags | TapFlags.TAP_API_FLAG_CSUM_OFFLOAD
597 elif int_type == "tap":
600 TapFlags.TAP_API_FLAG_GSO | TapFlags.TAP_API_FLAG_GRO_COALESCE
603 tap_flags = TapFlags.TAP_API_FLAG_GSO
604 elif enable_checksum_offload:
605 tap_flags = tap_flags | TapFlags.TAP_API_FLAG_CSUM_OFFLOAD
609 "host_namespace_set": True,
610 "host_namespace": host_namespace,
611 "host_if_name_set": False,
612 "host_bridge_set": False,
613 "host_mac_addr_set": False,
616 api_args["tap_flags"] = tap_flags
618 api_args["host_ip4_prefix"] = ip_interface(host_ip4_prefix)
619 api_args["host_ip4_prefix_set"] = True
621 api_args["host_ip4_gw"] = ip_address(host_ip4_gw)
622 api_args["host_ip4_gw_set"] = True
624 api_args["host_ip6_prefix"] = ip_interface(host_ip6_prefix)
625 api_args["host_ip6_prefix_set"] = True
627 api_args["host_ip6_gw"] = ip_address(host_ip6_gw)
628 api_args["host_ip6_gw_set"] = True
630 api_args["host_if_name"] = host_if_name
631 api_args["host_if_name_set"] = True
633 result = self.vapi.tap_create_v2(**api_args)
634 sw_if_index = result.sw_if_index
635 # Enable software GSO chunking when interface doesn't support GSO offload and
637 if enable_gso == 0 and enable_gro == 0:
638 self.vapi.feature_gso_enable_disable(
639 sw_if_index=sw_if_index, enable_disable=1
642 self.vapi.feature_gso_enable_disable(
643 sw_if_index=sw_if_index, enable_disable=0
646 self.vapi.sw_interface_set_flags(sw_if_index=sw_if_index, flags=1)
649 def create_memif(self, memif_id, mode):
650 """Create memif interface in VPP.
653 memif_id: A unique ID for the memif interface
654 mode: 0 = ethernet, 1 = ip, 2 = punt/inject
656 # create memif interface with role=0 (i.e. master)
657 result = self.vapi.memif_create_v2(
658 role=0, mode=mode, id=memif_id, buffer_size=9216
660 sw_if_index = result.sw_if_index
661 self.vapi.sw_interface_set_flags(sw_if_index=sw_if_index, flags=1)
664 def dump_bridge_domain_details(self, bd_id):
665 return self.vapi.bridge_domain_dump(bd_id=bd_id)
667 def l2_connect_interfaces(self, bridge_id, *sw_if_idxs):
668 for if_idx in sw_if_idxs:
669 self.vapi.sw_interface_set_l2_bridge(
670 rx_sw_if_index=if_idx, bd_id=bridge_id, shg=0, port_type=0, enable=True
673 def l3_connect_interfaces(self, ip_version, vrf_id, *if_idx_ip_prefixes):
674 """Setup routing for (if_idx, ip_prefix) inside VPP.
677 if_idx_ip_prefixes -- sequence of (if_idx, ip_prefix) tuples
681 is_ipv6 = 0 if ip_version == 4 else 1
682 self.vapi.ip_table_add_del(
683 is_add=1, table={"table_id": vrf_id, "is_ip6": is_ipv6}
685 for sw_if_index, ip_prefix in if_idx_ip_prefixes:
686 self.vapi.sw_interface_set_table(
687 sw_if_index=sw_if_index, is_ipv6=is_ipv6, vrf_id=vrf_id
689 self.vapi.sw_interface_add_del_address(
690 sw_if_index=sw_if_index, is_add=1, prefix=ip_interface(ip_prefix)
693 def set_interfaces_mtu(self, mtu, ip_version, **kwargs):
694 """Set MTUs on VPP and Linux interfaces.
699 kwargs['vpp_interfaces'] -- list of vpp interface if indexes
700 kwargs['linux_interfaces'] -- list of tuples (namespace, interface_names)
701 return True if mtu is set, else False
703 vpp_interfaces = kwargs.get("vpp_interfaces")
704 linux_interfaces = kwargs.get("linux_interfaces")
705 # IPv6 on Linux requires an MTU value >=1280
706 if (ip_version == 6 and mtu >= 1280) or ip_version == 4:
707 for sw_if_idx in vpp_interfaces:
708 self.vapi.sw_interface_set_mtu(
709 sw_if_index=sw_if_idx, mtu=[mtu, 0, 0, 0]
711 for namespace, interface_name in linux_interfaces:
714 interface=interface_name,
723 if __name__ == "__main__":
724 unittest.main(testRunner=VppTestRunner)