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 EDA1C45527; Fri, 28 Jun 2024 19:33:26 +0200 (CEST) Received: from mails.dpdk.org (localhost [127.0.0.1]) by mails.dpdk.org (Postfix) with ESMTP id 0482F42DDF; Fri, 28 Jun 2024 19:33:09 +0200 (CEST) Received: from mail-io1-f100.google.com (mail-io1-f100.google.com [209.85.166.100]) by mails.dpdk.org (Postfix) with ESMTP id 9D0E842E36 for ; Fri, 28 Jun 2024 19:33:05 +0200 (CEST) Received: by mail-io1-f100.google.com with SMTP id ca18e2360f4ac-7ea0b5e0977so28156539f.2 for ; Fri, 28 Jun 2024 10:33:05 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=iol.unh.edu; s=unh-iol; t=1719595985; x=1720200785; 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=aQpDJZjirJh6g+pdqSl5k7pLwn0n6C51dgGgb7blIGs=; b=FNCP2yCEcjoc1W0LoPJCbNBZtDlQgIzrBWYr/NDermlIB/jy78UceiJHjPwu0zZ4Fh 8VWzpgc9gkvPz8Zu57rKJVavcyXED/ST8BPQAdTrScsvmaFiqe3d9x/RBiF47jlAiGJm Ssbv7ms1G5Jhpp/aSuSI9PA4F/j3q5FQnVHY8= X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1719595985; x=1720200785; 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=aQpDJZjirJh6g+pdqSl5k7pLwn0n6C51dgGgb7blIGs=; b=iECFls2EcGdYlqsoKdITA5APf+zbm+b0RnNvkCffu9WtTLnERxHNmxKdKMRK0YykvD +dcirz4PzxEGLqMfhCdfwWrNbATkPsYikza1yD4qWoJD5S7PCeITj4MuCe5uGdXgAqvG vZHvh80qk81+o8aLwsR3ZHMToR12SiN2dF3EdotmXzSUXShv9rY0w8/iLKgbLGkR7795 cdtAppP3pMbbYNWrkflGXPYFnxEWjdPeS1D8xRkUdwfJFiNyTcs5Wdm71l1kiRHbAH8+ PhA2tBLSoVR5vYjeviT6Ra5Q/yUi+lQh3QITpV4g28k7t89UT1rEXbh3f/nY1jxkx51g mJOw== X-Gm-Message-State: AOJu0YxYOfekjY1o9cp6NH/NVldPj2luUL/EqF26QxSYUBdMOKTgAyEP XfVNxGLqtRrzgcIukxT82hRf7xkmpXoTzZTVfVCd9gh+6bsspX78j+udjMaheXXYHsV5CQCH9ML 6Ikw6B05eSeUAqlEQVLrYWCi0xJGRGYgWwVqfSoU92p/wkWfG X-Google-Smtp-Source: AGHT+IFbmiye79f7sAH3trfpfBrf5An4a99x6YL0pNJJnYk5n9yGzLOaR92bAQJsdMUCeGzuoSNQAjwtlO/R X-Received: by 2002:a05:6602:6b12:b0:7f3:d2bb:790c with SMTP id ca18e2360f4ac-7f3d2bb7b98mr1039901839f.7.1719595985016; Fri, 28 Jun 2024 10:33:05 -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 8926c6da1cb9f-4bb73fcbfdbsm62465173.64.2024.06.28.10.33.04 (version=TLS1_2 cipher=ECDHE-ECDSA-AES128-GCM-SHA256 bits=128/128); Fri, 28 Jun 2024 10:33:05 -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 EFC42605C374; Fri, 28 Jun 2024 13:33:03 -0400 (EDT) From: jspewock@iol.unh.edu To: paul.szczepanek@arm.com, npratte@iol.unh.edu, juraj.linkes@pantheon.tech, wathsala.vithanage@arm.com, Honnappa.Nagarahalli@arm.com, yoan.picchi@foss.arm.com, thomas@monjalon.net, Luca.Vizzarro@arm.com, probb@iol.unh.edu Cc: dev@dpdk.org, Jeremy Spewock Subject: [PATCH v6 3/4] dts: add methods for modifying MTU to testpmd shell Date: Fri, 28 Jun 2024 13:32:31 -0400 Message-ID: <20240628173232.22906-4-jspewock@iol.unh.edu> X-Mailer: git-send-email 2.45.2 In-Reply-To: <20240628173232.22906-1-jspewock@iol.unh.edu> References: <20240514201436.2496-1-jspewock@iol.unh.edu> <20240628173232.22906-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 There are methods within DTS currently that support updating the MTU of ports on a node, but the methods for doing this in a linux session rely on the ip command and the port being bound to the kernel driver. Since test suites are run while bound to the driver for DPDK, there needs to be a way to modify the value while bound to said driver as well. This is done by using testpmd to modify the MTU. Signed-off-by: Jeremy Spewock --- In this verion the decorator function was swapped out for a decorator class for what I feel is slihtly more readable syntax for decorators taking in parameters of their own. Additionally, I replaced the "Any" with a TypeVarTuple to provide a better type signature for methods that are decorated by this class. The TypeVarTuple isn't support in mypy yet, but the functionality of enforcing the first two parameters are the types we want them to be and then essentially not caring about the rest is still functional. The main downside of using the TypeVarTuple over something like a ParamSpec is the loss of the key-word arguments and parameter names in the type the is returned. This tradeoff seems worth it to me since in losing that allows us to catch typing problems early rather than at runtime. dts/framework/remote_session/testpmd_shell.py | 132 +++++++++++++++++- 1 file changed, 131 insertions(+), 1 deletion(-) diff --git a/dts/framework/remote_session/testpmd_shell.py b/dts/framework/remote_session/testpmd_shell.py index 805bb3a77d..b4b77dd399 100644 --- a/dts/framework/remote_session/testpmd_shell.py +++ b/dts/framework/remote_session/testpmd_shell.py @@ -22,6 +22,8 @@ from pathlib import PurePath from typing import Callable, ClassVar +from typing_extensions import TypeVarTuple + from framework.exception import InteractiveCommandExecutionError from framework.settings import SETTINGS from framework.utils import StrEnum @@ -82,12 +84,83 @@ class TestPmdForwardingModes(StrEnum): recycle_mbufs = auto() +T = TypeVarTuple("T") # type: ignore[misc] + + +class stop_then_start_port: + """Decorator that stops a port, runs decorated function, then starts the port. + + The function being decorated must be a method defined in :class:`TestPmdShell` that takes a + port ID (as an int) as its first parameter. The port ID will be passed into + :meth:`~TestPmdShell._stop_port` and :meth:`~TestPmdShell._start_port` so that the correct port + is stopped/started. + + Note that, because this decorator is presented through a class to allow for passing arguments + into the decorator, the class must be initialized when decorating functions. This means that, + even when not modifying any arguments, the signature for decorating with this class must be + "@stop_then_start_port()". + + Example usage on testpmd methods:: + + @stop_then_start_port() + def ex1(self, port_id, verify=True) + pass + + @stop_then_start_port(verify=False) + def ex2(self, port_id, verify=True) + pass + + Attributes: + verify: Whether to verify the stopping and starting of the port. + """ + + verify: bool + + def __init__(self, verify: bool = True) -> None: + """Store decorator options. + + Args: + verify: If :data:`True` the stopping/starting of ports will be verified, otherwise they + will it won't. Defaults to :data:`True`. + """ + self.verify = verify + + def __call__( + self, func: Callable[["TestPmdShell", int, *T], None] # type: ignore[valid-type] + ) -> Callable[["TestPmdShell", int, *T], None]: # type: ignore[valid-type] + """Wrap decorated method. + + Args: + func: Decorated method to wrap. + + Returns: + Function that stops a port, runs the decorated method, then starts the port. + """ + + def wrapper(shell: "TestPmdShell", port_id: int, *args, **kwargs) -> None: + """Function that wraps the instance method of :class:`TestPmdShell`. + + Args: + shell: Instance of the shell containing the method to decorate. + port_id: ID of the port to stop/start. + """ + print(f"verify is {self.verify}") + shell._stop_port(port_id, self.verify) + func(shell, port_id, *args, **kwargs) + shell._start_port(port_id, self.verify) + + return wrapper + + class TestPmdShell(SingleActiveInteractiveShell): """Testpmd interactive shell. The testpmd shell users should never use the :meth:`~.interactive_shell.InteractiveShell.send_command` method directly, but rather - call specialized methods. If there isn't one that satisfies a need, it should be added. + call specialized methods. If there isn't one that satisfies a need, it should be added. Methods + of this class can be optionally decorated by :func:`~stop_then_start_port` if their first + parameter is the ID of a port in testpmd. This decorator will stop the port before running the + method and then start it again once the method is finished. Attributes: number_of_ports: The number of ports which were allowed on the command-line when testpmd @@ -227,6 +300,63 @@ def set_forward_mode(self, mode: TestPmdForwardingModes, verify: bool = True): f"Test pmd failed to set fwd mode to {mode.value}" ) + def _stop_port(self, port_id: int, verify: bool = True) -> None: + """Stop port with `port_id` in testpmd. + + Depending on the PMD, the port may need to be stopped before configuration can take place. + This method wraps the command needed to properly stop ports and take their link down. + + Raises: + InteractiveCommandExecutionError: If `verify` is :data:`True` and the port did not + successfully stop. + """ + stop_port_output = self.send_command(f"port stop {port_id}") + if verify and ("Done" not in stop_port_output): + self._logger.debug(f"Failed to stop port {port_id}. Output was:\n{stop_port_output}") + raise InteractiveCommandExecutionError(f"Test pmd failed to stop port {port_id}.") + + def _start_port(self, port_id: int, verify: bool = True) -> None: + """Start port with `port_id` in testpmd. + + Because the port may need to be stopped to make some configuration changes, it naturally + follows that it will need to be started again once those changes have been made. + + Raises: + InteractiveCommandExecutionError: If `verify` is :data:`True` and the port did not come + back up. + """ + start_port_output = self.send_command(f"port start {port_id}") + if verify and ("Done" not in start_port_output): + self._logger.debug(f"Failed to start port {port_id}. Output was:\n{start_port_output}") + raise InteractiveCommandExecutionError(f"Test pmd failed to start port {port_id}.") + + @stop_then_start_port() + def set_port_mtu(self, port_id: int, mtu: int, verify: bool = True) -> None: + """Change the MTU of a port using testpmd. + + Some PMDs require that the port be stopped before changing the MTU, and it does no harm to + stop the port before configuring in cases where it isn't required, so we first stop ports, + then update the MTU, then start the ports again afterwards. + + Args: + port_id: ID of the port to adjust the MTU on. + mtu: Desired value for the MTU to be set to. + verify: If `verify` is :data:`True` then the output will be scanned in an attempt to + verify that the mtu was properly set on the port. Defaults to :data:`True`. + + Raises: + InteractiveCommandExecutionError: If `verify` is :data:`True` and the MTU was not + properly updated on the port matching `port_id`. + """ + set_mtu_output = self.send_command(f"port config mtu {port_id} {mtu}") + if verify and (f"MTU: {mtu}" not in self.send_command(f"show port info {port_id}")): + self._logger.debug( + f"Failed to set mtu to {mtu} on port {port_id}." f" Output was:\n{set_mtu_output}" + ) + raise InteractiveCommandExecutionError( + f"Test pmd failed to update mtu of port {port_id} to {mtu}" + ) + def _close(self) -> None: """Overrides :meth:`~.interactive_shell.close`.""" self.stop() -- 2.45.2