1 # Copyright (c) 2024 Cisco and/or its affiliates.
2 # Licensed under the Apache License, Version 2.0 (the "License");
3 # you may not use this file except in compliance with the License.
4 # You may obtain a copy of the License at:
6 # http://www.apache.org/licenses/LICENSE-2.0
8 # Unless required by applicable law or agreed to in writing, software
9 # distributed under the License is distributed on an "AS IS" BASIS,
10 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
11 # See the License for the specific language governing permissions and
12 # limitations under the License.
14 """Interface util library."""
16 from json import loads
17 from time import sleep
18 from enum import IntEnum
20 from ipaddress import ip_address
21 from robot.api import logger
22 from robot.libraries.BuiltIn import BuiltIn
24 from resources.libraries.python.Constants import Constants
25 from resources.libraries.python.DUTSetup import DUTSetup
26 from resources.libraries.python.IPAddress import IPAddress
27 from resources.libraries.python.L2Util import L2Util
28 from resources.libraries.python.PapiExecutor import PapiSocketExecutor
29 from resources.libraries.python.ssh import SSH, exec_cmd, exec_cmd_no_error
30 from resources.libraries.python.topology import NodeType, Topology
31 from resources.libraries.python.VPPUtil import VPPUtil
34 class InterfaceStatusFlags(IntEnum):
35 """Interface status flags."""
36 IF_STATUS_API_FLAG_ADMIN_UP = 1
37 IF_STATUS_API_FLAG_LINK_UP = 2
40 class MtuProto(IntEnum):
45 MTU_PROTO_API_MPLS = 3
49 class LinkDuplex(IntEnum):
51 LINK_DUPLEX_API_UNKNOWN = 0
52 LINK_DUPLEX_API_HALF = 1
53 LINK_DUPLEX_API_FULL = 2
56 class SubInterfaceFlags(IntEnum):
57 """Sub-interface flags."""
58 SUB_IF_API_FLAG_NO_TAGS = 1
59 SUB_IF_API_FLAG_ONE_TAG = 2
60 SUB_IF_API_FLAG_TWO_TAGS = 4
61 SUB_IF_API_FLAG_DOT1AD = 8
62 SUB_IF_API_FLAG_EXACT_MATCH = 16
63 SUB_IF_API_FLAG_DEFAULT = 32
64 SUB_IF_API_FLAG_OUTER_VLAN_ID_ANY = 64
65 SUB_IF_API_FLAG_INNER_VLAN_ID_ANY = 128
66 SUB_IF_API_FLAG_DOT1AH = 256
69 class RxMode(IntEnum):
71 RX_MODE_API_UNKNOWN = 0
72 RX_MODE_API_POLLING = 1
73 RX_MODE_API_INTERRUPT = 2
74 RX_MODE_API_ADAPTIVE = 3
75 RX_MODE_API_DEFAULT = 4
78 class IfType(IntEnum):
81 IF_API_TYPE_HARDWARE = 0
88 class LinkBondLoadBalanceAlgo(IntEnum):
89 """Link bonding load balance algorithm."""
90 BOND_API_LB_ALGO_L2 = 0
91 BOND_API_LB_ALGO_L34 = 1
92 BOND_API_LB_ALGO_L23 = 2
93 BOND_API_LB_ALGO_RR = 3
94 BOND_API_LB_ALGO_BC = 4
95 BOND_API_LB_ALGO_AB = 5
98 class LinkBondMode(IntEnum):
99 """Link bonding mode."""
100 BOND_API_MODE_ROUND_ROBIN = 1
101 BOND_API_MODE_ACTIVE_BACKUP = 2
102 BOND_API_MODE_XOR = 3
103 BOND_API_MODE_BROADCAST = 4
104 BOND_API_MODE_LACP = 5
107 class RdmaMode(IntEnum):
108 """RDMA interface mode."""
109 RDMA_API_MODE_AUTO = 0
110 RDMA_API_MODE_IBV = 1
114 class AfXdpMode(IntEnum):
115 """AF_XDP interface mode."""
116 AF_XDP_API_MODE_AUTO = 0
117 AF_XDP_API_MODE_COPY = 1
118 AF_XDP_API_MODE_ZERO_COPY = 2
122 """General utilities for managing interfaces"""
125 def pci_to_int(pci_str):
126 """Convert PCI address from string format (0000:18:0a.0) to
127 integer representation (169345024).
129 :param pci_str: PCI address in string representation.
131 :returns: Integer representation of PCI address.
134 pci = list(pci_str.split(u":")[0:2])
135 pci.extend(pci_str.split(u":")[2].split(u"."))
137 return (int(pci[0], 16) | int(pci[1], 16) << 16 |
138 int(pci[2], 16) << 24 | int(pci[3], 16) << 29)
141 def pci_to_eth(node, pci_str):
142 """Convert PCI address on DUT to Linux ethernet name.
144 :param node: DUT node
145 :param pci_str: PCI address.
148 :returns: Ethernet name.
151 cmd = f"basename /sys/bus/pci/devices/{pci_str}/net/*"
153 stdout, _ = exec_cmd_no_error(node, cmd)
155 raise RuntimeError(f"Cannot convert {pci_str} to ethernet name!")
157 return stdout.strip()
160 def get_interface_index(node, interface):
161 """Get interface sw_if_index from topology file.
163 :param node: Node where the interface is.
164 :param interface: Numeric index or name string of a specific interface.
166 :type interface: str or int
167 :returns: SW interface index.
171 sw_if_index = int(interface)
173 sw_if_index = Topology.get_interface_sw_index(node, interface)
174 if sw_if_index is None:
176 Topology.get_interface_sw_index_by_name(node, interface)
177 except TypeError as err:
178 raise TypeError(f"Wrong interface format {interface}") from err
183 def set_interface_state(node, interface, state, if_type=u"key"):
184 """Set interface state on a node.
186 Function can be used for DUTs as well as for TGs.
188 :param node: Node where the interface is.
189 :param interface: Interface key or sw_if_index or name.
190 :param state: One of 'up' or 'down'.
191 :param if_type: Interface type
193 :type interface: str or int
197 :raises ValueError: If the interface type is unknown.
198 :raises ValueError: If the state of interface is unexpected.
199 :raises ValueError: If the node has an unknown node type.
201 if if_type == u"key":
202 if isinstance(interface, str):
203 sw_if_index = Topology.get_interface_sw_index(node, interface)
204 iface_name = Topology.get_interface_name(node, interface)
206 sw_if_index = interface
207 elif if_type == u"name":
208 iface_key = Topology.get_interface_by_name(node, interface)
209 if iface_key is not None:
210 sw_if_index = Topology.get_interface_sw_index(node, iface_key)
211 iface_name = interface
213 raise ValueError(f"Unknown if_type: {if_type}")
215 if node[u"type"] == NodeType.DUT:
216 if sw_if_index is None:
218 f"Interface index for {interface} not assigned by VPP."
221 flags = InterfaceStatusFlags.IF_STATUS_API_FLAG_ADMIN_UP.value
222 elif state == u"down":
225 raise ValueError(f"Unexpected interface state: {state}")
226 cmd = u"sw_interface_set_flags"
227 err_msg = f"Failed to set interface state on host {node[u'host']}"
229 sw_if_index=int(sw_if_index),
232 with PapiSocketExecutor(node) as papi_exec:
233 papi_exec.add(cmd, **args).get_reply(err_msg)
234 elif node[u"type"] == NodeType.TG or node[u"type"] == NodeType.VM:
235 cmd = f"ip link set {iface_name} {state}"
236 exec_cmd_no_error(node, cmd, sudo=True)
239 f"Node {node[u'host']} has unknown NodeType: {node[u'type']}"
243 def set_interface_state_pci(
244 node, pf_pcis, namespace=None, state=u"up"):
245 """Set operational state for interface specified by PCI address.
247 :param node: Topology node.
248 :param pf_pcis: List of node's interfaces PCI addresses.
249 :param namespace: Exec command in namespace. (Optional, Default: none)
250 :param state: Up/Down. (Optional, default: up)
256 for pf_pci in pf_pcis:
257 pf_eth = InterfaceUtil.pci_to_eth(node, pf_pci)
258 InterfaceUtil.set_linux_interface_state(
259 node, pf_eth, namespace=namespace, state=state
263 def set_interface_mtu(node, pf_pcis, mtu=9200):
264 """Set Ethernet MTU for specified interfaces.
266 :param node: Topology node.
267 :param pf_pcis: List of node's interfaces PCI addresses.
268 :param mtu: MTU to set. Default: 9200.
272 :raises RuntimeError: If failed to set MTU on interface.
274 for pf_pci in pf_pcis:
275 pf_eth = InterfaceUtil.pci_to_eth(node, pf_pci)
276 cmd = f"ip link set {pf_eth} mtu {mtu}"
277 exec_cmd_no_error(node, cmd, sudo=True)
280 def set_interface_channels(
281 node, pf_pcis, num_queues=1, channel=u"combined"):
282 """Set interface channels for specified interfaces.
284 :param node: Topology node.
285 :param pf_pcis: List of node's interfaces PCI addresses.
286 :param num_queues: Number of channels. (Optional, Default: 1)
287 :param channel: Channel type. (Optional, Default: combined)
290 :type num_queues: int
293 for pf_pci in pf_pcis:
294 pf_eth = InterfaceUtil.pci_to_eth(node, pf_pci)
295 cmd = f"ethtool --set-channels {pf_eth} {channel} {num_queues}"
296 exec_cmd_no_error(node, cmd, sudo=True)
299 def set_interface_xdp_off(node, pf_pcis):
300 """Detaches any currently attached XDP/BPF program from the specified
303 :param node: Topology node.
304 :param pf_pcis: List of node's interfaces PCI addresses.
308 for pf_pci in pf_pcis:
309 pf_eth = InterfaceUtil.pci_to_eth(node, pf_pci)
310 cmd = f"ip link set dev {pf_eth} xdp off"
311 exec_cmd_no_error(node, cmd, sudo=True)
314 def set_interface_flow_control(node, pf_pcis, rxf=u"off", txf=u"off"):
315 """Set Ethernet flow control for specified interfaces.
317 :param node: Topology node.
318 :param pf_pcis: List of node's interfaces PCI addresses.
319 :param rxf: RX flow. (Optional, Default: off).
320 :param txf: TX flow. (Optional, Default: off).
326 for pf_pci in pf_pcis:
327 pf_eth = InterfaceUtil.pci_to_eth(node, pf_pci)
328 cmd = f"ethtool -A {pf_eth} rx {rxf} tx {txf}"
329 ret_code, _, _ = exec_cmd(node, cmd, sudo=True)
330 if int(ret_code) not in (0, 78):
331 raise RuntimeError("Failed to set flow control on {pf_eth}!")
334 def set_pci_parameter(node, pf_pcis, key, value):
335 """Set PCI parameter for specified interfaces.
337 :param node: Topology node.
338 :param pf_pcis: List of node's interfaces PCI addresses.
339 :param key: Key to set.
340 :param value: Value to set.
346 for pf_pci in pf_pcis:
347 cmd = f"setpci -s {pf_pci} {key}={value}"
348 exec_cmd_no_error(node, cmd, sudo=True)
351 def vpp_set_interface_mtu(node, interface, mtu):
352 """Apply new MTU value to a VPP hardware interface.
354 The interface should be down when this is called.
356 :param node: VPP node.
357 :param interface: Interface to set MTU on.
358 :param mtu: Ethernet MTU size in Bytes.
360 :type interface: str or int
363 if isinstance(interface, str):
364 sw_if_index = Topology.get_interface_sw_index(node, interface)
366 sw_if_index = interface
367 cmd = u"hw_interface_set_mtu"
368 err_msg = f"Failed to set interface MTU on host {node[u'host']}"
369 args = dict(sw_if_index=sw_if_index, mtu=int(mtu))
370 with PapiSocketExecutor(node) as papi_exec:
371 papi_exec.add(cmd, **args).get_reply(err_msg)
374 def vpp_node_interfaces_ready_wait(node, retries=15):
375 """Wait until all interfaces with admin-up are in link-up state.
377 :param node: Node to wait on.
378 :param retries: Number of retries to check interface status (optional,
383 :raises RuntimeError: If any interface is not in link-up state after
384 defined number of retries.
386 for _ in range(0, retries):
388 out = InterfaceUtil.vpp_get_interface_data(node)
389 for interface in out:
390 if interface.get(u"flags") == 1:
391 not_ready.append(interface.get(u"interface_name"))
394 f"Interfaces still not in link-up state:\n{not_ready}"
400 err = f"Timeout, interfaces not up:\n{not_ready}" \
401 if u"not_ready" in locals() else u"No check executed!"
402 raise RuntimeError(err)
405 def all_vpp_interfaces_ready_wait(nodes, retries=15):
406 """Wait until all interfaces with admin-up are in link-up state for all
407 nodes in the topology.
409 :param nodes: Nodes in the topology.
410 :param retries: Number of retries to check interface status (optional,
416 for node in nodes.values():
417 if node[u"type"] == NodeType.DUT:
418 InterfaceUtil.vpp_node_interfaces_ready_wait(node, retries)
421 def vpp_get_interface_data(node, interface=None):
422 """Get all interface data from a VPP node. If a name or
423 sw_interface_index is provided, return only data for the matching
426 :param node: VPP node to get interface data from.
427 :param interface: Numeric index or name string of a specific interface.
429 :type interface: int or str
430 :returns: List of dictionaries containing data for each interface, or a
431 single dictionary for the specified interface.
433 :raises TypeError: if the data type of interface is neither basestring
436 def process_if_dump(if_dump):
437 """Process interface dump.
439 :param if_dump: Interface dump.
441 :returns: Processed interface dump.
444 if_dump[u"l2_address"] = str(if_dump[u"l2_address"])
445 if_dump[u"b_dmac"] = str(if_dump[u"b_dmac"])
446 if_dump[u"b_smac"] = str(if_dump[u"b_smac"])
447 if_dump[u"flags"] = if_dump[u"flags"].value
448 if_dump[u"type"] = if_dump[u"type"].value
449 if_dump[u"link_duplex"] = if_dump[u"link_duplex"].value
450 if_dump[u"sub_if_flags"] = if_dump[u"sub_if_flags"].value \
451 if hasattr(if_dump[u"sub_if_flags"], u"value") \
452 else int(if_dump[u"sub_if_flags"])
456 if interface is not None:
457 if isinstance(interface, str):
458 param = u"interface_name"
459 elif isinstance(interface, int):
460 param = u"sw_if_index"
462 raise TypeError(f"Wrong interface format {interface}")
466 cmd = u"sw_interface_dump"
468 name_filter_valid=False,
471 err_msg = f"Failed to get interface dump on host {node[u'host']}"
473 with PapiSocketExecutor(node) as papi_exec:
474 details = papi_exec.add(cmd, **args).get_details(err_msg)
475 logger.debug(f"Received data:\n{details!r}")
477 data = list() if interface is None else dict()
479 if interface is None:
480 data.append(process_if_dump(dump))
481 elif str(dump.get(param)).rstrip(u"\x00") == str(interface):
482 data = process_if_dump(dump)
485 logger.debug(f"Interface data:\n{data}")
489 def vpp_get_interface_name(node, sw_if_index):
490 """Get interface name for the given SW interface index from actual
493 :param node: VPP node to get interface data from.
494 :param sw_if_index: SW interface index of the specific interface.
496 :type sw_if_index: int
497 :returns: Name of the given interface.
500 if_data = InterfaceUtil.vpp_get_interface_data(node, sw_if_index)
501 if if_data[u"sup_sw_if_index"] != if_data[u"sw_if_index"]:
502 if_data = InterfaceUtil.vpp_get_interface_data(
503 node, if_data[u"sup_sw_if_index"]
506 return if_data.get(u"interface_name")
509 def vpp_get_interface_sw_index(node, interface_name):
510 """Get interface name for the given SW interface index from actual
513 :param node: VPP node to get interface data from.
514 :param interface_name: Interface name.
516 :type interface_name: str
517 :returns: Name of the given interface.
520 if_data = InterfaceUtil.vpp_get_interface_data(node, interface_name)
522 return if_data.get(u"sw_if_index")
525 def vpp_get_interface_mac(node, interface):
526 """Get MAC address for the given interface from actual interface dump.
528 :param node: VPP node to get interface data from.
529 :param interface: Numeric index or name string of a specific interface.
531 :type interface: int or str
532 :returns: MAC address.
535 if_data = InterfaceUtil.vpp_get_interface_data(node, interface)
536 if if_data[u"sup_sw_if_index"] != if_data[u"sw_if_index"]:
537 if_data = InterfaceUtil.vpp_get_interface_data(
538 node, if_data[u"sup_sw_if_index"])
540 return if_data.get(u"l2_address")
543 def vpp_set_interface_mac(node, interface, mac):
544 """Set MAC address for the given interface.
546 :param node: VPP node to set interface MAC.
547 :param interface: Numeric index or name string of a specific interface.
548 :param mac: Required MAC address.
550 :type interface: int or str
553 cmd = u"sw_interface_set_mac_address"
555 sw_if_index=InterfaceUtil.get_interface_index(node, interface),
556 mac_address=L2Util.mac_to_bin(mac)
558 err_msg = f"Failed to set MAC address of interface {interface}" \
559 f"on host {node[u'host']}"
560 with PapiSocketExecutor(node) as papi_exec:
561 papi_exec.add(cmd, **args).get_reply(err_msg)
564 def tg_set_interface_driver(node, pci_addr, driver):
565 """Set interface driver on the TG node.
567 :param node: Node to set interface driver on (must be TG node).
568 :param pci_addr: PCI address of the interface.
569 :param driver: Driver name.
573 :raises RuntimeError: If unbinding from the current driver fails.
574 :raises RuntimeError: If binding to the new driver fails.
576 old_driver = InterfaceUtil.tg_get_interface_driver(node, pci_addr)
577 if old_driver == driver:
583 # Unbind from current driver
584 if old_driver is not None:
585 cmd = f"sh -c \"echo {pci_addr} > " \
586 f"/sys/bus/pci/drivers/{old_driver}/unbind\""
587 ret_code, _, _ = ssh.exec_command_sudo(cmd)
588 if int(ret_code) != 0:
589 raise RuntimeError(f"'{cmd}' failed on '{node[u'host']}'")
591 # Bind to the new driver
592 cmd = f"sh -c \"echo {pci_addr} > /sys/bus/pci/drivers/{driver}/bind\""
593 ret_code, _, _ = ssh.exec_command_sudo(cmd)
594 if int(ret_code) != 0:
595 raise RuntimeError(f"'{cmd}' failed on '{node[u'host']}'")
598 def tg_get_interface_driver(node, pci_addr):
599 """Get interface driver from the TG node.
601 :param node: Node to get interface driver on (must be TG node).
602 :param pci_addr: PCI address of the interface.
605 :returns: Interface driver or None if not found.
607 :raises RuntimeError: If PCI rescan or lspci command execution failed.
609 return DUTSetup.get_pci_dev_driver(node, pci_addr)
612 def tg_set_interfaces_default_driver(node):
613 """Set interfaces default driver specified in topology yaml file.
615 :param node: Node to setup interfaces driver on (must be TG node).
618 for interface in node[u"interfaces"].values():
619 InterfaceUtil.tg_set_interface_driver(
620 node, interface[u"pci_address"], interface[u"driver"]
624 def update_vpp_interface_data_on_node(node):
625 """Update vpp generated interface data for a given node in DICT__nodes.
627 Updates interface names, software if index numbers and any other details
628 generated specifically by vpp that are unknown before testcase run.
629 It does this by dumping interface list from all devices using python
630 api, and pairing known information from topology (mac address) to state
633 :param node: Node selected from DICT__nodes.
636 interface_list = InterfaceUtil.vpp_get_interface_data(node)
637 interface_dict = dict()
638 for ifc in interface_list:
639 interface_dict[ifc[u"l2_address"]] = ifc
641 for if_name, if_data in node[u"interfaces"].items():
642 ifc_dict = interface_dict.get(if_data[u"mac_address"])
643 if ifc_dict is not None:
644 if_data[u"name"] = ifc_dict[u"interface_name"]
645 if_data[u"vpp_sw_index"] = ifc_dict[u"sw_if_index"]
646 if_data[u"mtu"] = ifc_dict[u"mtu"][0]
648 f"Interface {if_name} found by MAC "
649 f"{if_data[u'mac_address']}"
653 f"Interface {if_name} not found by MAC "
654 f"{if_data[u'mac_address']}"
656 if_data[u"vpp_sw_index"] = None
659 def update_nic_interface_names(node):
660 """Update interface names based on nic type and PCI address.
662 This method updates interface names in the same format as VPP does.
664 :param node: Node dictionary.
667 for ifc in node[u"interfaces"].values():
668 if_pci = ifc[u"pci_address"].replace(u".", u":").split(u":")
669 loc = f"{int(if_pci[1], 16):x}/{int(if_pci[2], 16):x}/" \
670 f"{int(if_pci[3], 16):x}"
671 if ifc[u"model"] == u"Intel-XL710":
672 ifc[u"name"] = f"FortyGigabitEthernet{loc}"
673 elif ifc[u"model"] == u"Intel-X710":
674 ifc[u"name"] = f"TenGigabitEthernet{loc}"
675 elif ifc[u"model"] == u"Intel-X520-DA2":
676 ifc[u"name"] = f"TenGigabitEthernet{loc}"
677 elif ifc[u"model"] == u"Cisco-VIC-1385":
678 ifc[u"name"] = f"FortyGigabitEthernet{loc}"
679 elif ifc[u"model"] == u"Cisco-VIC-1227":
680 ifc[u"name"] = f"TenGigabitEthernet{loc}"
682 ifc[u"name"] = f"UnknownEthernet{loc}"
685 def update_nic_interface_names_on_all_duts(nodes):
686 """Update interface names based on nic type and PCI address on all DUTs.
688 This method updates interface names in the same format as VPP does.
690 :param nodes: Topology nodes.
693 for node in nodes.values():
694 if node[u"type"] == NodeType.DUT:
695 InterfaceUtil.update_nic_interface_names(node)
698 def update_tg_interface_data_on_node(node):
699 """Update interface name for TG/linux node in DICT__nodes.
702 # for dev in `ls /sys/class/net/`;
703 > do echo "\"`cat /sys/class/net/$dev/address`\": \"$dev\""; done
704 "52:54:00:9f:82:63": "eth0"
705 "52:54:00:77:ae:a9": "eth1"
706 "52:54:00:e1:8a:0f": "eth2"
707 "00:00:00:00:00:00": "lo"
709 :param node: Node selected from DICT__nodes.
711 :raises RuntimeError: If getting of interface name and MAC fails.
713 # First setup interface driver specified in yaml file
714 InterfaceUtil.tg_set_interfaces_default_driver(node)
716 # Get interface names
720 cmd = u'for dev in `ls /sys/class/net/`; do echo "\\"`cat ' \
721 u'/sys/class/net/$dev/address`\\": \\"$dev\\""; done;'
723 ret_code, stdout, _ = ssh.exec_command(cmd)
724 if int(ret_code) != 0:
725 raise RuntimeError(u"Get interface name and MAC failed")
727 interfaces = loads("{" + stdout.rstrip().replace("\n", ",") + "}")
728 for interface in node[u"interfaces"].values():
729 name = interfaces.get(interface[u"mac_address"])
732 interface[u"name"] = name
735 def iface_update_numa_node(node):
736 """For all interfaces from topology file update numa node based on
737 information from the node.
739 :param node: Node from topology.
742 :raises ValueError: If numa node ia less than 0.
743 :raises RuntimeError: If update of numa node failed.
746 for if_key in Topology.get_node_interfaces(node):
747 if_pci = Topology.get_interface_pci_addr(node, if_key)
749 cmd = f"cat /sys/bus/pci/devices/{if_pci}/numa_node"
751 ret, out, _ = ssh.exec_command(cmd)
754 numa_node = 0 if int(out) < 0 else int(out)
757 f"Reading numa location failed for: {if_pci}"
760 Topology.set_interface_numa_node(
761 node, if_key, numa_node
765 raise RuntimeError(f"Update numa node failed for: {if_pci}")
768 def update_all_interface_data_on_all_nodes(
769 nodes, skip_tg=False, skip_vpp=False):
770 """Update interface names on all nodes in DICT__nodes.
772 This method updates the topology dictionary by querying interface lists
773 of all nodes mentioned in the topology dictionary.
775 :param nodes: Nodes in the topology.
776 :param skip_tg: Skip TG node.
777 :param skip_vpp: Skip VPP node.
782 for node in nodes.values():
783 if node[u"type"] == NodeType.DUT and not skip_vpp:
784 InterfaceUtil.update_vpp_interface_data_on_node(node)
785 elif node[u"type"] == NodeType.TG and not skip_tg:
786 InterfaceUtil.update_tg_interface_data_on_node(node)
787 InterfaceUtil.iface_update_numa_node(node)
790 def create_vlan_subinterface(node, interface, vlan):
791 """Create VLAN sub-interface on node.
793 :param node: Node to add VLAN subinterface on.
794 :param interface: Interface name or index on which create VLAN
796 :param vlan: VLAN ID of the subinterface to be created.
798 :type interface: str on int
800 :returns: Name and index of created subinterface.
802 :raises RuntimeError: if it is unable to create VLAN subinterface on the
803 node or interface cannot be converted.
805 sw_if_index = InterfaceUtil.get_interface_index(node, interface)
807 cmd = u"create_vlan_subif"
809 sw_if_index=sw_if_index,
812 err_msg = f"Failed to create VLAN sub-interface on host {node[u'host']}"
814 with PapiSocketExecutor(node) as papi_exec:
815 sw_if_index = papi_exec.add(cmd, **args).get_sw_if_index(err_msg)
817 if_key = Topology.add_new_port(node, u"vlan_subif")
818 Topology.update_interface_sw_if_index(node, if_key, sw_if_index)
819 ifc_name = InterfaceUtil.vpp_get_interface_name(node, sw_if_index)
820 Topology.update_interface_name(node, if_key, ifc_name)
822 return f"{interface}.{vlan}", sw_if_index
825 def create_vxlan_interface(node, vni, source_ip, destination_ip):
826 """Create VXLAN interface and return sw if index of created interface.
828 :param node: Node where to create VXLAN interface.
829 :param vni: VXLAN Network Identifier.
830 :param source_ip: Source IP of a VXLAN Tunnel End Point.
831 :param destination_ip: Destination IP of a VXLAN Tunnel End Point.
835 :type destination_ip: str
836 :returns: SW IF INDEX of created interface.
838 :raises RuntimeError: if it is unable to create VxLAN interface on the
841 cmd = u"vxlan_add_del_tunnel_v3"
844 instance=Constants.BITWISE_NON_ZERO,
845 src_address=IPAddress.create_ip_address_object(
846 ip_address(source_ip)
848 dst_address=IPAddress.create_ip_address_object(
849 ip_address(destination_ip)
851 mcast_sw_if_index=Constants.BITWISE_NON_ZERO,
853 decap_next_index=Constants.BITWISE_NON_ZERO,
856 err_msg = f"Failed to create VXLAN tunnel interface " \
857 f"on host {node[u'host']}"
858 with PapiSocketExecutor(node) as papi_exec:
859 sw_if_index = papi_exec.add(cmd, **args).get_sw_if_index(err_msg)
861 if_key = Topology.add_new_port(node, u"vxlan_tunnel")
862 Topology.update_interface_sw_if_index(node, if_key, sw_if_index)
863 ifc_name = InterfaceUtil.vpp_get_interface_name(node, sw_if_index)
864 Topology.update_interface_name(node, if_key, ifc_name)
869 def set_vxlan_bypass(node, interface=None):
870 """Add the 'ip4-vxlan-bypass' graph node for a given interface.
872 By adding the IPv4 vxlan-bypass graph node to an interface, the node
873 checks for and validate input vxlan packet and bypass ip4-lookup,
874 ip4-local, ip4-udp-lookup nodes to speedup vxlan packet forwarding.
875 This node will cause extra overhead to for non-vxlan packets which is
878 :param node: Node where to set VXLAN bypass.
879 :param interface: Numeric index or name string of a specific interface.
881 :type interface: int or str
882 :raises RuntimeError: if it failed to set VXLAN bypass on interface.
884 sw_if_index = InterfaceUtil.get_interface_index(node, interface)
886 cmd = u"sw_interface_set_vxlan_bypass"
889 sw_if_index=sw_if_index,
892 err_msg = f"Failed to set VXLAN bypass on interface " \
893 f"on host {node[u'host']}"
894 with PapiSocketExecutor(node) as papi_exec:
895 papi_exec.add(cmd, **args).get_reply(err_msg)
898 def vxlan_dump(node, interface=None):
899 """Get VxLAN data for the given interface.
901 :param node: VPP node to get interface data from.
902 :param interface: Numeric index or name string of a specific interface.
903 If None, information about all VxLAN interfaces is returned.
905 :type interface: int or str
906 :returns: Dictionary containing data for the given VxLAN interface or if
907 interface=None, the list of dictionaries with all VxLAN interfaces.
909 :raises TypeError: if the data type of interface is neither basestring
912 def process_vxlan_dump(vxlan_dump):
913 """Process vxlan dump.
915 :param vxlan_dump: Vxlan interface dump.
916 :type vxlan_dump: dict
917 :returns: Processed vxlan interface dump.
920 vxlan_dump[u"src_address"] = str(vxlan_dump[u"src_address"])
921 vxlan_dump[u"dst_address"] = str(vxlan_dump[u"dst_address"])
924 if interface is not None:
925 sw_if_index = InterfaceUtil.get_interface_index(node, interface)
927 sw_if_index = int(Constants.BITWISE_NON_ZERO)
929 cmd = u"vxlan_tunnel_dump"
931 sw_if_index=sw_if_index
933 err_msg = f"Failed to get VXLAN dump on host {node[u'host']}"
935 with PapiSocketExecutor(node) as papi_exec:
936 details = papi_exec.add(cmd, **args).get_details(err_msg)
938 data = list() if interface is None else dict()
940 if interface is None:
941 data.append(process_vxlan_dump(dump))
942 elif dump[u"sw_if_index"] == sw_if_index:
943 data = process_vxlan_dump(dump)
946 logger.debug(f"VXLAN data:\n{data}")
950 def create_subinterface(
951 node, interface, sub_id, outer_vlan_id=None, inner_vlan_id=None,
953 """Create sub-interface on node. It is possible to set required
954 sub-interface type and VLAN tag(s).
956 :param node: Node to add sub-interface.
957 :param interface: Interface name on which create sub-interface.
958 :param sub_id: ID of the sub-interface to be created.
959 :param outer_vlan_id: Optional outer VLAN ID.
960 :param inner_vlan_id: Optional inner VLAN ID.
961 :param type_subif: Optional type of sub-interface. Values supported by
962 VPP: [no_tags] [one_tag] [two_tags] [dot1ad] [exact_match]
965 :type interface: str or int
967 :type outer_vlan_id: int
968 :type inner_vlan_id: int
969 :type type_subif: str
970 :returns: Name and index of created sub-interface.
972 :raises RuntimeError: If it is not possible to create sub-interface.
974 subif_types = type_subif.split()
977 if u"no_tags" in subif_types:
978 flags = flags | SubInterfaceFlags.SUB_IF_API_FLAG_NO_TAGS
979 if u"one_tag" in subif_types:
980 flags = flags | SubInterfaceFlags.SUB_IF_API_FLAG_ONE_TAG
981 if u"two_tags" in subif_types:
982 flags = flags | SubInterfaceFlags.SUB_IF_API_FLAG_TWO_TAGS
983 if u"dot1ad" in subif_types:
984 flags = flags | SubInterfaceFlags.SUB_IF_API_FLAG_DOT1AD
985 if u"exact_match" in subif_types:
986 flags = flags | SubInterfaceFlags.SUB_IF_API_FLAG_EXACT_MATCH
987 if u"default_sub" in subif_types:
988 flags = flags | SubInterfaceFlags.SUB_IF_API_FLAG_DEFAULT
989 if type_subif == u"default_sub":
990 flags = flags | SubInterfaceFlags.SUB_IF_API_FLAG_INNER_VLAN_ID_ANY\
991 | SubInterfaceFlags.SUB_IF_API_FLAG_OUTER_VLAN_ID_ANY
993 cmd = u"create_subif"
995 sw_if_index=InterfaceUtil.get_interface_index(node, interface),
997 sub_if_flags=flags.value if hasattr(flags, u"value")
999 outer_vlan_id=int(outer_vlan_id) if outer_vlan_id else 0,
1000 inner_vlan_id=int(inner_vlan_id) if inner_vlan_id else 0
1002 err_msg = f"Failed to create sub-interface on host {node[u'host']}"
1003 with PapiSocketExecutor(node) as papi_exec:
1004 sw_if_index = papi_exec.add(cmd, **args).get_sw_if_index(err_msg)
1006 if_key = Topology.add_new_port(node, u"subinterface")
1007 Topology.update_interface_sw_if_index(node, if_key, sw_if_index)
1008 ifc_name = InterfaceUtil.vpp_get_interface_name(node, sw_if_index)
1009 Topology.update_interface_name(node, if_key, ifc_name)
1011 return f"{interface}.{sub_id}", sw_if_index
1014 def create_gre_tunnel_interface(node, source_ip, destination_ip):
1015 """Create GRE tunnel interface on node.
1017 :param node: VPP node to add tunnel interface.
1018 :param source_ip: Source of the GRE tunnel.
1019 :param destination_ip: Destination of the GRE tunnel.
1021 :type source_ip: str
1022 :type destination_ip: str
1023 :returns: Name and index of created GRE tunnel interface.
1025 :raises RuntimeError: If unable to create GRE tunnel interface.
1027 cmd = u"gre_tunnel_add_del"
1030 instance=Constants.BITWISE_NON_ZERO,
1032 dst=str(destination_ip),
1040 err_msg = f"Failed to create GRE tunnel interface " \
1041 f"on host {node[u'host']}"
1042 with PapiSocketExecutor(node) as papi_exec:
1043 sw_if_index = papi_exec.add(cmd, **args).get_sw_if_index(err_msg)
1045 if_key = Topology.add_new_port(node, u"gre_tunnel")
1046 Topology.update_interface_sw_if_index(node, if_key, sw_if_index)
1047 ifc_name = InterfaceUtil.vpp_get_interface_name(node, sw_if_index)
1048 Topology.update_interface_name(node, if_key, ifc_name)
1050 return ifc_name, sw_if_index
1053 def create_gtpu_tunnel_interface(node, teid, source_ip, destination_ip):
1054 """Create GTPU interface and return sw if index of created interface.
1056 :param node: Node where to create GTPU interface.
1057 :param teid: GTPU Tunnel Endpoint Identifier.
1058 :param source_ip: Source IP of a GTPU Tunnel End Point.
1059 :param destination_ip: Destination IP of a GTPU Tunnel End Point.
1062 :type source_ip: str
1063 :type destination_ip: str
1064 :returns: SW IF INDEX of created interface.
1066 :raises RuntimeError: if it is unable to create GTPU interface on the
1069 cmd = u"gtpu_add_del_tunnel_v2"
1072 src_address=IPAddress.create_ip_address_object(
1073 ip_address(source_ip)
1075 dst_address=IPAddress.create_ip_address_object(
1076 ip_address(destination_ip)
1078 mcast_sw_if_index=Constants.BITWISE_NON_ZERO,
1080 decap_next_index=2, # ipv4
1082 # pdu_extension: Unused, false by default.
1083 # qfi: Irrelevant when pdu_extension is not used.
1085 err_msg = f"Failed to create GTPU tunnel interface " \
1086 f"on host {node[u'host']}"
1087 with PapiSocketExecutor(node) as papi_exec:
1088 sw_if_index = papi_exec.add(cmd, **args).get_sw_if_index(err_msg)
1090 if_key = Topology.add_new_port(node, u"gtpu_tunnel")
1091 Topology.update_interface_sw_if_index(node, if_key, sw_if_index)
1092 ifc_name = InterfaceUtil.vpp_get_interface_name(node, sw_if_index)
1093 Topology.update_interface_name(node, if_key, ifc_name)
1098 def vpp_enable_gtpu_offload_rx(node, interface, gtpu_if_index):
1099 """Enable GTPU offload RX onto interface.
1101 :param node: Node to run command on.
1102 :param interface: Name of the specific interface.
1103 :param gtpu_if_index: Index of GTPU tunnel interface.
1106 :type interface: str
1107 :type gtpu_interface: int
1109 sw_if_index = Topology.get_interface_sw_index(node, interface)
1111 cmd = u"gtpu_offload_rx"
1113 hw_if_index=sw_if_index,
1114 sw_if_index=gtpu_if_index,
1118 err_msg = f"Failed to enable GTPU offload RX on host {node[u'host']}"
1119 with PapiSocketExecutor(node) as papi_exec:
1120 papi_exec.add(cmd, **args).get_reply(err_msg)
1123 def vpp_create_loopback(node, mac=None):
1124 """Create loopback interface on VPP node.
1126 :param node: Node to create loopback interface on.
1127 :param mac: Optional MAC address for loopback interface.
1130 :returns: SW interface index.
1132 :raises RuntimeError: If it is not possible to create loopback on the
1135 cmd = u"create_loopback_instance"
1137 mac_address=L2Util.mac_to_bin(mac) if mac else 0,
1141 err_msg = f"Failed to create loopback interface on host {node[u'host']}"
1142 with PapiSocketExecutor(node) as papi_exec:
1143 sw_if_index = papi_exec.add(cmd, **args).get_sw_if_index(err_msg)
1145 if_key = Topology.add_new_port(node, u"loopback")
1146 Topology.update_interface_sw_if_index(node, if_key, sw_if_index)
1147 ifc_name = InterfaceUtil.vpp_get_interface_name(node, sw_if_index)
1148 Topology.update_interface_name(node, if_key, ifc_name)
1150 mac = InterfaceUtil.vpp_get_interface_mac(node, ifc_name)
1151 Topology.update_interface_mac_address(node, if_key, mac)
1156 def vpp_create_bond_interface(
1157 node, mode, load_balance=None, mac=None, gso=False):
1158 """Create bond interface on VPP node.
1160 :param node: DUT node from topology.
1161 :param mode: Link bonding mode.
1162 :param load_balance: Load balance (optional, valid for xor and lacp
1163 modes, otherwise ignored). Default: None.
1164 :param mac: MAC address to assign to the bond interface (optional).
1166 :param gso: Enable GSO support (optional). Default: False.
1169 :type load_balance: str
1172 :returns: Interface key (name) in topology.
1174 :raises RuntimeError: If it is not possible to create bond interface on
1177 cmd = u"bond_create2"
1179 id=int(Constants.BITWISE_NON_ZERO),
1180 use_custom_mac=bool(mac is not None),
1181 mac_address=L2Util.mac_to_bin(mac) if mac else None,
1184 f"BOND_API_MODE_{mode.replace(u'-', u'_').upper()}"
1186 lb=0 if load_balance is None else getattr(
1187 LinkBondLoadBalanceAlgo,
1188 f"BOND_API_LB_ALGO_{load_balance.upper()}"
1193 err_msg = f"Failed to create bond interface on host {node[u'host']}"
1194 with PapiSocketExecutor(node) as papi_exec:
1195 sw_if_index = papi_exec.add(cmd, **args).get_sw_if_index(err_msg)
1197 InterfaceUtil.add_eth_interface(
1198 node, sw_if_index=sw_if_index, ifc_pfx=u"eth_bond"
1200 if_key = Topology.get_interface_by_sw_index(node, sw_if_index)
1205 def add_eth_interface(
1206 node, ifc_name=None, sw_if_index=None, ifc_pfx=None,
1208 """Add ethernet interface to current topology.
1210 :param node: DUT node from topology.
1211 :param ifc_name: Name of the interface.
1212 :param sw_if_index: SW interface index.
1213 :param ifc_pfx: Interface key prefix.
1214 :param host_if_key: Host interface key from topology file.
1217 :type sw_if_index: int
1219 :type host_if_key: str
1221 if_key = Topology.add_new_port(node, ifc_pfx)
1223 if ifc_name and sw_if_index is None:
1224 sw_if_index = InterfaceUtil.vpp_get_interface_sw_index(
1226 Topology.update_interface_sw_if_index(node, if_key, sw_if_index)
1227 if sw_if_index and ifc_name is None:
1228 ifc_name = InterfaceUtil.vpp_get_interface_name(node, sw_if_index)
1229 Topology.update_interface_name(node, if_key, ifc_name)
1230 ifc_mac = InterfaceUtil.vpp_get_interface_mac(node, sw_if_index)
1231 Topology.update_interface_mac_address(node, if_key, ifc_mac)
1232 if host_if_key is not None:
1233 Topology.set_interface_numa_node(
1234 node, if_key, Topology.get_interface_numa_node(
1238 Topology.update_interface_pci_address(
1239 node, if_key, Topology.get_interface_pci_addr(node, host_if_key)
1243 def vpp_create_avf_interface(
1244 node, if_key, num_rx_queues=None, rxq_size=0, txq_size=0):
1245 """Create AVF interface on VPP node.
1247 :param node: DUT node from topology.
1248 :param if_key: Interface key from topology file of interface
1249 to be bound to i40evf driver.
1250 :param num_rx_queues: Number of RX queues.
1251 :param rxq_size: Size of RXQ (0 = Default API; 512 = Default VPP).
1252 :param txq_size: Size of TXQ (0 = Default API; 512 = Default VPP).
1255 :type num_rx_queues: int
1258 :returns: AVF interface key (name) in topology.
1260 :raises RuntimeError: If it is not possible to create AVF interface on
1263 PapiSocketExecutor.run_cli_cmd(
1264 node, u"set logging class avf level debug"
1268 vf_pci_addr = Topology.get_interface_pci_addr(node, if_key)
1270 pci_addr=InterfaceUtil.pci_to_int(vf_pci_addr),
1272 rxq_num=int(num_rx_queues) if num_rx_queues else 0,
1276 err_msg = f"Failed to create AVF interface on host {node[u'host']}"
1278 # FIXME: Remove once the fw/driver is upgraded.
1280 with PapiSocketExecutor(node) as papi_exec:
1282 sw_if_index = papi_exec.add(cmd, **args).get_sw_if_index(
1286 except AssertionError:
1287 logger.error(err_msg)
1289 raise AssertionError(err_msg)
1291 InterfaceUtil.add_eth_interface(
1292 node, sw_if_index=sw_if_index, ifc_pfx=u"eth_avf",
1296 return Topology.get_interface_by_sw_index(node, sw_if_index)
1299 def vpp_create_af_xdp_interface(
1300 node, if_key, num_rx_queues=None, rxq_size=0, txq_size=0,
1302 """Create AF_XDP interface on VPP node.
1304 :param node: DUT node from topology.
1305 :param if_key: Physical interface key from topology file of interface
1306 to be bound to compatible driver.
1307 :param num_rx_queues: Number of RX queues. (Optional, Default: none)
1308 :param rxq_size: Size of RXQ (0 = Default API; 512 = Default VPP).
1309 :param txq_size: Size of TXQ (0 = Default API; 512 = Default VPP).
1310 :param mode: AF_XDP interface mode. (Optional, Default: auto).
1313 :type num_rx_queues: int
1317 :returns: Interface key (name) in topology file.
1319 :raises RuntimeError: If it is not possible to create AF_XDP interface
1322 PapiSocketExecutor.run_cli_cmd(
1323 node, u"set logging class af_xdp level debug"
1326 cmd = u"af_xdp_create_v3"
1327 pci_addr = Topology.get_interface_pci_addr(node, if_key)
1329 name=InterfaceUtil.pci_to_eth(node, pci_addr),
1330 host_if=InterfaceUtil.pci_to_eth(node, pci_addr),
1331 rxq_num=int(num_rx_queues) if num_rx_queues else 0,
1334 mode=getattr(AfXdpMode, f"AF_XDP_API_MODE_{mode.upper()}").value
1336 err_msg = f"Failed to create AF_XDP interface on host {node[u'host']}"
1337 with PapiSocketExecutor(node) as papi_exec:
1338 sw_if_index = papi_exec.add(cmd, **args).get_sw_if_index(err_msg)
1340 InterfaceUtil.vpp_set_interface_mac(
1341 node, sw_if_index, Topology.get_interface_mac(node, if_key)
1343 InterfaceUtil.add_eth_interface(
1344 node, sw_if_index=sw_if_index, ifc_pfx=u"eth_af_xdp",
1348 return Topology.get_interface_by_sw_index(node, sw_if_index)
1351 def vpp_create_rdma_interface(
1352 node, if_key, num_rx_queues=None, rxq_size=0, txq_size=0,
1354 """Create RDMA interface on VPP node.
1356 :param node: DUT node from topology.
1357 :param if_key: Physical interface key from topology file of interface
1358 to be bound to rdma-core driver.
1359 :param num_rx_queues: Number of RX queues.
1360 :param rxq_size: Size of RXQ (0 = Default API; 512 = Default VPP).
1361 :param txq_size: Size of TXQ (0 = Default API; 512 = Default VPP).
1362 :param mode: RDMA interface mode - auto/ibv/dv.
1365 :type num_rx_queues: int
1369 :returns: Interface key (name) in topology file.
1371 :raises RuntimeError: If it is not possible to create RDMA interface on
1374 PapiSocketExecutor.run_cli_cmd(
1375 node, u"set logging class rdma level debug"
1378 cmd = u"rdma_create_v4"
1379 pci_addr = Topology.get_interface_pci_addr(node, if_key)
1381 name=InterfaceUtil.pci_to_eth(node, pci_addr),
1382 host_if=InterfaceUtil.pci_to_eth(node, pci_addr),
1383 rxq_num=int(num_rx_queues) if num_rx_queues else 0,
1386 mode=getattr(RdmaMode, f"RDMA_API_MODE_{mode.upper()}").value,
1387 # Note: Set True for non-jumbo packets.
1390 # TODO: Apply desired RSS flags.
1391 # rss4 kept 0 (auto) as API default.
1392 # rss6 kept 0 (auto) as API default.
1394 err_msg = f"Failed to create RDMA interface on host {node[u'host']}"
1395 with PapiSocketExecutor(node) as papi_exec:
1396 sw_if_index = papi_exec.add(cmd, **args).get_sw_if_index(err_msg)
1398 InterfaceUtil.vpp_set_interface_mac(
1399 node, sw_if_index, Topology.get_interface_mac(node, if_key)
1401 InterfaceUtil.add_eth_interface(
1402 node, sw_if_index=sw_if_index, ifc_pfx=u"eth_rdma",
1406 return Topology.get_interface_by_sw_index(node, sw_if_index)
1409 def vpp_add_bond_member(node, interface, bond_if):
1410 """Add member interface to bond interface on VPP node.
1412 :param node: DUT node from topology.
1413 :param interface: Physical interface key from topology file.
1414 :param bond_if: Load balance
1416 :type interface: str
1418 :raises RuntimeError: If it is not possible to add member to bond
1419 interface on the node.
1421 cmd = u"bond_add_member"
1423 sw_if_index=Topology.get_interface_sw_index(node, interface),
1424 bond_sw_if_index=Topology.get_interface_sw_index(node, bond_if),
1426 is_long_timeout=False
1428 err_msg = f"Failed to add member {interface} to bond interface " \
1429 f"{bond_if} on host {node[u'host']}"
1430 with PapiSocketExecutor(node) as papi_exec:
1431 papi_exec.add(cmd, **args).get_reply(err_msg)
1434 def vpp_show_bond_data_on_node(node, verbose=False):
1435 """Show (detailed) bond information on VPP node.
1437 :param node: DUT node from topology.
1438 :param verbose: If detailed information is required or not.
1442 cmd = u"sw_bond_interface_dump"
1443 err_msg = f"Failed to get bond interface dump on host {node[u'host']}"
1445 data = f"Bond data on node {node[u'host']}:\n"
1446 with PapiSocketExecutor(node) as papi_exec:
1447 details = papi_exec.add(cmd).get_details(err_msg)
1449 for bond in details:
1450 data += f"{bond[u'interface_name']}\n"
1451 data += u" mode: {m}\n".format(
1452 m=bond[u"mode"].name.replace(u"BOND_API_MODE_", u"").lower()
1454 data += u" load balance: {lb}\n".format(
1455 lb=bond[u"lb"].name.replace(u"BOND_API_LB_ALGO_", u"").lower()
1457 data += f" number of active members: {bond[u'active_members']}\n"
1459 member_data = InterfaceUtil.vpp_bond_member_dump(
1460 node, Topology.get_interface_by_sw_index(
1461 node, bond[u"sw_if_index"]
1464 for member in member_data:
1465 if not member[u"is_passive"]:
1466 data += f" {member[u'interface_name']}\n"
1467 data += f" number of members: {bond[u'members']}\n"
1469 for member in member_data:
1470 data += f" {member[u'interface_name']}\n"
1471 data += f" interface id: {bond[u'id']}\n"
1472 data += f" sw_if_index: {bond[u'sw_if_index']}\n"
1476 def vpp_bond_member_dump(node, interface):
1477 """Get bond interface slave(s) data on VPP node.
1479 :param node: DUT node from topology.
1480 :param interface: Physical interface key from topology file.
1482 :type interface: str
1483 :returns: Bond slave interface data.
1486 cmd = u"sw_member_interface_dump"
1488 sw_if_index=Topology.get_interface_sw_index(node, interface)
1490 err_msg = f"Failed to get slave dump on host {node[u'host']}"
1492 with PapiSocketExecutor(node) as papi_exec:
1493 details = papi_exec.add(cmd, **args).get_details(err_msg)
1495 logger.debug(f"Member data:\n{details}")
1499 def vpp_show_bond_data_on_all_nodes(nodes, verbose=False):
1500 """Show (detailed) bond information on all VPP nodes in DICT__nodes.
1502 :param nodes: Nodes in the topology.
1503 :param verbose: If detailed information is required or not.
1507 for node_data in nodes.values():
1508 if node_data[u"type"] == NodeType.DUT:
1509 InterfaceUtil.vpp_show_bond_data_on_node(node_data, verbose)
1512 def vpp_enable_input_acl_interface(
1513 node, interface, ip_version, table_index):
1514 """Enable input acl on interface.
1516 :param node: VPP node to setup interface for input acl.
1517 :param interface: Interface to setup input acl.
1518 :param ip_version: Version of IP protocol.
1519 :param table_index: Classify table index.
1521 :type interface: str or int
1522 :type ip_version: str
1523 :type table_index: int
1525 cmd = u"input_acl_set_interface"
1527 sw_if_index=InterfaceUtil.get_interface_index(node, interface),
1528 ip4_table_index=table_index if ip_version == u"ip4"
1529 else Constants.BITWISE_NON_ZERO,
1530 ip6_table_index=table_index if ip_version == u"ip6"
1531 else Constants.BITWISE_NON_ZERO,
1532 l2_table_index=table_index if ip_version == u"l2"
1533 else Constants.BITWISE_NON_ZERO,
1535 err_msg = f"Failed to enable input acl on interface {interface}"
1536 with PapiSocketExecutor(node) as papi_exec:
1537 papi_exec.add(cmd, **args).get_reply(err_msg)
1540 def get_interface_classify_table(node, interface):
1541 """Get name of classify table for the given interface.
1543 TODO: Move to Classify.py.
1545 :param node: VPP node to get data from.
1546 :param interface: Name or sw_if_index of a specific interface.
1548 :type interface: str or int
1549 :returns: Classify table name.
1552 if isinstance(interface, str):
1553 sw_if_index = InterfaceUtil.get_sw_if_index(node, interface)
1555 sw_if_index = interface
1557 cmd = u"classify_table_by_interface"
1559 sw_if_index=sw_if_index
1561 err_msg = f"Failed to get classify table name by interface {interface}"
1562 with PapiSocketExecutor(node) as papi_exec:
1563 reply = papi_exec.add(cmd, **args).get_reply(err_msg)
1568 def get_sw_if_index(node, interface_name):
1569 """Get sw_if_index for the given interface from actual interface dump.
1571 FIXME: Delete and redirect callers to vpp_get_interface_sw_index.
1573 :param node: VPP node to get interface data from.
1574 :param interface_name: Name of the specific interface.
1576 :type interface_name: str
1577 :returns: sw_if_index of the given interface.
1580 interface_data = InterfaceUtil.vpp_get_interface_data(
1581 node, interface=interface_name
1583 return interface_data.get(u"sw_if_index")
1586 def vxlan_gpe_dump(node, interface_name=None):
1587 """Get VxLAN GPE data for the given interface.
1589 :param node: VPP node to get interface data from.
1590 :param interface_name: Name of the specific interface. If None,
1591 information about all VxLAN GPE interfaces is returned.
1593 :type interface_name: str
1594 :returns: Dictionary containing data for the given VxLAN GPE interface
1595 or if interface=None, the list of dictionaries with all VxLAN GPE
1597 :rtype: dict or list
1599 def process_vxlan_gpe_dump(vxlan_dump):
1600 """Process vxlan_gpe dump.
1602 :param vxlan_dump: Vxlan_gpe nterface dump.
1603 :type vxlan_dump: dict
1604 :returns: Processed vxlan_gpe interface dump.
1607 if vxlan_dump[u"is_ipv6"]:
1608 vxlan_dump[u"local"] = ip_address(vxlan_dump[u"local"])
1609 vxlan_dump[u"remote"] = ip_address(vxlan_dump[u"remote"])
1611 vxlan_dump[u"local"] = ip_address(vxlan_dump[u"local"][0:4])
1612 vxlan_dump[u"remote"] = ip_address(vxlan_dump[u"remote"][0:4])
1615 if interface_name is not None:
1616 sw_if_index = InterfaceUtil.get_interface_index(
1617 node, interface_name
1620 sw_if_index = int(Constants.BITWISE_NON_ZERO)
1622 cmd = u"vxlan_gpe_tunnel_dump"
1624 sw_if_index=sw_if_index
1626 err_msg = f"Failed to get VXLAN-GPE dump on host {node[u'host']}"
1627 with PapiSocketExecutor(node) as papi_exec:
1628 details = papi_exec.add(cmd, **args).get_details(err_msg)
1630 data = list() if interface_name is None else dict()
1631 for dump in details:
1632 if interface_name is None:
1633 data.append(process_vxlan_gpe_dump(dump))
1634 elif dump[u"sw_if_index"] == sw_if_index:
1635 data = process_vxlan_gpe_dump(dump)
1638 logger.debug(f"VXLAN-GPE data:\n{data}")
1642 def assign_interface_to_fib_table(node, interface, table_id, ipv6=False):
1643 """Assign VPP interface to specific VRF/FIB table.
1645 :param node: VPP node where the FIB and interface are located.
1646 :param interface: Interface to be assigned to FIB.
1647 :param table_id: VRF table ID.
1648 :param ipv6: Assign to IPv6 table. Default False.
1650 :type interface: str or int
1654 cmd = u"sw_interface_set_table"
1656 sw_if_index=InterfaceUtil.get_interface_index(node, interface),
1658 vrf_id=int(table_id)
1660 err_msg = f"Failed to assign interface {interface} to FIB table"
1661 with PapiSocketExecutor(node) as papi_exec:
1662 papi_exec.add(cmd, **args).get_reply(err_msg)
1665 def set_linux_interface_mac(
1666 node, interface, mac, namespace=None, vf_id=None):
1667 """Set MAC address for interface in linux.
1669 :param node: Node where to execute command.
1670 :param interface: Interface in namespace.
1671 :param mac: MAC to be assigned to interface.
1672 :param namespace: Execute command in namespace. Optional
1673 :param vf_id: Virtual Function id. Optional
1675 :type interface: str
1677 :type namespace: str
1680 mac_str = f"vf {vf_id} mac {mac}" if vf_id is not None \
1681 else f"address {mac}"
1682 ns_str = f"ip netns exec {namespace}" if namespace else u""
1684 cmd = f"{ns_str} ip link set {interface} {mac_str}"
1685 exec_cmd_no_error(node, cmd, sudo=True)
1688 def set_linux_interface_promisc(
1689 node, interface, namespace=None, vf_id=None, state=u"on"):
1690 """Set promisc state for interface in linux.
1692 :param node: Node where to execute command.
1693 :param interface: Interface in namespace.
1694 :param namespace: Exec command in namespace. (Optional, Default: None)
1695 :param vf_id: Virtual Function id. (Optional, Default: None)
1696 :param state: State of feature. (Optional, Default: on)
1698 :type interface: str
1699 :type namespace: str
1703 promisc_str = f"vf {vf_id} promisc {state}" if vf_id is not None \
1704 else f"promisc {state}"
1705 ns_str = f"ip netns exec {namespace}" if namespace else u""
1707 cmd = f"{ns_str} ip link set dev {interface} {promisc_str}"
1708 exec_cmd_no_error(node, cmd, sudo=True)
1711 def set_linux_interface_trust_on(
1712 node, interface, namespace=None, vf_id=None):
1713 """Set trust on (promisc) for interface in linux.
1715 :param node: Node where to execute command.
1716 :param interface: Interface in namespace.
1717 :param namespace: Execute command in namespace. Optional
1718 :param vf_id: Virtual Function id. Optional
1720 :type interface: str
1721 :type namespace: str
1724 trust_str = f"vf {vf_id} trust on" if vf_id is not None else u"trust on"
1725 ns_str = f"ip netns exec {namespace}" if namespace else u""
1727 cmd = f"{ns_str} ip link set dev {interface} {trust_str}"
1728 exec_cmd_no_error(node, cmd, sudo=True)
1731 def set_linux_interface_spoof_off(
1732 node, interface, namespace=None, vf_id=None):
1733 """Set spoof off for interface in linux.
1735 :param node: Node where to execute command.
1736 :param interface: Interface in namespace.
1737 :param namespace: Execute command in namespace. Optional
1738 :param vf_id: Virtual Function id. Optional
1740 :type interface: str
1741 :type namespace: str
1744 spoof_str = f"vf {vf_id} spoof off" if vf_id is not None \
1746 ns_str = f"ip netns exec {namespace}" if namespace else u""
1748 cmd = f"{ns_str} ip link set dev {interface} {spoof_str}"
1749 exec_cmd_no_error(node, cmd, sudo=True)
1752 def set_linux_interface_state(
1753 node, interface, namespace=None, state=u"up"):
1754 """Set operational state for interface in linux.
1756 :param node: Node where to execute command.
1757 :param interface: Interface in namespace.
1758 :param namespace: Execute command in namespace. Optional
1759 :param state: Up/Down.
1761 :type interface: str
1762 :type namespace: str
1765 ns_str = f"ip netns exec {namespace}" if namespace else u""
1767 cmd = f"{ns_str} ip link set dev {interface} {state}"
1768 exec_cmd_no_error(node, cmd, sudo=True)
1771 def init_interface(node, ifc_key, driver, numvfs=0, osi_layer=u"L2"):
1772 """Init PCI device. Check driver compatibility and bind to proper
1773 drivers. Optionally create NIC VFs.
1775 :param node: DUT node.
1776 :param ifc_key: Interface key from topology file.
1777 :param driver: Base driver to use.
1778 :param numvfs: Number of VIFs to initialize, 0 - disable the VIFs.
1779 :param osi_layer: OSI Layer type to initialize TG with.
1780 Default value "L2" sets linux interface spoof off.
1785 :type osi_layer: str
1786 :returns: Virtual Function topology interface keys.
1788 :raises RuntimeError: If a reason preventing initialization is found.
1790 kernel_driver = Topology.get_interface_driver(node, ifc_key)
1792 if driver == u"avf":
1793 if kernel_driver not in (
1794 u"ice", u"iavf", u"i40e", u"i40evf"):
1796 f"AVF needs ice or i40e compatible driver, not "
1797 f"{kernel_driver} at node {node[u'host']} ifc {ifc_key}"
1799 vf_keys = InterfaceUtil.init_generic_interface(
1800 node, ifc_key, numvfs=numvfs, osi_layer=osi_layer
1802 elif driver == u"af_xdp":
1803 if kernel_driver not in (
1804 u"ice", u"iavf", u"i40e", u"i40evf", u"mlx5_core",
1807 f"AF_XDP needs ice/i40e/rdma/ixgbe compatible driver, not "
1808 f"{kernel_driver} at node {node[u'host']} ifc {ifc_key}"
1810 vf_keys = InterfaceUtil.init_generic_interface(
1811 node, ifc_key, numvfs=numvfs, osi_layer=osi_layer
1813 elif driver == u"rdma-core":
1814 vf_keys = InterfaceUtil.init_generic_interface(
1815 node, ifc_key, numvfs=numvfs, osi_layer=osi_layer
1820 def init_generic_interface(node, ifc_key, numvfs=0, osi_layer=u"L2"):
1821 """Init PCI device. Bind to proper drivers. Optionally create NIC VFs.
1823 :param node: DUT node.
1824 :param ifc_key: Interface key from topology file.
1825 :param numvfs: Number of VIFs to initialize, 0 - disable the VIFs.
1826 :param osi_layer: OSI Layer type to initialize TG with.
1827 Default value "L2" sets linux interface spoof off.
1831 :type osi_layer: str
1832 :returns: Virtual Function topology interface keys.
1834 :raises RuntimeError: If a reason preventing initialization is found.
1836 # Read PCI address and driver.
1837 pf_pci_addr = Topology.get_interface_pci_addr(node, ifc_key)
1838 pf_mac_addr = Topology.get_interface_mac(node, ifc_key).split(":")
1839 uio_driver = Topology.get_uio_driver(node)
1840 kernel_driver = Topology.get_interface_driver(node, ifc_key)
1841 current_driver = DUTSetup.get_pci_dev_driver(
1842 node, pf_pci_addr.replace(u":", r"\:"))
1843 pf_dev = f"`basename /sys/bus/pci/devices/{pf_pci_addr}/net/*`"
1845 VPPUtil.stop_vpp_service(node)
1846 if current_driver != kernel_driver:
1847 # PCI device must be re-bound to kernel driver before creating VFs.
1848 DUTSetup.verify_kernel_module(node, kernel_driver, force_load=True)
1849 # Stop VPP to prevent deadlock.
1850 # Unbind from current driver if bound.
1852 DUTSetup.pci_driver_unbind(node, pf_pci_addr)
1853 # Bind to kernel driver.
1854 DUTSetup.pci_driver_bind(node, pf_pci_addr, kernel_driver)
1856 # Initialize PCI VFs.
1857 DUTSetup.set_sriov_numvfs(node, pf_pci_addr, numvfs=numvfs)
1860 if osi_layer == u"L2":
1861 InterfaceUtil.set_linux_interface_promisc(node, pf_dev)
1864 # Set MAC address and bind each virtual function to uio driver.
1865 for vf_id in range(numvfs):
1866 vf_mac_addr = u":".join(
1867 [pf_mac_addr[0], pf_mac_addr[2], pf_mac_addr[3], pf_mac_addr[4],
1868 pf_mac_addr[5], f"{vf_id:02x}"
1872 InterfaceUtil.set_linux_interface_trust_on(
1873 node, pf_dev, vf_id=vf_id
1875 if osi_layer == u"L2":
1876 InterfaceUtil.set_linux_interface_spoof_off(
1877 node, pf_dev, vf_id=vf_id
1879 InterfaceUtil.set_linux_interface_mac(
1880 node, pf_dev, vf_mac_addr, vf_id=vf_id
1882 InterfaceUtil.set_linux_interface_state(
1883 node, pf_dev, state=u"up"
1886 vf_pci_addr = DUTSetup.get_virtfn_pci_addr(node, pf_pci_addr, vf_id)
1887 current_driver = DUTSetup.get_pci_dev_driver(
1888 node, vf_pci_addr.replace(":", r"\:")
1891 DUTSetup.pci_vf_driver_unbind(
1892 node, pf_pci_addr, vf_id
1894 DUTSetup.pci_vf_driver_bind(
1895 node, pf_pci_addr, vf_id, uio_driver
1898 # Add newly created ports into topology file
1899 vf_ifc_name = f"{ifc_key}_vif"
1900 vf_ifc_key = Topology.add_new_port(node, vf_ifc_name)
1901 Topology.update_interface_name(
1902 node, vf_ifc_key, vf_ifc_name+str(vf_id+1)
1904 Topology.update_interface_mac_address(node, vf_ifc_key, vf_mac_addr)
1905 Topology.update_interface_pci_address(node, vf_ifc_key, vf_pci_addr)
1906 Topology.set_interface_numa_node(
1907 node, vf_ifc_key, Topology.get_interface_numa_node(
1911 vf_ifc_keys.append(vf_ifc_key)
1916 def vpp_sw_interface_rx_placement_dump(node):
1917 """Dump VPP interface RX placement on node.
1919 :param node: Node to run command on.
1921 :returns: Thread mapping information as a list of dictionaries.
1924 cmd = u"sw_interface_rx_placement_dump"
1925 err_msg = f"Failed to run '{cmd}' PAPI command on host {node[u'host']}!"
1926 with PapiSocketExecutor(node) as papi_exec:
1927 for ifc in node[u"interfaces"].values():
1928 if ifc[u"vpp_sw_index"] is not None:
1929 papi_exec.add(cmd, sw_if_index=ifc[u"vpp_sw_index"])
1930 details = papi_exec.get_details(err_msg)
1931 return sorted(details, key=lambda k: k[u"sw_if_index"])
1934 def vpp_sw_interface_rx_placement_dump_on_all_duts(nodes):
1935 """Dump VPP interface RX placement on all given nodes.
1937 :param nodes: Nodes to run command on.
1939 :returns: Thread mapping information as a list of dictionaries.
1942 for node in nodes.values():
1943 if node[u"type"] == NodeType.DUT:
1944 InterfaceUtil.vpp_sw_interface_rx_placement_dump(node)
1947 def vpp_sw_interface_set_rx_placement(
1948 node, sw_if_index, queue_id, worker_id):
1949 """Set interface RX placement to worker on node.
1951 :param node: Node to run command on.
1952 :param sw_if_index: VPP SW interface index.
1953 :param queue_id: VPP interface queue ID.
1954 :param worker_id: VPP worker ID (indexing from 0).
1956 :type sw_if_index: int
1958 :type worker_id: int
1959 :raises RuntimeError: If failed to run command on host or if no API
1962 cmd = u"sw_interface_set_rx_placement"
1963 err_msg = f"Failed to set interface RX placement to worker " \
1964 f"on host {node[u'host']}!"
1966 sw_if_index=sw_if_index,
1968 worker_id=worker_id,
1971 with PapiSocketExecutor(node) as papi_exec:
1972 papi_exec.add(cmd, **args).get_reply(err_msg)
1975 def vpp_round_robin_rx_placement(
1976 node, prefix, workers=None):
1977 """Set Round Robin interface RX placement on all worker threads
1980 If specified, workers limits the number of physical cores used
1981 for data plane I/O work. Other cores are presumed to do something else,
1982 e.g. asynchronous crypto processing.
1983 None means all workers are used for data plane work.
1985 :param node: Topology nodes.
1986 :param prefix: Interface name prefix.
1987 :param workers: Comma separated worker index numbers intended for
1993 thread_data = VPPUtil.vpp_show_threads(node)
1994 worker_cnt = len(thread_data) - 1
1999 for item in thread_data:
2000 if str(item.cpu_id) in workers.split(u","):
2001 worker_ids.append(item.id)
2003 for item in thread_data:
2004 if u"vpp_main" not in item.name:
2005 worker_ids.append(item.id)
2008 for placement in InterfaceUtil.vpp_sw_interface_rx_placement_dump(node):
2009 for interface in node[u"interfaces"].values():
2010 if placement[u"sw_if_index"] == interface[u"vpp_sw_index"] \
2011 and prefix in interface[u"name"]:
2012 InterfaceUtil.vpp_sw_interface_set_rx_placement(
2013 node, placement[u"sw_if_index"], placement[u"queue_id"],
2014 worker_ids[worker_idx % len(worker_ids)] - 1
2019 def vpp_round_robin_rx_placement_on_all_duts(
2020 nodes, prefix, use_dp_cores=False):
2021 """Set Round Robin interface RX placement on worker threads
2024 If specified, workers limits the number of physical cores used
2025 for data plane I/O work. Other cores are presumed to do something else,
2026 e.g. asynchronous crypto processing.
2027 None means all cores are used for data plane work.
2029 :param nodes: Topology nodes.
2030 :param prefix: Interface name prefix.
2031 :param use_dp_cores: Limit to dataplane cores.
2034 :type use_dp_cores: bool
2036 for node_name, node in nodes.items():
2037 if node["type"] == NodeType.DUT:
2040 workers = BuiltIn().get_variable_value(
2041 f"${{{node_name}_cpu_dp}}"
2043 InterfaceUtil.vpp_round_robin_rx_placement(
2044 node, prefix, workers