From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mails.dpdk.org (mails.dpdk.org [217.70.189.124]) by inbox.dpdk.org (Postfix) with ESMTP id 156A645A12; Mon, 23 Sep 2024 20:43:28 +0200 (CEST) Received: from mails.dpdk.org (localhost [127.0.0.1]) by mails.dpdk.org (Postfix) with ESMTP id D837D4064A; Mon, 23 Sep 2024 20:42:59 +0200 (CEST) Received: from mail-il1-f228.google.com (mail-il1-f228.google.com [209.85.166.228]) by mails.dpdk.org (Postfix) with ESMTP id 133EE40608 for ; Mon, 23 Sep 2024 20:42:57 +0200 (CEST) Received: by mail-il1-f228.google.com with SMTP id e9e14a558f8ab-3a0cdd77dbeso9438995ab.2 for ; Mon, 23 Sep 2024 11:42:57 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=iol.unh.edu; s=unh-iol; t=1727116976; x=1727721776; darn=dpdk.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=a83cvxp67ZIRrEOBil2F0eDUK9GDuaqDP0wR+nzvNIQ=; b=YX4pDWtHFyrT41ISXOxS3P33bB14fRf1U9UBlLX72rKcydodAsWuMTqt034Jc0SPRR tA2Mmhd+3mNNQHyi3y8Jx+retxNOoSKwhLhGwiNRLYDDtpqNaHZRkikJ7qNo0EbgzPIG LeX17gHzGGZ3s5gPNGGCIdrC3H7zEm0yuHM08= X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1727116976; x=1727721776; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=a83cvxp67ZIRrEOBil2F0eDUK9GDuaqDP0wR+nzvNIQ=; b=fMP26fG9Li7SJ9J+ViMyHVy6mSPFmJFDHFFztl3QctWTphTIST40BnSCAp5+ha3xbZ ufuHFQSLXrAQRbv1Jlvhr9jTY9OVT7eE1zZa4m2Y1bEhu1FDmUyGwKSnRwM+db4rGBcN vb49lLrwzMsKv7wiILMd8YkXNGf9g6Ytv6AkhV0L34yJ17iaaBfvk5gHLVVaqI9UiN2T qgDlJFFrfYF9eVQumg2tyr6YDLIdi2AGXE1NwCwaTR9mri+96nbD336+gxAfa4mcjGs7 Nr90HA4ag6TduAkTpButohszM5Pjbw94kAGIbfwXv/miskm8KCnh7vUKeIIspV4yFk/6 N27g== X-Gm-Message-State: AOJu0YwEkAe+fERASyTZHHTZizXdQSgPI4yyXzdI+sApuFr6//gub7Wy CBo1hYKgv2GW9k+nxIDsw+NCFWHQHZaOKW7mX8H7HgzU6I52LKnzNkqFJBpJgkm1ec23o0veXob VizuXW4gMbp8aA6ll1WHFllCPMt3qPA2+B1GOorwCWzoPioxS X-Google-Smtp-Source: AGHT+IERw64q/6HWxx77R8gmxuamig3YWLg9xH1zTGxMPwOVq0WxObOBizLzMItppROueCylWK3nK1qvdCdv X-Received: by 2002:a05:6e02:1c04:b0:3a0:a0bd:f92b with SMTP id e9e14a558f8ab-3a0c9d251e7mr111127185ab.10.1727116976230; Mon, 23 Sep 2024 11:42:56 -0700 (PDT) Received: from postal.iol.unh.edu (postal.iol.unh.edu. [2606:4100:3880:1234::84]) by smtp-relay.gmail.com with ESMTPS id e9e14a558f8ab-3a193732a8esm3061075ab.28.2024.09.23.11.42.55 (version=TLS1_2 cipher=ECDHE-ECDSA-AES128-GCM-SHA256 bits=128/128); Mon, 23 Sep 2024 11:42:56 -0700 (PDT) X-Relaying-Domain: iol.unh.edu Received: from iol.unh.edu (unknown [IPv6:2606:4100:3880:1257::1083]) by postal.iol.unh.edu (Postfix) with ESMTP id 0B612605C351; Mon, 23 Sep 2024 14:42:55 -0400 (EDT) From: jspewock@iol.unh.edu To: npratte@iol.unh.edu, juraj.linkes@pantheon.tech, yoan.picchi@foss.arm.com, thomas@monjalon.net, Honnappa.Nagarahalli@arm.com, probb@iol.unh.edu, wathsala.vithanage@arm.com, paul.szczepanek@arm.com, Luca.Vizzarro@arm.com, alex.chapman@arm.com Cc: dev@dpdk.org, Jeremy Spewock Subject: [PATCH v4 5/5] dts: add functions for managing VFs to Node Date: Mon, 23 Sep 2024 14:42:35 -0400 Message-ID: <20240923184235.22582-6-jspewock@iol.unh.edu> X-Mailer: git-send-email 2.46.0 In-Reply-To: <20240923184235.22582-1-jspewock@iol.unh.edu> References: <20240821191557.18744-1-jspewock@iol.unh.edu> <20240923184235.22582-1-jspewock@iol.unh.edu> MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: DPDK patches and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dev-bounces@dpdk.org From: Jeremy Spewock In order for test suites to create virtual functions there has to be functions in the API that developers can use. This patch adds the ability to create virtual functions to the Node API so that they are reachable within test suites. Bugzilla ID: 1500 Depends-on: patch-144318 ("dts: add binding to different drivers to TG node") Signed-off-by: Jeremy Spewock --- dts/framework/testbed_model/node.py | 97 ++++++++++++++++++++++++++++- 1 file changed, 94 insertions(+), 3 deletions(-) diff --git a/dts/framework/testbed_model/node.py b/dts/framework/testbed_model/node.py index 106e189ce3..d9b6ee040b 100644 --- a/dts/framework/testbed_model/node.py +++ b/dts/framework/testbed_model/node.py @@ -13,7 +13,7 @@ The :func:`~Node.skip_setup` decorator can be used without subclassing. """ - +import re from abc import ABC, abstractmethod from ipaddress import IPv4Interface, IPv6Interface from pathlib import PurePath @@ -23,9 +23,10 @@ OS, BuildTargetConfiguration, NodeConfiguration, + PortConfig, TestRunConfiguration, ) -from framework.exception import ConfigurationError +from framework.exception import ConfigurationError, InternalError from framework.logger import DTSLogger, get_dts_logger from framework.settings import SETTINGS @@ -38,7 +39,7 @@ ) from .linux_session import LinuxSession from .os_session import OSSession -from .port import Port +from .port import Port, VirtualFunction class Node(ABC): @@ -276,6 +277,96 @@ def _bind_port_to_driver(self, port: Port, for_dpdk: bool = True) -> None: verify=True, ) + def create_virtual_functions( + self, num: int, pf_port: Port, dpdk_driver: str | None = None + ) -> list[VirtualFunction]: + """Create virtual functions (VFs) from a given physical function (PF) on the node. + + Virtual functions will be created if there are not any currently configured on `pf_port`. + If there are greater than or equal to `num` VFs already configured on `pf_port`, those will + be used instead of creating more. In order to create VFs, the PF must be bound to its + kernel driver. This method will handle binding `pf_port` and any other ports in the test + run that reside on the same device back to their OS drivers if this was not done already. + VFs gathered in this method will be bound to `driver` if one is provided, or the DPDK + driver for `pf_port` and then added to `self.ports`. + + Args: + num: The number of VFs to create. Must be greater than 0. + pf_port: The PF to create the VFs on. + dpdk_driver: Optional driver to bind the VFs to after they are created. Defaults to the + DPDK driver of `pf_port`. + + Raises: + InternalError: If `num` is less than or equal to 0. + """ + if num <= 0: + raise InternalError( + "Method for creating virtual functions received a non-positive value." + ) + if not dpdk_driver: + dpdk_driver = pf_port.os_driver_for_dpdk + # Get any other port that is on the same device which DTS is aware of + all_device_ports = [ + p for p in self.ports if p.pci.split(".")[0] == pf_port.pci.split(".")[0] + ] + # Ports must be bound to the kernel driver in order to create VFs from them + for port in all_device_ports: + self._bind_port_to_driver(port, False) + # Some PMDs require the interface being up in order to make VFs + self.configure_port_state(port) + created_vfs = self.main_session.set_num_virtual_functions(num, pf_port) + # We don't need more then `num` VFs from the list + vf_pcis = self.main_session.get_pci_addr_of_vfs(pf_port)[:num] + devbind_info = self.main_session.send_command( + f"{self.path_to_devbind_script} -s", privileged=True + ).stdout + + ret = [] + + for pci in vf_pcis: + original_driver = re.search(f"{pci}.*drv=([\\d\\w-]*)", devbind_info) + os_driver = original_driver[1] if original_driver else pf_port.os_driver + vf_config = PortConfig( + self.name, pci, dpdk_driver, os_driver, pf_port.peer.node, pf_port.peer.pci + ) + vf_port = VirtualFunction(self.name, vf_config, created_vfs, pf_port) + self.main_session.update_ports([vf_port]) + self._bind_port_to_driver(vf_port) + self.ports.append(vf_port) + ret.append(vf_port) + return ret + + def get_vfs_on_port(self, pf_port: Port) -> list[VirtualFunction]: + """Get all virtual functions (VFs) that DTS is aware of on `pf_port`. + + Args: + pf_port: The port to search for the VFs on. + + Returns: + A list of VFs in the framework that were created/gathered from `pf_port`. + """ + return [p for p in self.ports if isinstance(p, VirtualFunction) and p.pf_port == pf_port] + + def remove_virtual_functions(self, pf_port: Port) -> None: + """Removes all virtual functions (VFs) created on `pf_port` by DTS. + + Finds all the VFs that were created from `pf_port` and either removes them if they were + created by the DTS framework or binds them back to their os_driver if they were preexisting + on the node. + + Args: + pf_port: Port to remove the VFs from. + """ + vf_ports = self.get_vfs_on_port(pf_port) + if any(vf.created_by_framework for vf in vf_ports): + self.main_session.set_num_virtual_functions(0, pf_port) + else: + self._logger.info("Skipping removing VFs since they were not created by DTS.") + # Bind all VFs that we are no longer using back to their original driver + for vf in vf_ports: + self._bind_port_to_driver(vf, for_dpdk=False) + self.ports = [p for p in self.ports if p not in vf_ports] + def create_session(node_config: NodeConfiguration, name: str, logger: DTSLogger) -> OSSession: """Factory for OS-aware sessions. -- 2.46.0