* [PATCH v1 2/3] dts: add reception check to checksum offload suite [not found] <20250902114327.48185-1-abailey@iol.unh.edu> @ 2025-09-02 11:43 ` Andrew Bailey 2025-09-02 11:43 ` [PATCH v1 3/3] dts: all are one Andrew Bailey ` (4 subsequent siblings) 5 siblings, 0 replies; 22+ messages in thread From: Andrew Bailey @ 2025-09-02 11:43 UTC (permalink / raw) To: luca.vizzarro; +Cc: abailey, dev, dmarx, probb From: Dean Marx <dmarx@iol.unh.edu> In the current implementation of Checksum Offload, the variables is_L4 and is_IP are not initialized outside of the loop that checks the received packet, so if the packet is dropped these variables cause a NameError in the verification steps. Add a line that sets these variables to None prior to the check, then verifies they are not None directly after. Fixes: 8c9a7471a0e6 ("dts: add checksum offload test suite") Signed-off-by: Dean Marx <dmarx@iol.unh.edu> Reviewed-by: Patrick Robb <probb@iol.unh.edu> Reviewed-by: Luca Vizzarro <luca.vizzarro@arm.com> --- dts/tests/TestSuite_checksum_offload.py | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/dts/tests/TestSuite_checksum_offload.py b/dts/tests/TestSuite_checksum_offload.py index b03c3d46ed..d411af70a9 100644 --- a/dts/tests/TestSuite_checksum_offload.py +++ b/dts/tests/TestSuite_checksum_offload.py @@ -85,10 +85,15 @@ def send_packet_and_verify_checksum( testpmd.start() self.send_packet_and_capture(packet=packet) verbose_output = testpmd.extract_verbose_output(testpmd.stop()) + is_IP = is_L4 = None for testpmd_packet in verbose_output: if testpmd_packet.l4_dport == id: is_IP = PacketOffloadFlag.RTE_MBUF_F_RX_IP_CKSUM_GOOD in testpmd_packet.ol_flags is_L4 = PacketOffloadFlag.RTE_MBUF_F_RX_L4_CKSUM_GOOD in testpmd_packet.ol_flags + self.verify( + is_IP is not None and is_L4 is not None, + "Test packet was dropped when it should have been received.", + ) self.verify(is_L4 == good_L4, "Layer 4 checksum flag did not match expected checksum flag.") self.verify(is_IP == good_IP, "IP checksum flag did not match expected checksum flag.") -- 2.50.1 ^ permalink raw reply related [flat|nested] 22+ messages in thread
* [PATCH v1 3/3] dts: all are one [not found] <20250902114327.48185-1-abailey@iol.unh.edu> 2025-09-02 11:43 ` [PATCH v1 2/3] dts: add reception check to checksum offload suite Andrew Bailey @ 2025-09-02 11:43 ` Andrew Bailey 2025-09-02 11:48 ` [PATCH v1 0/3] dts: add tx_offload support in dts Andrew Bailey ` (3 subsequent siblings) 5 siblings, 0 replies; 22+ messages in thread From: Andrew Bailey @ 2025-09-02 11:43 UTC (permalink / raw) To: luca.vizzarro; +Cc: abailey, dev, dmarx, probb --- dts/framework/remote_session/testpmd_shell.py | 342 +++++++++++++++++- dts/tests/TestSuite_rxtx_offload.py | 153 ++++++++ 2 files changed, 493 insertions(+), 2 deletions(-) create mode 100644 dts/tests/TestSuite_rxtx_offload.py diff --git a/dts/framework/remote_session/testpmd_shell.py b/dts/framework/remote_session/testpmd_shell.py index ad8cb273dc..2867fbce7a 100644 --- a/dts/framework/remote_session/testpmd_shell.py +++ b/dts/framework/remote_session/testpmd_shell.py @@ -19,7 +19,7 @@ import time from collections.abc import Callable, MutableSet from dataclasses import dataclass, field -from enum import Flag, auto +from enum import Enum, Flag, auto from os import environ from pathlib import PurePath from typing import TYPE_CHECKING, Any, ClassVar, Concatenate, Literal, ParamSpec, Tuple, TypeAlias @@ -344,6 +344,13 @@ def make_parser(cls) -> ParserFn: ) +class RxTxArgFlag(Enum): + """Enum representing recieving or transmitting ports.""" + + TX = "tx" + RX = "rx" + + class DeviceCapabilitiesFlag(Flag): """Flag representing the device capabilities.""" @@ -1278,6 +1285,81 @@ class TestPmdVerbosePacket(TextParser): ) +class TxOffloadCapability(Flag): + """TX offload capabilities of a device. + + The flags are taken from ``lib/ethdev/rte_ethdev.h``. + They're prefixed with ``RTE_ETH_TX_OFFLOAD`` in ``lib/ethdev/rte_ethdev.h`` + instead of ``TX_OFFLOAD``, which is what testpmd changes the prefix to. + The values are not contiguous, so the correspondence is preserved + by specifying concrete values interspersed between auto() values. + + The ``TX_OFFLOAD`` prefix has been preserved so that the same flag names can be used + in :class:`NicCapability`. The prefix is needed in :class:`NicCapability` since there's + no other qualifier which would sufficiently distinguish it from other capabilities. + + References: + DPDK lib: ``lib/ethdev/rte_ethdev.h`` + testpmd display function: ``app/test-pmd/cmdline.c:print_rx_offloads()`` + """ + + TX_OFFLOAD_VLAN_INSERT = auto() + TX_OFFLOAD_IPV4_CKSUM = auto() + TX_OFFLOAD_UDP_CKSUM = auto() + TX_OFFLOAD_TCP_CKSUM = auto() + TX_OFFLOAD_SCTP_CKSUM = auto() + TX_OFFLOAD_TCP_TSO = auto() + TX_OFFLOAD_UDP_TSO = auto() + TX_OFFLOAD_OUTER_IPV4_CKSUM = auto() + TX_OFFLOAD_QINQ_INSERT = auto() + TX_OFFLOAD_VXLAN_TNL_TSO = auto() + TX_OFFLOAD_GRE_TNL_TSO = auto() + TX_OFFLOAD_IPIP_TNL_TSO = auto() + TX_OFFLOAD_GENEVE_TNL_TSO = auto() + TX_OFFLOAD_MACSEC_INSERT = auto() + TX_OFFLOAD_MT_LOCKFREE = auto() + TX_OFFLOAD_MULTI_SEGS = auto() + TX_OFFLOAD_MBUF_FAST_FREE = auto() + TX_OFFLOAD_SECURITY = auto() + TX_OFFLOAD_UDP_TNL_TSO = auto() + TX_OFFLOAD_IP_TNL_TSO = auto() + TX_OFFLOAD_OUTER_UDP_CKSUM = auto() + TX_OFFLOAD_SEND_ON_TIMESTAMP = auto() + + @classmethod + def from_string(cls, line: str) -> Self: + """Make an instance from a string containing the flag names separated with a space. + + Args: + line: The line to parse. + + Returns: + A new instance containing all found flags. + """ + flag = cls(0) + for flag_name in line.split(): + flag |= cls[f"TX_OFFLOAD_{flag_name}"] + return flag + + @classmethod + def make_parser(cls, per_port: bool) -> ParserFn: + """Make a parser function. + + Args: + per_port: If :data:`True`, will return capabilities per port. If :data:`False`, + will return capabilities per queue. + + Returns: + ParserFn: A dictionary for the `dataclasses.field` metadata argument containing a + parser function that makes an instance of this flag from text. + """ + granularity = "Port" if per_port else "Queue" + return TextParser.wrap( + TextParser.find(rf"Per {granularity}\s+:(.*)$", re.MULTILINE), + cls.from_string, + ) + + class RxOffloadCapability(Flag): """Rx offload capabilities of a device. @@ -1376,6 +1458,24 @@ def make_parser(cls, per_port: bool) -> ParserFn: ) +@dataclass +class TxOffloadCapabilities(TextParser): + """The result of testpmd's ``show port <port_id> tx_offload capabilities`` command. + + References: + testpmd command function: ``app/test-pmd/cmdline.c:cmd_tx_offload_get_capa()`` + testpmd display function: ``app/test-pmd/cmdline.c:cmd_tx_offload_get_capa_parsed()`` + """ + + port_id: int = field( + metadata=TextParser.find_int(r"Tx Offloading Capabilities of port (\d+) :") + ) + #: Per-queue Tx offload capabilities. + per_queue: TxOffloadCapability = field(metadata=TxOffloadCapability.make_parser(False)) + #: Capabilities other than per-queue Tx offload capabilities. + per_port: TxOffloadCapability = field(metadata=TxOffloadCapability.make_parser(True)) + + @dataclass class RxOffloadCapabilities(TextParser): """The result of testpmd's ``show port <port_id> rx_offload capabilities`` command. @@ -2390,6 +2490,28 @@ def close(self) -> None: ====== Capability retrieval methods ====== """ + def get_capabilities_tx_offload( + self, + supported_capabilities: MutableSet["NicCapability"], + unsupported_capabilities: MutableSet["NicCapability"], + ) -> None: + """Get all TX offload capabilities and divide them into supported and unsupported. + + Args: + supported_capabilities: Supported capabilities will be added to this set. + unsupported_capabilities: Unsupported capabilities will be added to this set. + """ + self._logger.debug("Getting TX offload capabilities.") + command = f"show port {self.ports[0].id} tx_offload capabilities" + tx_offload_capabilities_out = self.send_command(command) + tx_offload_capabilities = TxOffloadCapabilities.parse(tx_offload_capabilities_out) + self._update_capabilities_from_flag( + supported_capabilities, + unsupported_capabilities, + TxOffloadCapability, + tx_offload_capabilities.per_port | tx_offload_capabilities.per_queue, + ) + def get_capabilities_rx_offload( self, supported_capabilities: MutableSet["NicCapability"], @@ -2672,6 +2794,134 @@ def get_capabilities_physical_function( else: unsupported_capabilities.add(NicCapability.PHYSICAL_FUNCTION) + @requires_started_ports + def get_rxtx_offload_config( + self, + rxtx: RxTxArgFlag, + verify: bool, + port_id: int = 0, + num_queues: int = 0, + ) -> dict[int | str, str]: + """Get the RX or TX offload configuration of the queues from the given port. + + Args: + rxtx: Whether to get the RX or TX configuration of the given queues. + verify: If :data:'True' the output of the command will be scanned in an attempt to + verify that the offload configuration was retrieved succesfully on all queues. + num_queues: The number of queues to get the offload configuration for. + port_id: The port ID that contains the desired queues. + + Returns: + A dict containing port info at key 'port' and queue info keyed by the appropriate queue + id. + + Raises: + InteractiveCommandExecutionError: If all queue offlaod configutrations could not be + retrieved. + + """ + returnDict: dict[int | str, str] = {} + + config_output = self.send_command(f"show port {port_id} {rxtx.value}_offload configuration") + if verify: + if ( + f"Rx Offloading Configuration of port {port_id}" not in config_output + and f"Tx Offloading Configuration of port {port_id}" not in config_output + ): + self._logger.debug(f"Get port offload config error\n{config_output}") + raise InteractiveCommandExecutionError( + f"""Failed to get offload config on port {port_id}:\n{config_output}""" + ) + # Actual ouput data starts on the thrid line + tempList: list[str] = config_output.splitlines()[3::] + returnDict["port"] = tempList[0] + for i in range(0, num_queues): + returnDict[i] = tempList[i + 1] + return returnDict + + @requires_stopped_ports + def set_port_rxtx_mbuf_fast_free( + self, rxtx: RxTxArgFlag, on: bool, verify: bool, port_id: int = 0 + ) -> None: + """Sets the mbuf_fast_free configuration for the RX or TX offload for a given port. + + Args: + rxtx: Whether to set the mbuf_fast_free on the RX or TX port. + on: If :data:'True' mbuf_fast_free will be enabled, disable it otherwise. + verify: If :data:'True' the output of the command will be scanned in an attempt to + verify that the mbuf_fast_free was set successfully. + port_id: The port number to enable or disable mbuf_fast_free on. + + Raises: + InteractiveCommandExecutionError: If mbuf_fast_free could not be set successfully + """ + mbuf_output = self.send_command( + f"port config {port_id} {rxtx.value}_offload mbuf_fast_free {"on" if on else "off"}" + ) + + if "error" in mbuf_output and verify: + raise InteractiveCommandExecutionError( + f"""Unable to set mbuf_fast_free config on port {port_id}:\n{mbuf_output}""" + ) + + @requires_stopped_ports + def set_queue_rxtx_mbuf_fast_free( + self, + rxtx: RxTxArgFlag, + on: bool, + verify: bool, + port_id: int = 0, + queue_id: int = 0, + ) -> None: + """Sets RX or TX mbuf_fast_free configuration of the specified queue on a given port. + + Args: + rxtx: Whether to set mbuf_fast_free for the RX or TX offload configuration on the + given queues. + on: If :data:'True' the mbuf_fast_free configuration will be enabled, otherwise + disabled. + verify: If :data:'True' the output of the command will be scanned in an attempt to + verify that mbuf_fast_free was set successfully on all ports. + queue_id: The queue to disable mbuf_fast_free on. + port_id: The ID of the port containing the queues. + + Raises: + InteractiveCommandExecutionError: If all queues could not be set successfully. + """ + toggle = "on" if on else "off" + output = self.send_command( + f"port {port_id} {rxtx.value}q {queue_id} {rxtx.value}_offload mbuf_fast_free {toggle}" + ) + if verify: + if "Error" in output: + self._logger.debug(f"Set queue offload config error\n{output}") + raise InteractiveCommandExecutionError( + f"Failed to get offload config on port {port_id}, queue {queue_id}:\n{output}" + ) + + def set_all_queues_rxtx_mbuf_fast_free( + self, + rxtx: RxTxArgFlag, + on: bool, + verify: bool, + port_id=0, + num_queues: int = 0, + ) -> None: + """Sets mbuf_fast_free configuration for the RX or TX offload of all queues on a given port. + + Args: + rxtx: Whether to set mbuf_fast_free for the RX or TX offload configuration on the + given queues. + on: If :data:'True' the mbuf fast_free_configuration will be enabled, otherwise + disabled. + verify: If :data:'True' the output of the command will be scanned in an attempt to + verify that mbuf_fast_free was set successfully on all ports. + port_id: The ID of the port containing the queues. + num_queues: The queue to disable mbuf_fast_free on. + """ + for i in range(0, num_queues): + self.set_queue_rxtx_mbuf_fast_free(rxtx, on, verify, port_id=port_id, queue_id=i) + class NicCapability(NoAliasEnum): """A mapping between capability names and the associated :class:`TestPmdShell` methods. @@ -2698,7 +2948,95 @@ class NicCapability(NoAliasEnum): we don't go looking for it again if a different test case also needs it. """ - #: Scattered packets Rx enabled + TX_OFFLOAD_VLAN_INSERT: TestPmdShellNicCapability = ( + TestPmdShell.get_capabilities_tx_offload, + None, + ) + TX_OFFLOAD_IPV4_CKSUM: TestPmdShellNicCapability = ( + TestPmdShell.get_capabilities_tx_offload, + None, + ) + TX_OFFLOAD_UDP_CKSUM: TestPmdShellNicCapability = ( + TestPmdShell.get_capabilities_tx_offload, + None, + ) + TX_OFFLOAD_TCP_CKSUM: TestPmdShellNicCapability = ( + TestPmdShell.get_capabilities_tx_offload, + None, + ) + TX_OFFLOAD_SCTP_CKSUM: TestPmdShellNicCapability = ( + TestPmdShell.get_capabilities_tx_offload, + None, + ) + TX_OFFLOAD_TCP_TSO: TestPmdShellNicCapability = ( + TestPmdShell.get_capabilities_tx_offload, + None, + ) + TX_OFFLOAD_UDP_TSO: TestPmdShellNicCapability = ( + TestPmdShell.get_capabilities_tx_offload, + None, + ) + TX_OFFLOAD_OUTER_IPV4_CKSUM: TestPmdShellNicCapability = ( + TestPmdShell.get_capabilities_tx_offload, + None, + ) + TX_OFFLOAD_QINQ_INSERT: TestPmdShellNicCapability = ( + TestPmdShell.get_capabilities_tx_offload, + None, + ) + TX_OFFLOAD_VXLAN_TNL_TSO: TestPmdShellNicCapability = ( + TestPmdShell.get_capabilities_tx_offload, + None, + ) + TX_OFFLOAD_GRE_TNL_TSO: TestPmdShellNicCapability = ( + TestPmdShell.get_capabilities_tx_offload, + None, + ) + TX_OFFLOAD_IPIP_TNL_TSO: TestPmdShellNicCapability = ( + TestPmdShell.get_capabilities_tx_offload, + None, + ) + TX_OFFLOAD_GENEVE_TNL_TSO: TestPmdShellNicCapability = ( + TestPmdShell.get_capabilities_tx_offload, + None, + ) + TX_OFFLOAD_MACSEC_INSERT: TestPmdShellNicCapability = ( + TestPmdShell.get_capabilities_tx_offload, + None, + ) + TX_OFFLOAD_MT_LOCKFREE: TestPmdShellNicCapability = ( + TestPmdShell.get_capabilities_tx_offload, + None, + ) + TX_OFFLOAD_MULTI_SEGS: TestPmdShellNicCapability = ( + TestPmdShell.get_capabilities_tx_offload, + None, + ) + TX_OFFLOAD_MBUF_FAST_FREE: TestPmdShellNicCapability = ( + TestPmdShell.get_capabilities_tx_offload, + None, + ) + TX_OFFLOAD_SECURITY: TestPmdShellNicCapability = ( + TestPmdShell.get_capabilities_tx_offload, + None, + ) + TX_OFFLOAD_UDP_TNL_TSO: TestPmdShellNicCapability = ( + TestPmdShell.get_capabilities_tx_offload, + None, + ) + TX_OFFLOAD_IP_TNL_TSO: TestPmdShellNicCapability = ( + TestPmdShell.get_capabilities_tx_offload, + None, + ) + TX_OFFLOAD_OUTER_UDP_CKSUM: TestPmdShellNicCapability = ( + TestPmdShell.get_capabilities_tx_offload, + None, + ) + TX_OFFLOAD_SEND_ON_TIMESTAMP: TestPmdShellNicCapability = ( + TestPmdShell.get_capabilities_tx_offload, + None, + ) + # : Scattered packets Rx enabled SCATTERED_RX_ENABLED: TestPmdShellNicCapability = ( TestPmdShell.get_capabilities_rxq_info, add_remove_mtu(9000), diff --git a/dts/tests/TestSuite_rxtx_offload.py b/dts/tests/TestSuite_rxtx_offload.py new file mode 100644 index 0000000000..90ba58bb25 --- /dev/null +++ b/dts/tests/TestSuite_rxtx_offload.py @@ -0,0 +1,153 @@ +# Copyright(c) 2025 University of New Hampshire + +"""RX TX offload test suite. + +Test the testpmd feature of configuring RX and TX offloads +""" + +from time import sleep +from framework.remote_session.testpmd_shell import ( + RxTxArgFlag, + TestPmdShell, +) +from framework.test_suite import TestSuite, func_test +from framework.testbed_model.capability import requires, NicCapability + + +@requires(NicCapability.TX_OFFLOAD_MACSEC_INSERT) +class TestRxTxOffload(TestSuite): + """RX/TX offload test suite.""" + + def check_port_config( + self, + testpmd: TestPmdShell, + offload: str, + rxtx: RxTxArgFlag, + verify: bool, + port_id: int = 0, + ) -> bool: + """Checks that the current port configuration matches the given offload. + + Args: + testpmd: The currrent testpmd shell session to send commands to. + offload: The expected configuration of the given port. + rxtx: Wether to check the RX or TX configuration of the given port. + verify: Wether to verify the result of call to testpmd. + port_id: Id of the port to check. + + Returns: + Whether current configuration matches given offload. + """ + output = testpmd.get_rxtx_offload_config(rxtx, verify, port_id, 0) + return offload in output["port"] or ( + offload == "NULL" and "MBUF_FAST_FREE" not in output["port"] + ) + + def check_queue_config( + self, + testpmd: TestPmdShell, + offload: list[str], + rxtx: RxTxArgFlag, + verify: bool, + port_id: int = 0, + num_queues: int = 0, + ) -> bool: + """Checks that the queue configuration matches the given offlad. + + Args: + testpmd: The currrent testpmd shell session to send commands to. + offload: The expected configuration of the queues, each index corresponds + to the queue id. + rxtx: Whether to check the RX or TX configuration of the given queues. + verify: Whether to verify commands sent to testpmd. + port_id: The port of which the queues reside. + num_queues: The number of queues to check. + + Returns: + Whether current configuration matches given offload + """ + output = testpmd.get_rxtx_offload_config(rxtx, verify, port_id, num_queues) + for i in range(0, num_queues): + if not ( + offload[i] in output[i] + or (offload[i] == "NULL" and "MBUF_FAST_FREE" not in output[i]) + ): + return False + return True + + @func_test + def test_mbuf_fast_free_configurations(self) -> None: + """Ensure mbuf_fast_free can be configured with testpmd. + + Steps: + Start up testpmd shell. + Toggle mbuf_fast_free on. + Toggle mbuf_fast_free off. + + Verify: + Mbuf_fast_free starts disabled. + Mbuf_fast_free can be configured on. + Mbuf_fast_free can be configured off. + """ + with TestPmdShell() as testpmd: + verify: bool = True + port_id: int = 0 + num_queues: int = 4 + queue_off: list[str] = [] + queue_on: list[str] = [] + mbuf_on = "MBUF_FAST_FREE" + mbuf_off = "NULL" + tx = RxTxArgFlag.TX + + for _ in range(0, num_queues): + queue_off.append(mbuf_off) + queue_on.append(mbuf_on) + + testpmd.set_ports_queues(num_queues) + testpmd.start_all_ports() + + # Ensure mbuf_fast_free is disabled by default on port and queues + self.verify( + self.check_port_config(testpmd, mbuf_off, tx, verify, port_id), + "Mbuf_fast_free enabled on port start", + ) + self.verify( + self.check_queue_config(testpmd, queue_off, tx, verify, port_id, num_queues), + "Mbuf_fast_free enabled on queue start", + ) + + # Enable mbuf_fast_free per queue and verify + testpmd.set_all_queues_rxtx_mbuf_fast_free(tx, True, verify, port_id, num_queues) + self.verify( + self.check_port_config(testpmd, mbuf_off, tx, verify, port_id), + "Port configuration changed without call", + ) + self.verify( + self.check_queue_config(testpmd, queue_on, tx, verify, port_id, num_queues), + "Queues failed to enable mbuf_fast_free", + ) + + # Enable mbuf_fast_free per port and verify + testpmd.set_port_rxtx_mbuf_fast_free(tx, True, verify, port_id) + self.verify( + self.check_port_config(testpmd, mbuf_on, tx, verify, port_id), + "Port failed to enable mbuf_fast_free", + ) + + # Disable mbuf_fast_free per queue and verify + testpmd.set_all_queues_rxtx_mbuf_fast_free(tx, False, verify, port_id, num_queues) + self.verify( + self.check_port_config(testpmd, mbuf_on, tx, verify, port_id), + "Port configuration changed without call", + ) + self.verify( + self.check_queue_config(testpmd, queue_off, tx, verify, port_id, num_queues), + "Queues failed to disable mbuf_fast_free", + ) + + # Disable mbuf_fast_free per port and verify + testpmd.set_port_rxtx_mbuf_fast_free(tx, False, verify, port_id) + self.verify( + self.check_port_config(testpmd, mbuf_off, tx, verify, port_id), + "Port failed to disable mbuf_fast_free", + ) -- 2.50.1 ^ permalink raw reply related [flat|nested] 22+ messages in thread
* Re: [PATCH v1 0/3] dts: add tx_offload support in dts [not found] <20250902114327.48185-1-abailey@iol.unh.edu> 2025-09-02 11:43 ` [PATCH v1 2/3] dts: add reception check to checksum offload suite Andrew Bailey 2025-09-02 11:43 ` [PATCH v1 3/3] dts: all are one Andrew Bailey @ 2025-09-02 11:48 ` Andrew Bailey 2025-09-24 16:47 ` [PATCH v4 0/3] dts:add " Andrew Bailey ` (2 subsequent siblings) 5 siblings, 0 replies; 22+ messages in thread From: Andrew Bailey @ 2025-09-02 11:48 UTC (permalink / raw) To: luca.vizzarro; +Cc: dev, dmarx, probb [-- Attachment #1: Type: text/plain, Size: 1046 bytes --] This patch set in its entirety was sent by mistake, please ignore. On Tue, Sep 2, 2025 at 7:43 AM Andrew Bailey <abailey@iol.unh.edu> wrote: > This patchset introduces the support for TX offload configuration > through DTS, allowing test cases to be written utilizing TX offload > capabilities. Along with configuring these capabilities, they are also > added to the NIC capabilities class, in which they can be required by > test suites. Finally, a test suite was created using the aforementioned > changes to update the RX TX offload test suite in legacy DTS. > > Andrew Bailey (3): > dts: add TX offload capabilities to NIC capabilities > dts: allow mbuf_fast_free to be set with testpmd shell > dts: update tx_offload test from old dts > > dts/framework/remote_session/testpmd_shell.py | 340 +++++++++++++++++- > dts/tests/TestSuite_rxtx_offload.py | 153 ++++++++ > 2 files changed, 492 insertions(+), 1 deletion(-) > create mode 100644 dts/tests/TestSuite_rxtx_offload.py > > -- > 2.50.1 > > [-- Attachment #2: Type: text/html, Size: 1397 bytes --] ^ permalink raw reply [flat|nested] 22+ messages in thread
* [PATCH v4 0/3] dts:add tx_offload support in dts [not found] <20250902114327.48185-1-abailey@iol.unh.edu> ` (2 preceding siblings ...) 2025-09-02 11:48 ` [PATCH v1 0/3] dts: add tx_offload support in dts Andrew Bailey @ 2025-09-24 16:47 ` Andrew Bailey 2025-09-24 16:47 ` [PATCH v4 1/3] dts: allow mbuf_fast_free to be set with testpmd shell Andrew Bailey ` (2 more replies) 2025-09-29 17:06 ` [PATCH v5 0/3] dts: add tx_offload support in dts Andrew Bailey 2025-09-29 17:27 ` [PATCH v6 0/3] dts: add tx_offload support in dts Andrew Bailey 5 siblings, 3 replies; 22+ messages in thread From: Andrew Bailey @ 2025-09-24 16:47 UTC (permalink / raw) To: luca.vizzarro; +Cc: abailey, dev, dmarx, ivan.malov, probb This patchset introduces the support for Tx offload configuration through DTS, allowing test cases to be written utilizing Tx offload capabilities. Along with configuring these capabilities, they are also added to the NIC capabilities class, in which they can be required by test suites. Finally, a test suite was created using the aforementioned changes to update the Rx\Tx offload test suite in legacy DTS. --- v2: * Removed mentions of mbuf_fast_free being configured for Rx queues/ports as this is not accurate behaviour. * Clarify argument descriptions in docstrings. v3: * Added seperation between port and queue capabilites as it is relevant to the added test case that queues support mbuf fast free configuration. * Homogenized methods for getting Rx and Tx offload capabilities and configurations * Moved to use the text parser to gather the configuration, rather than returning the raw string output. * Updated test suites to use the new ports/queues offload flags in the requires decorator * Updated mbuf fast free test suite to test ports and queues individually. Along with updating the way it confirms the configuration to be consistent with the new process of getting the configuration. * Moved the get configuration method to the get nic capability patch as it is more relevant to that patches context. v4: * Cleaned up some typing issues in testpmd, and moved where prefixes are passed to the capability flags. * Added documentation page for test suite. * Removed use of optional in the added test suite. Andrew Bailey (3): dts: allow mbuf_fast_free to be set with testpmd shell dts: add TX offload capabilities to NIC capabilities dts: update tx_offload test from old dts doc/api/dts/tests.TestSuite_rx_tx_offload.rst | 8 + dts/framework/parser.py | 30 + dts/framework/remote_session/testpmd_shell.py | 738 +++++++++++++++--- dts/tests/TestSuite_checksum_offload.py | 10 +- dts/tests/TestSuite_pmd_buffer_scatter.py | 4 +- dts/tests/TestSuite_rx_tx_offload.py | 128 +++ dts/tests/TestSuite_vlan.py | 4 +- 7 files changed, 789 insertions(+), 133 deletions(-) create mode 100644 doc/api/dts/tests.TestSuite_rx_tx_offload.rst create mode 100644 dts/tests/TestSuite_rx_tx_offload.py -- 2.50.1 ^ permalink raw reply [flat|nested] 22+ messages in thread
* [PATCH v4 1/3] dts: allow mbuf_fast_free to be set with testpmd shell 2025-09-24 16:47 ` [PATCH v4 0/3] dts:add " Andrew Bailey @ 2025-09-24 16:47 ` Andrew Bailey 2025-09-24 20:51 ` Patrick Robb 2025-09-25 16:01 ` Luca Vizzarro 2025-09-24 16:47 ` [PATCH v4 2/3] dts: add TX offload capabilities to NIC capabilities Andrew Bailey 2025-09-24 16:47 ` [PATCH v4 3/3] dts: update tx_offload test from old dts Andrew Bailey 2 siblings, 2 replies; 22+ messages in thread From: Andrew Bailey @ 2025-09-24 16:47 UTC (permalink / raw) To: luca.vizzarro; +Cc: abailey, dev, dmarx, ivan.malov, probb Currently, there is no way in the testpmd shell class to set the mbuf fast free offload configuration for queues or ports. This prohibits any test suites to be written utilizing this offload configuration. Introduce methods that support calls to testpmd in order to allow the configuration of mbuf fast free. Signed-off-by: Andrew Bailey <abailey@iol.unh.edu> --- dts/framework/remote_session/testpmd_shell.py | 60 +++++++++++++++++++ 1 file changed, 60 insertions(+) diff --git a/dts/framework/remote_session/testpmd_shell.py b/dts/framework/remote_session/testpmd_shell.py index 1df3d5f792..ecbdd66edd 100644 --- a/dts/framework/remote_session/testpmd_shell.py +++ b/dts/framework/remote_session/testpmd_shell.py @@ -2672,6 +2672,66 @@ def get_capabilities_physical_function( else: unsupported_capabilities.add(NicCapability.PHYSICAL_FUNCTION) + @requires_stopped_ports + def set_port_mbuf_fast_free( + self, + on: bool, + port_id: int, + /, + verify: bool = True, + ) -> None: + """Sets the mbuf_fast_free configuration for the Tx offload of a given port. + + Args: + on: If :data:`True` mbuf_fast_free will be enabled, disable it otherwise. + port_id: The ID of the port to configure mbuf_fast_free on. + verify: If :data:`True` the output of the command will be scanned in an attempt to + verify that the mbuf_fast_free was set successfully. + + Raises: + InteractiveCommandExecutionError: If mbuf_fast_free could not be set successfully. + """ + mbuf_output = self.send_command( + f"port config {port_id} tx_offload mbuf_fast_free {"on" if on else "off"}" + ) + + if verify and "Error" in mbuf_output: + raise InteractiveCommandExecutionError( + f"Unable to set mbuf_fast_free config on port {port_id}:\n{mbuf_output}" + ) + + @requires_stopped_ports + def set_queue_mbuf_fast_free( + self, + on: bool, + port_id: int, + /, + queue_id: int = 0, + verify: bool = True, + ) -> None: + """Sets the Tx mbuf_fast_free configuration of the specified queue on a given port. + + Args: + on: If :data:`True` the mbuf_fast_free configuration will be enabled, otherwise + disabled. + port_id: The ID of the port containing the queues. + queue_id: The ID of the queue to configure mbuf_fast_free on. + verify: If :data:`True` the output of the command will be scanned in an attempt to + verify that mbuf_fast_free was set successfully on all ports. + + Raises: + InteractiveCommandExecutionError: If all queues could not be set successfully. + """ + toggle = "on" if on else "off" + output = self.send_command( + f"port {port_id} txq {queue_id} tx_offload mbuf_fast_free {toggle}" + ) + if verify and "Error" in output: + self._logger.debug(f"Set queue offload config error\n{output}") + raise InteractiveCommandExecutionError( + f"Failed to get offload config on port {port_id}, queue {queue_id}:\n{output}" + ) + class NicCapability(NoAliasEnum): """A mapping between capability names and the associated :class:`TestPmdShell` methods. -- 2.50.1 ^ permalink raw reply related [flat|nested] 22+ messages in thread
* Re: [PATCH v4 1/3] dts: allow mbuf_fast_free to be set with testpmd shell 2025-09-24 16:47 ` [PATCH v4 1/3] dts: allow mbuf_fast_free to be set with testpmd shell Andrew Bailey @ 2025-09-24 20:51 ` Patrick Robb 2025-09-25 16:01 ` Luca Vizzarro 1 sibling, 0 replies; 22+ messages in thread From: Patrick Robb @ 2025-09-24 20:51 UTC (permalink / raw) To: Andrew Bailey; +Cc: luca.vizzarro, dev, dmarx, ivan.malov [-- Attachment #1: Type: text/plain, Size: 46 bytes --] Reviewed-by: Patrick Robb <probb@iol.unh.edu> [-- Attachment #2: Type: text/html, Size: 112 bytes --] ^ permalink raw reply [flat|nested] 22+ messages in thread
* Re: [PATCH v4 1/3] dts: allow mbuf_fast_free to be set with testpmd shell 2025-09-24 16:47 ` [PATCH v4 1/3] dts: allow mbuf_fast_free to be set with testpmd shell Andrew Bailey 2025-09-24 20:51 ` Patrick Robb @ 2025-09-25 16:01 ` Luca Vizzarro 1 sibling, 0 replies; 22+ messages in thread From: Luca Vizzarro @ 2025-09-25 16:01 UTC (permalink / raw) To: Andrew Bailey; +Cc: dev, dmarx, ivan.malov, probb Reviewed-by: Luca Vizzarro <luca.vizzarro@arm.com> ^ permalink raw reply [flat|nested] 22+ messages in thread
* [PATCH v4 2/3] dts: add TX offload capabilities to NIC capabilities 2025-09-24 16:47 ` [PATCH v4 0/3] dts:add " Andrew Bailey 2025-09-24 16:47 ` [PATCH v4 1/3] dts: allow mbuf_fast_free to be set with testpmd shell Andrew Bailey @ 2025-09-24 16:47 ` Andrew Bailey 2025-09-24 20:51 ` Patrick Robb 2025-09-25 16:05 ` Luca Vizzarro 2025-09-24 16:47 ` [PATCH v4 3/3] dts: update tx_offload test from old dts Andrew Bailey 2 siblings, 2 replies; 22+ messages in thread From: Andrew Bailey @ 2025-09-24 16:47 UTC (permalink / raw) To: luca.vizzarro; +Cc: abailey, dev, dmarx, ivan.malov, probb, Jeremy Spewock Currently, there is no support for tracking tx_offload capabilities and there is no separation between port capabilities and queue capabilities. This is an issue if a test case requires a tx_offload capability or if a test case requires that a card supports a capability on a queue. This causes test cases with said requirements to not be skipped when appropriate. Add tx_offload capabilities and distinguish capabilities between ports and queues. Signed-off-by: Andrew Bailey <abailey@iol.unh.edu> Signed-off-by: Jeremy Spewock <jspewock@iol.unh.edu> --- dts/framework/parser.py | 30 + dts/framework/remote_session/testpmd_shell.py | 678 ++++++++++++++---- dts/tests/TestSuite_checksum_offload.py | 10 +- dts/tests/TestSuite_pmd_buffer_scatter.py | 4 +- dts/tests/TestSuite_vlan.py | 4 +- 5 files changed, 593 insertions(+), 133 deletions(-) diff --git a/dts/framework/parser.py b/dts/framework/parser.py index 7254c75b71..4170cdb1dd 100644 --- a/dts/framework/parser.py +++ b/dts/framework/parser.py @@ -116,6 +116,36 @@ def _composite_parser_fn(text: str) -> Any: return ParserFn(TextParser_fn=_composite_parser_fn) + @staticmethod + def find_all( + pattern: str | re.Pattern[str], + flags: re.RegexFlag = re.RegexFlag(0), + ) -> ParserFn: + """Makes a parser function that finds all of the regular expression matches in the text. + + If there are no matches found in the text than None will be returned, otherwise a list + containing all matches will be returned. Patterns that contain multiple groups will pack + the matches for each group into a tuple. + + Args: + pattern: The regular expression pattern. + flags: The regular expression flags. Ignored if the given pattern is already compiled. + + Returns: + A :class:`ParserFn` that can be used as metadata for a dataclass field. + """ + if isinstance(pattern, str): + pattern = re.compile(pattern, flags) + + def _find_all(text: str) -> list[str] | None: + m = pattern.findall(text) + if len(m) == 0: + return None + + return m + + return ParserFn(TextParser_fn=_find_all) + @staticmethod def find( pattern: str | re.Pattern[str], diff --git a/dts/framework/remote_session/testpmd_shell.py b/dts/framework/remote_session/testpmd_shell.py index ecbdd66edd..db7e33222a 100644 --- a/dts/framework/remote_session/testpmd_shell.py +++ b/dts/framework/remote_session/testpmd_shell.py @@ -43,6 +43,7 @@ from framework.settings import SETTINGS from framework.utils import REGEX_FOR_MAC_ADDRESS, StrEnum +RxTxLiteralSwitch = Literal["rx", "tx"] P = ParamSpec("P") TestPmdShellMethod = Callable[Concatenate["TestPmdShell", P], Any] @@ -1278,7 +1279,99 @@ class TestPmdVerbosePacket(TextParser): ) -class RxOffloadCapability(Flag): +class OffloadCapability(Flag): + """Flags generated from RxOffloadCapabilites and TxOffloadCapabilities classes.""" + + @classmethod + def from_string(cls, line: str) -> Self: + """Make an instance from a string containing the flag names separated with a space. + + Args: + line: The line to parse. + + Returns: + A new instance containing all found flags. + """ + flag = cls(0) + for flag_name in line.split(): + flag |= cls[flag_name] + return flag + + @classmethod + def from_list(cls, lines: list[str]) -> list[Self]: + """Gather capabilities from a list of strings. + + Args: + lines: The list of capabilities to make flags from. + """ + return [cls.from_string(line) for line in lines] + + @classmethod + def make_parser( + cls, per_port: Literal["port", "queue"], /, find_multiple: bool = False + ) -> ParserFn: + """Make a parser function. + + Args: + per_port: If :data:`True`, will return capabilities per port. If :data:`False`, + will return capabilities per queue. + find_multiple: If :data:`True`, will use :func:`TextParser.find_all` to find all + matches for the regex query and return a list of instances based on those matches. + If :data:`False`, will return a single instance of the flag based off a single + match. + + Returns: + ParserFn: A dictionary for the `dataclasses.field` metadata argument containing a + parser function that makes an instance of this flag from text. + """ + granularity = per_port.capitalize() + regex = rf"{granularity}[\s\[\]\d]+:(.*)$" + if find_multiple: + return TextParser.wrap(TextParser.find_all(regex, re.MULTILINE), cls.from_list) + return TextParser.wrap(TextParser.find(regex, re.MULTILINE), cls.from_string) + + +class TxOffloadCapability(OffloadCapability): + """TX offload capabilities of a device. + + The flags are taken from ``lib/ethdev/rte_ethdev.h``. + They're prefixed with ``RTE_ETH_TX_OFFLOAD`` in ``lib/ethdev/rte_ethdev.h`` + instead of ``TX_OFFLOAD``, which is what testpmd changes the prefix to. + + The ``TX_OFFLOAD`` prefix has been preserved so that the same flag names can be used + in :class:`NicCapability`. The prefix is needed in :class:`NicCapability` since there's + no other qualifier which would sufficiently distinguish it from other capabilities. + + References: + DPDK lib: ``lib/ethdev/rte_ethdev.h`` + testpmd display function: ``app/test-pmd/cmdline.c:print_rx_offloads()`` + """ + + VLAN_INSERT = auto() + IPV4_CKSUM = auto() + UDP_CKSUM = auto() + TCP_CKSUM = auto() + SCTP_CKSUM = auto() + TCP_TSO = auto() + UDP_TSO = auto() + OUTER_IPV4_CKSUM = auto() + QINQ_INSERT = auto() + VXLAN_TNL_TSO = auto() + GRE_TNL_TSO = auto() + IPIP_TNL_TSO = auto() + GENEVE_TNL_TSO = auto() + MACSEC_INSERT = auto() + MT_LOCKFREE = auto() + MULTI_SEGS = auto() + MBUF_FAST_FREE = auto() + SECURITY = auto() + UDP_TNL_TSO = auto() + IP_TNL_TSO = auto() + OUTER_UDP_CKSUM = auto() + SEND_ON_TIMESTAMP = auto() + + +class RxOffloadCapability(OffloadCapability): """Rx offload capabilities of a device. The flags are taken from ``lib/ethdev/rte_ethdev.h``. @@ -1297,102 +1390,108 @@ class RxOffloadCapability(Flag): """ #: - RX_OFFLOAD_VLAN_STRIP = auto() + VLAN_STRIP = auto() #: Device supports L3 checksum offload. - RX_OFFLOAD_IPV4_CKSUM = auto() + IPV4_CKSUM = auto() #: Device supports L4 checksum offload. - RX_OFFLOAD_UDP_CKSUM = auto() + UDP_CKSUM = auto() #: Device supports L4 checksum offload. - RX_OFFLOAD_TCP_CKSUM = auto() + TCP_CKSUM = auto() #: Device supports Large Receive Offload. - RX_OFFLOAD_TCP_LRO = auto() + TCP_LRO = auto() #: Device supports QinQ (queue in queue) offload. - RX_OFFLOAD_QINQ_STRIP = auto() + QINQ_STRIP = auto() #: Device supports inner packet L3 checksum. - RX_OFFLOAD_OUTER_IPV4_CKSUM = auto() + OUTER_IPV4_CKSUM = auto() #: Device supports MACsec. - RX_OFFLOAD_MACSEC_STRIP = auto() + MACSEC_STRIP = auto() #: Device supports filtering of a VLAN Tag identifier. - RX_OFFLOAD_VLAN_FILTER = 1 << 9 + VLAN_FILTER = 1 << 9 #: Device supports VLAN offload. - RX_OFFLOAD_VLAN_EXTEND = auto() + VLAN_EXTEND = auto() #: Device supports receiving segmented mbufs. - RX_OFFLOAD_SCATTER = 1 << 13 + SCATTER = 1 << 13 #: Device supports Timestamp. - RX_OFFLOAD_TIMESTAMP = auto() + TIMESTAMP = auto() #: Device supports crypto processing while packet is received in NIC. - RX_OFFLOAD_SECURITY = auto() + SECURITY = auto() #: Device supports CRC stripping. - RX_OFFLOAD_KEEP_CRC = auto() + KEEP_CRC = auto() #: Device supports L4 checksum offload. - RX_OFFLOAD_SCTP_CKSUM = auto() + SCTP_CKSUM = auto() #: Device supports inner packet L4 checksum. - RX_OFFLOAD_OUTER_UDP_CKSUM = auto() + OUTER_UDP_CKSUM = auto() #: Device supports RSS hashing. - RX_OFFLOAD_RSS_HASH = auto() + RSS_HASH = auto() #: Device supports - RX_OFFLOAD_BUFFER_SPLIT = auto() + BUFFER_SPLIT = auto() #: Device supports all checksum capabilities. - RX_OFFLOAD_CHECKSUM = RX_OFFLOAD_IPV4_CKSUM | RX_OFFLOAD_UDP_CKSUM | RX_OFFLOAD_TCP_CKSUM + CHECKSUM = IPV4_CKSUM | UDP_CKSUM | TCP_CKSUM #: Device supports all VLAN capabilities. - RX_OFFLOAD_VLAN = ( - RX_OFFLOAD_VLAN_STRIP - | RX_OFFLOAD_VLAN_FILTER - | RX_OFFLOAD_VLAN_EXTEND - | RX_OFFLOAD_QINQ_STRIP - ) + VLAN = VLAN_STRIP | VLAN_FILTER | VLAN_EXTEND | QINQ_STRIP - @classmethod - def from_string(cls, line: str) -> Self: - """Make an instance from a string containing the flag names separated with a space. - Args: - line: The line to parse. +@dataclass +class OffloadCapabilities(TextParser): + """The result of testpmd's ``show port <port_id> tx_offload capabilities`` command. - Returns: - A new instance containing all found flags. - """ - flag = cls(0) - for flag_name in line.split(): - flag |= cls[f"RX_OFFLOAD_{flag_name}"] - return flag + References: + testpmd command function: ``app/test-pmd/cmdline.c:cmd_tx_offload_get_capa()`` + testpmd display function: ``app/test-pmd/cmdline.c:cmd_tx_offload_get_capa_parsed()`` + """ - @classmethod - def make_parser(cls, per_port: bool) -> ParserFn: - """Make a parser function. + port_id: int = field(metadata=TextParser.find_int(r"Offloading Capabilities of port (\d+) :")) + #: Per-queue Rx offload capabilities. + per_queue: OffloadCapability + #: Capabilities other than per-queue Rx offload capabilities. + per_port: OffloadCapability - Args: - per_port: If :data:`True`, will return capabilities per port. If :data:`False`, - will return capabilities per queue. - Returns: - ParserFn: A dictionary for the `dataclasses.field` metadata argument containing a - parser function that makes an instance of this flag from text. - """ - granularity = "Port" if per_port else "Queue" - return TextParser.wrap( - TextParser.find(rf"Per {granularity}\s+:(.*)$", re.MULTILINE), - cls.from_string, - ) +@dataclass +class RxOffloadCapabilities(OffloadCapabilities): + """Extends :class:`OffloadCapabilities` with Rx specific functionality.""" + + per_queue: OffloadCapability = field(metadata=RxOffloadCapability.make_parser("queue")) + per_port: OffloadCapability = field(metadata=RxOffloadCapability.make_parser("port")) @dataclass -class RxOffloadCapabilities(TextParser): - """The result of testpmd's ``show port <port_id> rx_offload capabilities`` command. +class TxOffloadCapabilities(OffloadCapabilities): + """Extends :class:`OffloadCapabilities` with Tx specific functionality.""" - References: - testpmd command function: ``app/test-pmd/cmdline.c:cmd_rx_offload_get_capa()`` - testpmd display function: ``app/test-pmd/cmdline.c:cmd_rx_offload_get_capa_parsed()`` - """ + per_queue: OffloadCapability = field(metadata=TxOffloadCapability.make_parser("queue")) + per_port: OffloadCapability = field(metadata=TxOffloadCapability.make_parser("port")) - #: - port_id: int = field( - metadata=TextParser.find_int(r"Rx Offloading Capabilities of port (\d+) :") + +@dataclass +class OffloadConfiguration(TextParser): + """The result of testpmd's ``show port <port_id> rx/tx_offload configuration`` command.""" + + port_id: int = field(metadata=TextParser.find_int(r"Offloading Configuration of port (\d+) :")) + #: Queue offload configurations. + queues: list[OffloadCapability] + #: Port offload configuration. + port: OffloadCapability + + +@dataclass +class RxOffloadConfiguration(OffloadConfiguration): + """Extends :class:`OffloadingConfiguration` with Rx specific functionality.""" + + queues: list[OffloadCapability] = field( + metadata=RxOffloadCapability.make_parser("queue", find_multiple=True) ) - #: Per-queue Rx offload capabilities. - per_queue: RxOffloadCapability = field(metadata=RxOffloadCapability.make_parser(False)) - #: Capabilities other than per-queue Rx offload capabilities. - per_port: RxOffloadCapability = field(metadata=RxOffloadCapability.make_parser(True)) + port: OffloadCapability = field(metadata=RxOffloadCapability.make_parser("port")) + + +@dataclass +class TxOffloadConfiguration(OffloadConfiguration): + """Extends :class:`OffloadingConfiguration` with Tx specific functionality.""" + + queues: list[OffloadCapability] = field( + metadata=TxOffloadCapability.make_parser("queue", find_multiple=True) + ) + port: OffloadCapability = field(metadata=TxOffloadCapability.make_parser("port")) @dataclass @@ -2390,27 +2489,54 @@ def close(self) -> None: ====== Capability retrieval methods ====== """ - def get_capabilities_rx_offload( - self, - supported_capabilities: MutableSet["NicCapability"], - unsupported_capabilities: MutableSet["NicCapability"], - ) -> None: - """Get all rx offload capabilities and divide them into supported and unsupported. + @staticmethod + def get_offload_capabilities_func( + rxtx: RxTxLiteralSwitch, + ) -> Callable[["TestPmdShell", MutableSet["NicCapability"], MutableSet["NicCapability"]], None]: + """High-order function that returns a method for gathering Rx/Tx offload capabilities. Args: - supported_capabilities: Supported capabilities will be added to this set. - unsupported_capabilities: Unsupported capabilities will be added to this set. - """ - self._logger.debug("Getting rx offload capabilities.") - command = f"show port {self.ports[0].id} rx_offload capabilities" - rx_offload_capabilities_out = self.send_command(command) - rx_offload_capabilities = RxOffloadCapabilities.parse(rx_offload_capabilities_out) - self._update_capabilities_from_flag( - supported_capabilities, - unsupported_capabilities, - RxOffloadCapability, - rx_offload_capabilities.per_port | rx_offload_capabilities.per_queue, - ) + rxtx: whether to gather the rx or tx capabilities in the returned method. + + Returns: + A method for gathering Rx/Tx offload capabilities that meets the required structure. + """ + + def get_capabilities( + self: "TestPmdShell", + supported_capabilities: MutableSet["NicCapability"], + unsupported_capabilities: MutableSet["NicCapability"], + ) -> None: + """Get all rx/tx offload capabilities and divide them into supported and unsupported. + + Args: + self: The shell instance to get the capabilities from. + supported_capabilities: Supported capabilities will be added to this set. + unsupported_capabilities: Unsupported capabilities will be added to this set. + """ + self._logger.debug(f"Getting {rxtx} offload capabilities.") + command = f"show port {self.ports[0].id} {rxtx}_offload capabilities" + offload_capabilities_out = self.send_command(command) + + capabilities = TxOffloadCapabilities if rxtx == "tx" else RxOffloadCapabilities + offload_capabilities = capabilities.parse(offload_capabilities_out) + + self._update_capabilities_from_flag( + supported_capabilities, + unsupported_capabilities, + TxOffloadCapability if rxtx == "tx" else RxOffloadCapability, + offload_capabilities.per_port | offload_capabilities.per_queue, + prefix=f"PORT_{rxtx.upper()}_OFFLOAD_", + ) + self._update_capabilities_from_flag( + supported_capabilities, + unsupported_capabilities, + TxOffloadCapability if rxtx == "tx" else RxOffloadCapability, + offload_capabilities.per_queue, + prefix=f"QUEUE_{rxtx.upper()}_OFFLOAD_", + ) + + return get_capabilities def get_port_queue_info( self, port_id: int, queue_id: int, is_rx_queue: bool @@ -2569,13 +2695,52 @@ def _update_capabilities_from_flag( unsupported_capabilities: MutableSet["NicCapability"], flag_class: type[Flag], supported_flags: Flag, + prefix: str = "", ) -> None: """Divide all flags from `flag_class` into supported and unsupported.""" for flag in flag_class: if flag in supported_flags: - supported_capabilities.add(NicCapability[str(flag.name)]) + supported_capabilities.add(NicCapability[f"{prefix}{flag.name}"]) else: - unsupported_capabilities.add(NicCapability[str(flag.name)]) + unsupported_capabilities.add(NicCapability[f"{prefix}{flag.name}"]) + + @requires_started_ports + def get_offload_config( + self, + rxtx: RxTxLiteralSwitch, + port_id: int, + /, + verify: bool = True, + ) -> RxOffloadConfiguration | TxOffloadConfiguration: + """Get the Rx or Tx offload configuration of the queues from the given port. + + Args: + rxtx: Whether to get the Rx or Tx configuration of the given queues. + port_id: The port ID that contains the desired queues. + verify: If :data:`True` the output of the command will be scanned in an attempt to + verify that the offload configuration was retrieved successfully on all queues. + + Returns: + An offload configuration containing the capabilities of the port and queues. + + Raises: + InteractiveCommandExecutionError: If all queue offload configurations could not be + retrieved. + """ + config_output = self.send_command(f"show port {port_id} {rxtx}_offload configuration") + if verify: + if ( + f"Rx Offloading Configuration of port {port_id}" not in config_output + and f"Tx Offloading Configuration of port {port_id}" not in config_output + ): + self._logger.debug(f"Get port offload config error\n{config_output}") + raise InteractiveCommandExecutionError( + f"Failed to get offload config on port {port_id}:\n{config_output}" + ) + if rxtx == "rx": + return RxOffloadConfiguration.parse(config_output) + else: + return TxOffloadConfiguration.parse(config_output) @requires_started_ports def get_capabilities_rxq_info( @@ -2758,102 +2923,367 @@ class NicCapability(NoAliasEnum): we don't go looking for it again if a different test case also needs it. """ + PORT_TX_OFFLOAD_VLAN_INSERT: TestPmdShellNicCapability = ( + TestPmdShell.get_offload_capabilities_func("tx"), + None, + ) + QUEUE_TX_OFFLOAD_VLAN_INSERT: TestPmdShellNicCapability = ( + TestPmdShell.get_offload_capabilities_func("tx"), + None, + ) + PORT_TX_OFFLOAD_IPV4_CKSUM: TestPmdShellNicCapability = ( + TestPmdShell.get_offload_capabilities_func("tx"), + None, + ) + QUEUE_TX_OFFLOAD_IPV4_CKSUM: TestPmdShellNicCapability = ( + TestPmdShell.get_offload_capabilities_func("tx"), + None, + ) + PORT_TX_OFFLOAD_UDP_CKSUM: TestPmdShellNicCapability = ( + TestPmdShell.get_offload_capabilities_func("tx"), + None, + ) + QUEUE_TX_OFFLOAD_UDP_CKSUM: TestPmdShellNicCapability = ( + TestPmdShell.get_offload_capabilities_func("tx"), + None, + ) + PORT_TX_OFFLOAD_TCP_CKSUM: TestPmdShellNicCapability = ( + TestPmdShell.get_offload_capabilities_func("tx"), + None, + ) + QUEUE_TX_OFFLOAD_TCP_CKSUM: TestPmdShellNicCapability = ( + TestPmdShell.get_offload_capabilities_func("tx"), + None, + ) + PORT_TX_OFFLOAD_SCTP_CKSUM: TestPmdShellNicCapability = ( + TestPmdShell.get_offload_capabilities_func("tx"), + None, + ) + QUEUE_TX_OFFLOAD_SCTP_CKSUM: TestPmdShellNicCapability = ( + TestPmdShell.get_offload_capabilities_func("tx"), + None, + ) + PORT_TX_OFFLOAD_TCP_TSO: TestPmdShellNicCapability = ( + TestPmdShell.get_offload_capabilities_func("tx"), + None, + ) + QUEUE_TX_OFFLOAD_TCP_TSO: TestPmdShellNicCapability = ( + TestPmdShell.get_offload_capabilities_func("tx"), + None, + ) + PORT_TX_OFFLOAD_UDP_TSO: TestPmdShellNicCapability = ( + TestPmdShell.get_offload_capabilities_func("tx"), + None, + ) + QUEUE_TX_OFFLOAD_UDP_TSO: TestPmdShellNicCapability = ( + TestPmdShell.get_offload_capabilities_func("tx"), + None, + ) + PORT_TX_OFFLOAD_OUTER_IPV4_CKSUM: TestPmdShellNicCapability = ( + TestPmdShell.get_offload_capabilities_func("tx"), + None, + ) + QUEUE_TX_OFFLOAD_OUTER_IPV4_CKSUM: TestPmdShellNicCapability = ( + TestPmdShell.get_offload_capabilities_func("tx"), + None, + ) + PORT_TX_OFFLOAD_QINQ_INSERT: TestPmdShellNicCapability = ( + TestPmdShell.get_offload_capabilities_func("tx"), + None, + ) + QUEUE_TX_OFFLOAD_QINQ_INSERT: TestPmdShellNicCapability = ( + TestPmdShell.get_offload_capabilities_func("tx"), + None, + ) + PORT_TX_OFFLOAD_VXLAN_TNL_TSO: TestPmdShellNicCapability = ( + TestPmdShell.get_offload_capabilities_func("tx"), + None, + ) + QUEUE_TX_OFFLOAD_VXLAN_TNL_TSO: TestPmdShellNicCapability = ( + TestPmdShell.get_offload_capabilities_func("tx"), + None, + ) + PORT_TX_OFFLOAD_GRE_TNL_TSO: TestPmdShellNicCapability = ( + TestPmdShell.get_offload_capabilities_func("tx"), + None, + ) + QUEUE_TX_OFFLOAD_GRE_TNL_TSO: TestPmdShellNicCapability = ( + TestPmdShell.get_offload_capabilities_func("tx"), + None, + ) + PORT_TX_OFFLOAD_IPIP_TNL_TSO: TestPmdShellNicCapability = ( + TestPmdShell.get_offload_capabilities_func("tx"), + None, + ) + QUEUE_TX_OFFLOAD_IPIP_TNL_TSO: TestPmdShellNicCapability = ( + TestPmdShell.get_offload_capabilities_func("tx"), + None, + ) + PORT_TX_OFFLOAD_GENEVE_TNL_TSO: TestPmdShellNicCapability = ( + TestPmdShell.get_offload_capabilities_func("tx"), + None, + ) + QUEUE_TX_OFFLOAD_GENEVE_TNL_TSO: TestPmdShellNicCapability = ( + TestPmdShell.get_offload_capabilities_func("tx"), + None, + ) + PORT_TX_OFFLOAD_MACSEC_INSERT: TestPmdShellNicCapability = ( + TestPmdShell.get_offload_capabilities_func("tx"), + None, + ) + QUEUE_TX_OFFLOAD_MACSEC_INSERT: TestPmdShellNicCapability = ( + TestPmdShell.get_offload_capabilities_func("tx"), + None, + ) + PORT_TX_OFFLOAD_MT_LOCKFREE: TestPmdShellNicCapability = ( + TestPmdShell.get_offload_capabilities_func("tx"), + None, + ) + QUEUE_TX_OFFLOAD_MT_LOCKFREE: TestPmdShellNicCapability = ( + TestPmdShell.get_offload_capabilities_func("tx"), + None, + ) + PORT_TX_OFFLOAD_MULTI_SEGS: TestPmdShellNicCapability = ( + TestPmdShell.get_offload_capabilities_func("tx"), + None, + ) + QUEUE_TX_OFFLOAD_MULTI_SEGS: TestPmdShellNicCapability = ( + TestPmdShell.get_offload_capabilities_func("tx"), + None, + ) + PORT_TX_OFFLOAD_MBUF_FAST_FREE: TestPmdShellNicCapability = ( + TestPmdShell.get_offload_capabilities_func("tx"), + None, + ) + QUEUE_TX_OFFLOAD_MBUF_FAST_FREE: TestPmdShellNicCapability = ( + TestPmdShell.get_offload_capabilities_func("tx"), + None, + ) + PORT_TX_OFFLOAD_SECURITY: TestPmdShellNicCapability = ( + TestPmdShell.get_offload_capabilities_func("tx"), + None, + ) + QUEUE_TX_OFFLOAD_SECURITY: TestPmdShellNicCapability = ( + TestPmdShell.get_offload_capabilities_func("tx"), + None, + ) + PORT_TX_OFFLOAD_UDP_TNL_TSO: TestPmdShellNicCapability = ( + TestPmdShell.get_offload_capabilities_func("tx"), + None, + ) + QUEUE_TX_OFFLOAD_UDP_TNL_TSO: TestPmdShellNicCapability = ( + TestPmdShell.get_offload_capabilities_func("tx"), + None, + ) + PORT_TX_OFFLOAD_IP_TNL_TSO: TestPmdShellNicCapability = ( + TestPmdShell.get_offload_capabilities_func("tx"), + None, + ) + QUEUE_TX_OFFLOAD_IP_TNL_TSO: TestPmdShellNicCapability = ( + TestPmdShell.get_offload_capabilities_func("tx"), + None, + ) + PORT_TX_OFFLOAD_OUTER_UDP_CKSUM: TestPmdShellNicCapability = ( + TestPmdShell.get_offload_capabilities_func("tx"), + None, + ) + QUEUE_TX_OFFLOAD_OUTER_UDP_CKSUM: TestPmdShellNicCapability = ( + TestPmdShell.get_offload_capabilities_func("tx"), + None, + ) + PORT_TX_OFFLOAD_SEND_ON_TIMESTAMP: TestPmdShellNicCapability = ( + TestPmdShell.get_offload_capabilities_func("tx"), + None, + ) + QUEUE_TX_OFFLOAD_SEND_ON_TIMESTAMP: TestPmdShellNicCapability = ( + TestPmdShell.get_offload_capabilities_func("tx"), + None, + ) #: Scattered packets Rx enabled SCATTERED_RX_ENABLED: TestPmdShellNicCapability = ( TestPmdShell.get_capabilities_rxq_info, add_remove_mtu(9000), ) #: - RX_OFFLOAD_VLAN_STRIP: TestPmdShellNicCapability = ( - TestPmdShell.get_capabilities_rx_offload, + PORT_RX_OFFLOAD_VLAN_STRIP: TestPmdShellNicCapability = ( + TestPmdShell.get_offload_capabilities_func("rx"), + None, + ) + QUEUE_RX_OFFLOAD_VLAN_STRIP: TestPmdShellNicCapability = ( + TestPmdShell.get_offload_capabilities_func("rx"), None, ) #: Device supports L3 checksum offload. - RX_OFFLOAD_IPV4_CKSUM: TestPmdShellNicCapability = ( - TestPmdShell.get_capabilities_rx_offload, + PORT_RX_OFFLOAD_IPV4_CKSUM: TestPmdShellNicCapability = ( + TestPmdShell.get_offload_capabilities_func("rx"), + None, + ) + QUEUE_RX_OFFLOAD_IPV4_CKSUM: TestPmdShellNicCapability = ( + TestPmdShell.get_offload_capabilities_func("rx"), None, ) #: Device supports L4 checksum offload. - RX_OFFLOAD_UDP_CKSUM: TestPmdShellNicCapability = ( - TestPmdShell.get_capabilities_rx_offload, + PORT_RX_OFFLOAD_UDP_CKSUM: TestPmdShellNicCapability = ( + TestPmdShell.get_offload_capabilities_func("rx"), + None, + ) + QUEUE_RX_OFFLOAD_UDP_CKSUM: TestPmdShellNicCapability = ( + TestPmdShell.get_offload_capabilities_func("rx"), None, ) #: Device supports L4 checksum offload. - RX_OFFLOAD_TCP_CKSUM: TestPmdShellNicCapability = ( - TestPmdShell.get_capabilities_rx_offload, + PORT_RX_OFFLOAD_TCP_CKSUM: TestPmdShellNicCapability = ( + TestPmdShell.get_offload_capabilities_func("rx"), + None, + ) + QUEUE_RX_OFFLOAD_TCP_CKSUM: TestPmdShellNicCapability = ( + TestPmdShell.get_offload_capabilities_func("rx"), None, ) #: Device supports Large Receive Offload. - RX_OFFLOAD_TCP_LRO: TestPmdShellNicCapability = (TestPmdShell.get_capabilities_rx_offload, None) + PORT_RX_OFFLOAD_TCP_LRO: TestPmdShellNicCapability = ( + TestPmdShell.get_offload_capabilities_func("rx"), + None, + ) + QUEUE_RX_OFFLOAD_TCP_LRO: TestPmdShellNicCapability = ( + TestPmdShell.get_offload_capabilities_func("rx"), + None, + ) #: Device supports QinQ (queue in queue) offload. - RX_OFFLOAD_QINQ_STRIP: TestPmdShellNicCapability = ( - TestPmdShell.get_capabilities_rx_offload, + PORT_RX_OFFLOAD_QINQ_STRIP: TestPmdShellNicCapability = ( + TestPmdShell.get_offload_capabilities_func("rx"), + None, + ) + QUEUE_RX_OFFLOAD_QINQ_STRIP: TestPmdShellNicCapability = ( + TestPmdShell.get_offload_capabilities_func("rx"), None, ) #: Device supports inner packet L3 checksum. - RX_OFFLOAD_OUTER_IPV4_CKSUM: TestPmdShellNicCapability = ( - TestPmdShell.get_capabilities_rx_offload, + PORT_RX_OFFLOAD_OUTER_IPV4_CKSUM: TestPmdShellNicCapability = ( + TestPmdShell.get_offload_capabilities_func("rx"), + None, + ) + QUEUE_RX_OFFLOAD_OUTER_IPV4_CKSUM: TestPmdShellNicCapability = ( + TestPmdShell.get_offload_capabilities_func("rx"), None, ) #: Device supports MACsec. - RX_OFFLOAD_MACSEC_STRIP: TestPmdShellNicCapability = ( - TestPmdShell.get_capabilities_rx_offload, + PORT_RX_OFFLOAD_MACSEC_STRIP: TestPmdShellNicCapability = ( + TestPmdShell.get_offload_capabilities_func("rx"), + None, + ) + QUEUE_RX_OFFLOAD_MACSEC_STRIP: TestPmdShellNicCapability = ( + TestPmdShell.get_offload_capabilities_func("rx"), None, ) #: Device supports filtering of a VLAN Tag identifier. - RX_OFFLOAD_VLAN_FILTER: TestPmdShellNicCapability = ( - TestPmdShell.get_capabilities_rx_offload, + PORT_RX_OFFLOAD_VLAN_FILTER: TestPmdShellNicCapability = ( + TestPmdShell.get_offload_capabilities_func("rx"), + None, + ) + QUEUE_RX_OFFLOAD_VLAN_FILTER: TestPmdShellNicCapability = ( + TestPmdShell.get_offload_capabilities_func("rx"), None, ) #: Device supports VLAN offload. - RX_OFFLOAD_VLAN_EXTEND: TestPmdShellNicCapability = ( - TestPmdShell.get_capabilities_rx_offload, + PORT_RX_OFFLOAD_VLAN_EXTEND: TestPmdShellNicCapability = ( + TestPmdShell.get_offload_capabilities_func("rx"), + None, + ) + QUEUE_RX_OFFLOAD_VLAN_EXTEND: TestPmdShellNicCapability = ( + TestPmdShell.get_offload_capabilities_func("rx"), None, ) #: Device supports receiving segmented mbufs. - RX_OFFLOAD_SCATTER: TestPmdShellNicCapability = (TestPmdShell.get_capabilities_rx_offload, None) + PORT_RX_OFFLOAD_SCATTER: TestPmdShellNicCapability = ( + TestPmdShell.get_offload_capabilities_func("rx"), + None, + ) + QUEUE_RX_OFFLOAD_SCATTER: TestPmdShellNicCapability = ( + TestPmdShell.get_offload_capabilities_func("rx"), + None, + ) #: Device supports Timestamp. - RX_OFFLOAD_TIMESTAMP: TestPmdShellNicCapability = ( - TestPmdShell.get_capabilities_rx_offload, + PORT_RX_OFFLOAD_TIMESTAMP: TestPmdShellNicCapability = ( + TestPmdShell.get_offload_capabilities_func("rx"), + None, + ) + QUEUE_RX_OFFLOAD_TIMESTAMP: TestPmdShellNicCapability = ( + TestPmdShell.get_offload_capabilities_func("rx"), None, ) #: Device supports crypto processing while packet is received in NIC. - RX_OFFLOAD_SECURITY: TestPmdShellNicCapability = ( - TestPmdShell.get_capabilities_rx_offload, + PORT_RX_OFFLOAD_SECURITY: TestPmdShellNicCapability = ( + TestPmdShell.get_offload_capabilities_func("rx"), + None, + ) + QUEUE_RX_OFFLOAD_SECURITY: TestPmdShellNicCapability = ( + TestPmdShell.get_offload_capabilities_func("rx"), None, ) #: Device supports CRC stripping. - RX_OFFLOAD_KEEP_CRC: TestPmdShellNicCapability = ( - TestPmdShell.get_capabilities_rx_offload, + PORT_RX_OFFLOAD_KEEP_CRC: TestPmdShellNicCapability = ( + TestPmdShell.get_offload_capabilities_func("rx"), + None, + ) + QUEUE_RX_OFFLOAD_KEEP_CRC: TestPmdShellNicCapability = ( + TestPmdShell.get_offload_capabilities_func("rx"), None, ) #: Device supports L4 checksum offload. - RX_OFFLOAD_SCTP_CKSUM: TestPmdShellNicCapability = ( - TestPmdShell.get_capabilities_rx_offload, + PORT_RX_OFFLOAD_SCTP_CKSUM: TestPmdShellNicCapability = ( + TestPmdShell.get_offload_capabilities_func("rx"), + None, + ) + QUEUE_RX_OFFLOAD_SCTP_CKSUM: TestPmdShellNicCapability = ( + TestPmdShell.get_offload_capabilities_func("rx"), None, ) #: Device supports inner packet L4 checksum. - RX_OFFLOAD_OUTER_UDP_CKSUM: TestPmdShellNicCapability = ( - TestPmdShell.get_capabilities_rx_offload, + PORT_RX_OFFLOAD_OUTER_UDP_CKSUM: TestPmdShellNicCapability = ( + TestPmdShell.get_offload_capabilities_func("rx"), + None, + ) + QUEUE_RX_OFFLOAD_OUTER_UDP_CKSUM: TestPmdShellNicCapability = ( + TestPmdShell.get_offload_capabilities_func("rx"), None, ) #: Device supports RSS hashing. - RX_OFFLOAD_RSS_HASH: TestPmdShellNicCapability = ( - TestPmdShell.get_capabilities_rx_offload, + PORT_RX_OFFLOAD_RSS_HASH: TestPmdShellNicCapability = ( + TestPmdShell.get_offload_capabilities_func("rx"), + None, + ) + QUEUE_RX_OFFLOAD_RSS_HASH: TestPmdShellNicCapability = ( + TestPmdShell.get_offload_capabilities_func("rx"), None, ) #: Device supports scatter Rx packets to segmented mbufs. - RX_OFFLOAD_BUFFER_SPLIT: TestPmdShellNicCapability = ( - TestPmdShell.get_capabilities_rx_offload, + PORT_RX_OFFLOAD_BUFFER_SPLIT: TestPmdShellNicCapability = ( + TestPmdShell.get_offload_capabilities_func("rx"), + None, + ) + QUEUE_RX_OFFLOAD_BUFFER_SPLIT: TestPmdShellNicCapability = ( + TestPmdShell.get_offload_capabilities_func("rx"), None, ) #: Device supports all checksum capabilities. - RX_OFFLOAD_CHECKSUM: TestPmdShellNicCapability = ( - TestPmdShell.get_capabilities_rx_offload, + PORT_RX_OFFLOAD_CHECKSUM: TestPmdShellNicCapability = ( + TestPmdShell.get_offload_capabilities_func("rx"), + None, + ) + QUEUE_RX_OFFLOAD_CHECKSUM: TestPmdShellNicCapability = ( + TestPmdShell.get_offload_capabilities_func("rx"), None, ) #: Device supports all VLAN capabilities. - RX_OFFLOAD_VLAN: TestPmdShellNicCapability = (TestPmdShell.get_capabilities_rx_offload, None) + PORT_RX_OFFLOAD_VLAN: TestPmdShellNicCapability = ( + TestPmdShell.get_offload_capabilities_func("rx"), + None, + ) + QUEUE_RX_OFFLOAD_VLAN: TestPmdShellNicCapability = ( + TestPmdShell.get_offload_capabilities_func("rx"), + None, + ) #: Device supports Rx queue setup after device started. RUNTIME_RX_QUEUE_SETUP: TestPmdShellNicCapability = ( TestPmdShell.get_capabilities_show_port_info, diff --git a/dts/tests/TestSuite_checksum_offload.py b/dts/tests/TestSuite_checksum_offload.py index ff916a4bb7..8e06c6b65f 100644 --- a/dts/tests/TestSuite_checksum_offload.py +++ b/dts/tests/TestSuite_checksum_offload.py @@ -30,9 +30,9 @@ @requires(topology_type=TopologyType.two_links) -@requires(NicCapability.RX_OFFLOAD_IPV4_CKSUM) -@requires(NicCapability.RX_OFFLOAD_UDP_CKSUM) -@requires(NicCapability.RX_OFFLOAD_TCP_CKSUM) +@requires(NicCapability.PORT_RX_OFFLOAD_IPV4_CKSUM) +@requires(NicCapability.PORT_RX_OFFLOAD_UDP_CKSUM) +@requires(NicCapability.PORT_RX_OFFLOAD_TCP_CKSUM) class TestChecksumOffload(TestSuite): """Checksum offload test suite. @@ -285,7 +285,7 @@ def validate_rx_checksum(self) -> None: packet=packet_list[i], good_L4=False, good_IP=True, testpmd=testpmd, id=dport_id ) - @requires(NicCapability.RX_OFFLOAD_VLAN) + @requires(NicCapability.PORT_RX_OFFLOAD_VLAN) @func_test def vlan_checksum(self) -> None: """Test VLAN Rx checksum hardware offload and verify packet reception. @@ -342,7 +342,7 @@ def vlan_checksum(self) -> None: packet=packet_list[i], good_L4=False, good_IP=True, testpmd=testpmd, id=dport_id ) - @requires(NicCapability.RX_OFFLOAD_SCTP_CKSUM) + @requires(NicCapability.PORT_RX_OFFLOAD_SCTP_CKSUM) @func_test def validate_sctp_checksum(self) -> None: """Test SCTP Rx checksum hardware offload and verify packet reception. diff --git a/dts/tests/TestSuite_pmd_buffer_scatter.py b/dts/tests/TestSuite_pmd_buffer_scatter.py index 802777a697..54627157b5 100644 --- a/dts/tests/TestSuite_pmd_buffer_scatter.py +++ b/dts/tests/TestSuite_pmd_buffer_scatter.py @@ -29,7 +29,7 @@ @requires(NicCapability.PHYSICAL_FUNCTION) -@requires(NicCapability.RX_OFFLOAD_SCATTER) +@requires(NicCapability.PORT_RX_OFFLOAD_SCATTER) class TestPmdBufferScatter(TestSuite): """DPDK PMD packet scattering test suite. @@ -135,7 +135,7 @@ def scatter_mbuf_2048(self) -> None: """Run the :meth:`pmd_scatter` test with `mb_size` set to 2048.""" self.pmd_scatter(mb_size=2048) - @requires(NicCapability.RX_OFFLOAD_SCATTER) + @requires(NicCapability.PORT_RX_OFFLOAD_SCATTER) @func_test def scatter_mbuf_2048_with_offload(self) -> None: """Run the :meth:`pmd_scatter` test with `mb_size` set to 2048 and rx_scatter offload.""" diff --git a/dts/tests/TestSuite_vlan.py b/dts/tests/TestSuite_vlan.py index ed36a2950d..906ceb0072 100644 --- a/dts/tests/TestSuite_vlan.py +++ b/dts/tests/TestSuite_vlan.py @@ -20,7 +20,7 @@ from framework.testbed_model.capability import NicCapability, TopologyType, requires -@requires(NicCapability.RX_OFFLOAD_VLAN_FILTER) +@requires(NicCapability.PORT_RX_OFFLOAD_VLAN_FILTER) @requires(topology_type=TopologyType.two_links) class TestVlan(TestSuite): """DPDK VLAN test suite. @@ -129,7 +129,7 @@ def vlan_receipt_no_stripping(self) -> None: testpmd.start() self.send_vlan_packet_and_verify(True, strip=False, vlan_id=1) - @requires(NicCapability.RX_OFFLOAD_VLAN_STRIP) + @requires(NicCapability.PORT_RX_OFFLOAD_VLAN_STRIP) @func_test def vlan_receipt_stripping(self) -> None: """Ensure VLAN packet received with no tag when receipts and header stripping are enabled. -- 2.50.1 ^ permalink raw reply related [flat|nested] 22+ messages in thread
* Re: [PATCH v4 2/3] dts: add TX offload capabilities to NIC capabilities 2025-09-24 16:47 ` [PATCH v4 2/3] dts: add TX offload capabilities to NIC capabilities Andrew Bailey @ 2025-09-24 20:51 ` Patrick Robb 2025-09-25 16:05 ` Luca Vizzarro 1 sibling, 0 replies; 22+ messages in thread From: Patrick Robb @ 2025-09-24 20:51 UTC (permalink / raw) To: Andrew Bailey; +Cc: luca.vizzarro, dev, dmarx, ivan.malov, Jeremy Spewock [-- Attachment #1: Type: text/plain, Size: 966 bytes --] On Wed, Sep 24, 2025 at 12:47 PM Andrew Bailey <abailey@iol.unh.edu> wrote: > Currently, there is no support for tracking tx_offload capabilities and > there is no separation between port capabilities and queue > capabilities. This is an issue if a test case requires a tx_offload > capability or if a test case requires that a card supports a capability > on a queue. This causes test cases with said requirements to not be > skipped when appropriate. Add tx_offload capabilities and distinguish > capabilities between ports and queues. > > Signed-off-by: Andrew Bailey <abailey@iol.unh.edu> > Signed-off-by: Jeremy Spewock <jspewock@iol.unh.edu> > > - Args: > - line: The line to parse. > +@dataclass > +class OffloadCapabilities(TextParser): > + """The result of testpmd's ``show port <port_id> tx_offload > capabilities`` command. > tx_offload or rx_offload, right? Reviewed-by: Patrick Robb <probb@iol.unh.edu> [-- Attachment #2: Type: text/html, Size: 1569 bytes --] ^ permalink raw reply [flat|nested] 22+ messages in thread
* Re: [PATCH v4 2/3] dts: add TX offload capabilities to NIC capabilities 2025-09-24 16:47 ` [PATCH v4 2/3] dts: add TX offload capabilities to NIC capabilities Andrew Bailey 2025-09-24 20:51 ` Patrick Robb @ 2025-09-25 16:05 ` Luca Vizzarro 1 sibling, 0 replies; 22+ messages in thread From: Luca Vizzarro @ 2025-09-25 16:05 UTC (permalink / raw) To: Andrew Bailey; +Cc: dev, dmarx, ivan.malov, probb, Jeremy Spewock Hi Andrew, Looks good! Just a small nit left. On Wed, Sep 24, 2025 at 12:47:24PM +0000, Andrew Bailey wrote: > diff --git a/dts/framework/remote_session/testpmd_shell.py b/dts/framework/remote_session/testpmd_shell.py > index ecbdd66edd..db7e33222a 100644 > --- a/dts/framework/remote_session/testpmd_shell.py > +++ b/dts/framework/remote_session/testpmd_shell.py > @@ -1278,7 +1279,99 @@ class TestPmdVerbosePacket(TextParser): > ) > > > -class RxOffloadCapability(Flag): > +class OffloadCapability(Flag): > + """Flags generated from RxOffloadCapabilites and TxOffloadCapabilities classes.""" <snip> > + @classmethod > + def make_parser( > + cls, per_port: Literal["port", "queue"], /, find_multiple: bool = False > + ) -> ParserFn: > + """Make a parser function. > + > + Args: > + per_port: If :data:`True`, will return capabilities per port. If :data:`False`, > + will return capabilities per queue. just a small nit: this doc doesn't match what it is anymore. Similarly the argument name is not entirely valid either. > + find_multiple: If :data:`True`, will use :func:`TextParser.find_all` to find all > + matches for the regex query and return a list of instances based on those matches. > + If :data:`False`, will return a single instance of the flag based off a single > + match. > + > + Returns: > + ParserFn: A dictionary for the `dataclasses.field` metadata argument containing a > + parser function that makes an instance of this flag from text. > + """ > + granularity = per_port.capitalize() > + regex = rf"{granularity}[\s\[\]\d]+:(.*)$" > + if find_multiple: > + return TextParser.wrap(TextParser.find_all(regex, re.MULTILINE), cls.from_list) > + return TextParser.wrap(TextParser.find(regex, re.MULTILINE), cls.from_string) <snip> ^ permalink raw reply [flat|nested] 22+ messages in thread
* [PATCH v4 3/3] dts: update tx_offload test from old dts 2025-09-24 16:47 ` [PATCH v4 0/3] dts:add " Andrew Bailey 2025-09-24 16:47 ` [PATCH v4 1/3] dts: allow mbuf_fast_free to be set with testpmd shell Andrew Bailey 2025-09-24 16:47 ` [PATCH v4 2/3] dts: add TX offload capabilities to NIC capabilities Andrew Bailey @ 2025-09-24 16:47 ` Andrew Bailey 2025-09-24 20:53 ` Patrick Robb 2 siblings, 1 reply; 22+ messages in thread From: Andrew Bailey @ 2025-09-24 16:47 UTC (permalink / raw) To: luca.vizzarro; +Cc: abailey, dev, dmarx, ivan.malov, probb Currently, the RX/TX offload test in old DTS expects the TX ports to be initially configured to use mbuf fast free. This is no longer the case and must be updated to assume mbuf fast free is not initially utilized by capable NICs. Add updated test suite to test mbuf fast free configuration. Signed-off-by: Andrew Bailey <abailey@iol.unh.edu> --- doc/api/dts/tests.TestSuite_rx_tx_offload.rst | 8 ++ dts/tests/TestSuite_rx_tx_offload.py | 128 ++++++++++++++++++ 2 files changed, 136 insertions(+) create mode 100644 doc/api/dts/tests.TestSuite_rx_tx_offload.rst create mode 100644 dts/tests/TestSuite_rx_tx_offload.py diff --git a/doc/api/dts/tests.TestSuite_rx_tx_offload.rst b/doc/api/dts/tests.TestSuite_rx_tx_offload.rst new file mode 100644 index 0000000000..225267a45f --- /dev/null +++ b/doc/api/dts/tests.TestSuite_rx_tx_offload.rst @@ -0,0 +1,8 @@ +.. SPDX-License-Identifier: BSD-3-Clause + +rx_tx_offload Test Suite +========================= + +.. automodule:: tests.TestSuite_rx_tx_offload + :members: + :show-inheritance: \ No newline at end of file diff --git a/dts/tests/TestSuite_rx_tx_offload.py b/dts/tests/TestSuite_rx_tx_offload.py new file mode 100644 index 0000000000..6ae98068e4 --- /dev/null +++ b/dts/tests/TestSuite_rx_tx_offload.py @@ -0,0 +1,128 @@ +# SPDX-License-Identifier: BSD-3-Clause +# Copyright(c) 2025 University of New Hampshire + +"""RX TX offload test suite. + +Test the testpmd feature of configuring RX and TX offloads. +""" + +from framework.remote_session.testpmd_shell import ( + OffloadConfiguration, + RxTxLiteralSwitch, + TestPmdShell, +) +from framework.test_suite import TestSuite, func_test +from framework.testbed_model.capability import NicCapability, requires + + +class TestRxTxOffload(TestSuite): + """RX/TX offload test suite.""" + + def _check_config( + self, + testpmd: TestPmdShell, + port_offload: str | None, + rxtx: RxTxLiteralSwitch, + port_id: int, + /, + queue_offload: list[str | None] | None = None, + verify: bool = True, + ) -> bool: + config: OffloadConfiguration = testpmd.get_offload_config(rxtx, port_id, verify) + if config.port.name != port_offload: + return False + + if queue_offload: + for i, q in enumerate(config.queues): + if q.name != queue_offload[i]: + return False + return True + + def _set_all_queues_mbuf_fast_free( + self, testpmd: TestPmdShell, on: bool, port_id: int, num_queues: int, /, verify: bool = True + ) -> None: + for i in range(num_queues): + testpmd.set_queue_mbuf_fast_free(on, port_id, i, verify) + + @requires(NicCapability.PORT_TX_OFFLOAD_MBUF_FAST_FREE) + @func_test + def test_mbuf_fast_free_configuration_per_port(self) -> None: + """Ensure mbuf_fast_free can be configured with testpmd per port. + + Steps: + * Start up testpmd shell. + * Toggle mbuf_fast_free on per port. + * Toggle mbuf_fast_free off per port. + + Verify: + * Mbuf_fast_free starts disabled. + * Mbuf_fast_free can be configured on per port. + * Mbuf_fast_free can be configured off per port. + """ + with TestPmdShell() as testpmd: + verify = True + port_id = 0 + testpmd.start_all_ports() + + # Ensure MBUF_FAST_FREE is disabled by default and verify + self.verify( + self._check_config(testpmd, None, "tx", port_id, verify=verify), + "MBUF_FAST_FREE enabled on port start.", + ) + # Enable MBUF_FAST_FREE per port and verify + testpmd.set_port_mbuf_fast_free(True, port_id, verify) + self.verify( + self._check_config( + testpmd, "TX_OFFLOAD_MBUF_FAST_FREE", "tx", port_id, verify=verify + ), + "Failed to enable MBUF_FAST_FREE on port.", + ) + # Disable MBUF_FAST_FREE per port and verify + testpmd.set_port_mbuf_fast_free(False, port_id, verify) + self.verify( + self._check_config(testpmd, None, "tx", port_id, verify=verify), + "Failed to disable MBUF_FAST_FREE on port.", + ) + + @requires(NicCapability.QUEUE_TX_OFFLOAD_MBUF_FAST_FREE) + @func_test + def test_mbuf_fast_free_configuration_per_queue(self) -> None: + """Ensure mbuf_fast_free can be configured with testpmd. + + Steps: + * Start up testpmd shell. + * Toggle mbuf_fast_free on per queue. + * Toggle mbuf_fast_free off per queue. + + Verify: + * Mbuf_fast_free starts disabled. + * Mbuf_fast_free can be configured on per queue. + * Mbuf_fast_free can be configured off per queue. + """ + with TestPmdShell() as testpmd: + verify = True + port_id = 0 + num_queues = 4 + queue_off: list[str | None] | None = [None] * num_queues + queue_on: list[str | None] | None = ["TX_OFFLOAD_MBUF_FAST_FREE"] * num_queues + + testpmd.set_ports_queues(num_queues) + testpmd.start_all_ports() + + # Ensure mbuf_fast_free is disabled by default on port and queues + self.verify( + self._check_config(testpmd, None, "tx", port_id, queue_off, verify=verify), + "MBUF_FAST_FREE enabled on queue start.", + ) + # Enable mbuf_fast_free per queue and verify + self._set_all_queues_mbuf_fast_free(testpmd, True, port_id, num_queues, verify) + self.verify( + self._check_config(testpmd, None, "tx", port_id, queue_on, verify), + "Failed to enable MBUF_FAST_FREE on all queues.", + ) + # Disable mbuf_fast_free per queue and verify + self._set_all_queues_mbuf_fast_free(testpmd, False, port_id, num_queues, verify) + self.verify( + self._check_config(testpmd, None, "tx", port_id, queue_off, verify), + "Failed to disable MBUF_FAST_FREE on all queues.", + ) -- 2.50.1 ^ permalink raw reply related [flat|nested] 22+ messages in thread
* Re: [PATCH v4 3/3] dts: update tx_offload test from old dts 2025-09-24 16:47 ` [PATCH v4 3/3] dts: update tx_offload test from old dts Andrew Bailey @ 2025-09-24 20:53 ` Patrick Robb 0 siblings, 0 replies; 22+ messages in thread From: Patrick Robb @ 2025-09-24 20:53 UTC (permalink / raw) To: Andrew Bailey; +Cc: luca.vizzarro, dev, dmarx, ivan.malov [-- Attachment #1: Type: text/plain, Size: 7399 bytes --] On Wed, Sep 24, 2025 at 12:47 PM Andrew Bailey <abailey@iol.unh.edu> wrote: > Currently, the RX/TX offload test in old DTS expects the TX ports to be > initially configured to use mbuf fast free. This is no longer the case > and must be updated to assume mbuf fast free is not initially utilized > by capable NICs. Add updated test suite to test mbuf fast free > configuration. > > Signed-off-by: Andrew Bailey <abailey@iol.unh.edu> > --- > doc/api/dts/tests.TestSuite_rx_tx_offload.rst | 8 ++ > dts/tests/TestSuite_rx_tx_offload.py | 128 ++++++++++++++++++ > 2 files changed, 136 insertions(+) > create mode 100644 doc/api/dts/tests.TestSuite_rx_tx_offload.rst > create mode 100644 dts/tests/TestSuite_rx_tx_offload.py > > diff --git a/doc/api/dts/tests.TestSuite_rx_tx_offload.rst > b/doc/api/dts/tests.TestSuite_rx_tx_offload.rst > new file mode 100644 > index 0000000000..225267a45f > --- /dev/null > +++ b/doc/api/dts/tests.TestSuite_rx_tx_offload.rst > @@ -0,0 +1,8 @@ > +.. SPDX-License-Identifier: BSD-3-Clause > + > +rx_tx_offload Test Suite > +========================= > Did you try to build the docs after adding this file? I might be wrong but I think the syntax might be flawed. If you don't remember the docs build process is: meson setup build ninja -C build doc > + > +.. automodule:: tests.TestSuite_rx_tx_offload > + :members: > + :show-inheritance: > \ No newline at end of file > diff --git a/dts/tests/TestSuite_rx_tx_offload.py > b/dts/tests/TestSuite_rx_tx_offload.py > new file mode 100644 > index 0000000000..6ae98068e4 > --- /dev/null > +++ b/dts/tests/TestSuite_rx_tx_offload.py > @@ -0,0 +1,128 @@ > +# SPDX-License-Identifier: BSD-3-Clause > +# Copyright(c) 2025 University of New Hampshire > + > +"""RX TX offload test suite. > + > +Test the testpmd feature of configuring RX and TX offloads. > +""" > + > +from framework.remote_session.testpmd_shell import ( > + OffloadConfiguration, > + RxTxLiteralSwitch, > + TestPmdShell, > +) > your branch needs to be rebased off of dpdk-next-dts/for-main. We have merged Paul's DTS API patch, which means your imports are no longer valid and will need to be updated. > +from framework.test_suite import TestSuite, func_test > +from framework.testbed_model.capability import NicCapability, requires > + > + > +class TestRxTxOffload(TestSuite): > + """RX/TX offload test suite.""" > + > + def _check_config( > + self, > + testpmd: TestPmdShell, > + port_offload: str | None, > + rxtx: RxTxLiteralSwitch, > + port_id: int, > + /, > + queue_offload: list[str | None] | None = None, > + verify: bool = True, > + ) -> bool: > + config: OffloadConfiguration = testpmd.get_offload_config(rxtx, > port_id, verify) > + if config.port.name != port_offload: > + return False > + > + if queue_offload: > + for i, q in enumerate(config.queues): > + if q.name != queue_offload[i]: > + return False > + return True > + > + def _set_all_queues_mbuf_fast_free( > + self, testpmd: TestPmdShell, on: bool, port_id: int, num_queues: > int, /, verify: bool = True > + ) -> None: > + for i in range(num_queues): > + testpmd.set_queue_mbuf_fast_free(on, port_id, i, verify) > + > + @requires(NicCapability.PORT_TX_OFFLOAD_MBUF_FAST_FREE) > + @func_test > + def test_mbuf_fast_free_configuration_per_port(self) -> None: > + """Ensure mbuf_fast_free can be configured with testpmd per port. > + > + Steps: > + * Start up testpmd shell. > + * Toggle mbuf_fast_free on per port. > + * Toggle mbuf_fast_free off per port. > + > + Verify: > + * Mbuf_fast_free starts disabled. > + * Mbuf_fast_free can be configured on per port. > + * Mbuf_fast_free can be configured off per port. > + """ > + with TestPmdShell() as testpmd: > + verify = True > + port_id = 0 > + testpmd.start_all_ports() > + > + # Ensure MBUF_FAST_FREE is disabled by default and verify > + self.verify( > + self._check_config(testpmd, None, "tx", port_id, > verify=verify), > + "MBUF_FAST_FREE enabled on port start.", > + ) > + # Enable MBUF_FAST_FREE per port and verify > + testpmd.set_port_mbuf_fast_free(True, port_id, verify) > + self.verify( > + self._check_config( > + testpmd, "TX_OFFLOAD_MBUF_FAST_FREE", "tx", port_id, > verify=verify > + ), > + "Failed to enable MBUF_FAST_FREE on port.", > + ) > + # Disable MBUF_FAST_FREE per port and verify > + testpmd.set_port_mbuf_fast_free(False, port_id, verify) > + self.verify( > + self._check_config(testpmd, None, "tx", port_id, > verify=verify), > + "Failed to disable MBUF_FAST_FREE on port.", > + ) > + > + @requires(NicCapability.QUEUE_TX_OFFLOAD_MBUF_FAST_FREE) > + @func_test > + def test_mbuf_fast_free_configuration_per_queue(self) -> None: > + """Ensure mbuf_fast_free can be configured with testpmd. > + > + Steps: > + * Start up testpmd shell. > + * Toggle mbuf_fast_free on per queue. > + * Toggle mbuf_fast_free off per queue. > + > + Verify: > + * Mbuf_fast_free starts disabled. > + * Mbuf_fast_free can be configured on per queue. > + * Mbuf_fast_free can be configured off per queue. > + """ > + with TestPmdShell() as testpmd: > + verify = True > + port_id = 0 > + num_queues = 4 > + queue_off: list[str | None] | None = [None] * num_queues > + queue_on: list[str | None] | None = > ["TX_OFFLOAD_MBUF_FAST_FREE"] * num_queues > + > + testpmd.set_ports_queues(num_queues) > + testpmd.start_all_ports() > + > + # Ensure mbuf_fast_free is disabled by default on port and > queues > + self.verify( > + self._check_config(testpmd, None, "tx", port_id, > queue_off, verify=verify), > + "MBUF_FAST_FREE enabled on queue start.", > + ) > + # Enable mbuf_fast_free per queue and verify > + self._set_all_queues_mbuf_fast_free(testpmd, True, port_id, > num_queues, verify) > + self.verify( > + self._check_config(testpmd, None, "tx", port_id, > queue_on, verify), > + "Failed to enable MBUF_FAST_FREE on all queues.", > + ) > + # Disable mbuf_fast_free per queue and verify > + self._set_all_queues_mbuf_fast_free(testpmd, False, port_id, > num_queues, verify) > + self.verify( > + self._check_config(testpmd, None, "tx", port_id, > queue_off, verify), > + "Failed to disable MBUF_FAST_FREE on all queues.", > + ) > -- > 2.50.1 > > Let's look at the testcases themselves together tomorrow or Friday. Thanks Andrew. [-- Attachment #2: Type: text/html, Size: 9435 bytes --] ^ permalink raw reply [flat|nested] 22+ messages in thread
* [PATCH v5 0/3] dts: add tx_offload support in dts [not found] <20250902114327.48185-1-abailey@iol.unh.edu> ` (3 preceding siblings ...) 2025-09-24 16:47 ` [PATCH v4 0/3] dts:add " Andrew Bailey @ 2025-09-29 17:06 ` Andrew Bailey 2025-09-29 17:06 ` [PATCH v5 1/3] dts: allow mbuf_fast_free to be set with testpmd shell Andrew Bailey 2025-09-29 17:06 ` [PATCH v5 3/3] dts: update tx_offload test from old dts Andrew Bailey 2025-09-29 17:27 ` [PATCH v6 0/3] dts: add tx_offload support in dts Andrew Bailey 5 siblings, 2 replies; 22+ messages in thread From: Andrew Bailey @ 2025-09-29 17:06 UTC (permalink / raw) To: luca.vizzarro; +Cc: dev, dmarx, ivan.malov, probb, Andrew Bailey This patchset introduces the support for Tx offload configuration through DTS, allowing test cases to be written utilizing Tx offload capabilities. Along with configuring these capabilities, they are also added to the NIC capabilities class, in which they can be required by test suites. Finally, a test suite was created using the aforementioned changes to update the Rx\Tx offload test suite in legacy DTS. --- v2: * Removed mentions of mbuf_fast_free being configured for Rx queues/ports as this is not accurate behaviour. * Clarify argument descriptions in docstrings. v3: * Added seperation between port and queue capabilites as it is relevant to the added test case that queues support mbuf fast free configuration. * Homogenized methods for getting Rx and Tx offload capabilities and configurations * Moved to use the text parser to gather the configuration, rather than returning the raw string output. * Updated test suites to use the new ports/queues offload flags in the requires decorator * Updated mbuf fast free test suite to test ports and queues individually. Along with updating the way it confirms the configuration to be consistent with the new process of getting the configuration. * Moved the get configuration method to the get nic capability patch as it is more relevant to that patches context. v4: * Cleaned up some typing issues in testpmd, and moved where prefixes are passed to the capability flags. * Added documentation page for test suite. * Removed use of optional in the added test suite. v5: * Moved configuration and capability handling to proper files in the api directory. * Updated Tx capability flags to adhere to the new way of handling them. * Test suites no longer need to worry about using the flag prefixes when analyzing offload configurations, but will still need to for required capabilities. Andrew Bailey (3): dts: allow mbuf_fast_free to be set with testpmd shell dts: add TX offload capabilities to NIC capabilities dts: update tx_offload test from old dts doc/api/dts/tests.TestSuite_rx_tx_offload.rst | 8 + dts/api/capabilities.py | 126 ++++++++-- dts/api/testpmd/__init__.py | 157 +++++++++++- dts/api/testpmd/types.py | 227 +++++++++++++----- dts/dpdk-24.11.3.tar.xz | Bin 0 -> 17402176 bytes dts/framework/parser.py | 30 +++ dts/framework/testbed_model/capability.py | 109 +++++++-- dts/tests/TestSuite_checksum_offload.py | 10 +- dts/tests/TestSuite_pmd_buffer_scatter.py | 4 +- dts/tests/TestSuite_rx_tx_offload.py | 126 ++++++++++ dts/tests/TestSuite_vlan.py | 4 +- 11 files changed, 683 insertions(+), 118 deletions(-) create mode 100644 doc/api/dts/tests.TestSuite_rx_tx_offload.rst create mode 100644 dts/dpdk-24.11.3.tar.xz create mode 100644 dts/tests/TestSuite_rx_tx_offload.py -- 2.50.1 ^ permalink raw reply [flat|nested] 22+ messages in thread
* [PATCH v5 1/3] dts: allow mbuf_fast_free to be set with testpmd shell 2025-09-29 17:06 ` [PATCH v5 0/3] dts: add tx_offload support in dts Andrew Bailey @ 2025-09-29 17:06 ` Andrew Bailey 2025-09-29 17:06 ` [PATCH v5 3/3] dts: update tx_offload test from old dts Andrew Bailey 1 sibling, 0 replies; 22+ messages in thread From: Andrew Bailey @ 2025-09-29 17:06 UTC (permalink / raw) To: luca.vizzarro; +Cc: dev, dmarx, ivan.malov, probb, Andrew Bailey Currently, there is no way in the testpmd shell class to set the mbuf fast free offload configuration for queues or ports. This prohibits any test suites to be written utilizing this offload configuration. Introduce methods that support calls to testpmd in order to allow the configuration of mbuf fast free. Signed-off-by: Andrew Bailey <abailey@iol.unh.edu> --- dts/api/testpmd/__init__.py | 60 +++++++++++++++++++++++++++++++++++++ 1 file changed, 60 insertions(+) diff --git a/dts/api/testpmd/__init__.py b/dts/api/testpmd/__init__.py index a060ab5639..39696ddde2 100644 --- a/dts/api/testpmd/__init__.py +++ b/dts/api/testpmd/__init__.py @@ -1292,3 +1292,63 @@ def get_capabilities_physical_function( supported_capabilities.add(NicCapability.PHYSICAL_FUNCTION) else: unsupported_capabilities.add(NicCapability.PHYSICAL_FUNCTION) + + @_requires_stopped_ports + def set_port_mbuf_fast_free( + self, + on: bool, + port_id: int, + /, + verify: bool = True, + ) -> None: + """Sets the mbuf_fast_free configuration for the Tx offload of a given port. + + Args: + on: If :data:`True` mbuf_fast_free will be enabled, disable it otherwise. + port_id: The ID of the port to configure mbuf_fast_free on. + verify: If :data:`True` the output of the command will be scanned in an attempt to + verify that the mbuf_fast_free was set successfully. + + Raises: + InteractiveCommandExecutionError: If mbuf_fast_free could not be set successfully. + """ + mbuf_output = self.send_command( + f"port config {port_id} tx_offload mbuf_fast_free {"on" if on else "off"}" + ) + + if verify and "Error" in mbuf_output: + raise InteractiveCommandExecutionError( + f"Unable to set mbuf_fast_free config on port {port_id}:\n{mbuf_output}" + ) + + @_requires_stopped_ports + def set_queue_mbuf_fast_free( + self, + on: bool, + port_id: int, + /, + queue_id: int = 0, + verify: bool = True, + ) -> None: + """Sets the Tx mbuf_fast_free configuration of the specified queue on a given port. + + Args: + on: If :data:`True` the mbuf_fast_free configuration will be enabled, otherwise + disabled. + port_id: The ID of the port containing the queues. + queue_id: The ID of the queue to configure mbuf_fast_free on. + verify: If :data:`True` the output of the command will be scanned in an attempt to + verify that mbuf_fast_free was set successfully on all ports. + + Raises: + InteractiveCommandExecutionError: If all queues could not be set successfully. + """ + toggle = "on" if on else "off" + output = self.send_command( + f"port {port_id} txq {queue_id} tx_offload mbuf_fast_free {toggle}" + ) + if verify and "Error" in output: + self._logger.debug(f"Set queue offload config error\n{output}") + raise InteractiveCommandExecutionError( + f"Failed to get offload config on port {port_id}, queue {queue_id}:\n{output}" + ) -- 2.50.1 ^ permalink raw reply related [flat|nested] 22+ messages in thread
* [PATCH v5 3/3] dts: update tx_offload test from old dts 2025-09-29 17:06 ` [PATCH v5 0/3] dts: add tx_offload support in dts Andrew Bailey 2025-09-29 17:06 ` [PATCH v5 1/3] dts: allow mbuf_fast_free to be set with testpmd shell Andrew Bailey @ 2025-09-29 17:06 ` Andrew Bailey 1 sibling, 0 replies; 22+ messages in thread From: Andrew Bailey @ 2025-09-29 17:06 UTC (permalink / raw) To: luca.vizzarro; +Cc: dev, dmarx, ivan.malov, probb, Andrew Bailey Currently, the RX/TX offload test in old DTS expects the TX ports to be initially configured to use mbuf fast free. This is no longer the case and must be updated to assume mbuf fast free is not initially utilized by capable NICs. Add updated test suite to test mbuf fast free configuration. Signed-off-by: Andrew Bailey <abailey@iol.unh.edu> --- doc/api/dts/tests.TestSuite_rx_tx_offload.rst | 8 ++ dts/tests/TestSuite_rx_tx_offload.py | 126 ++++++++++++++++++ 2 files changed, 134 insertions(+) create mode 100644 doc/api/dts/tests.TestSuite_rx_tx_offload.rst create mode 100644 dts/tests/TestSuite_rx_tx_offload.py diff --git a/doc/api/dts/tests.TestSuite_rx_tx_offload.rst b/doc/api/dts/tests.TestSuite_rx_tx_offload.rst new file mode 100644 index 0000000000..27834a74da --- /dev/null +++ b/doc/api/dts/tests.TestSuite_rx_tx_offload.rst @@ -0,0 +1,8 @@ +.. SPDX-License-Identifier: BSD-3-Clause + +rx_tx_offload Test Suite +======================== + +.. automodule:: tests.TestSuite_rx_tx_offload + :members: + :show-inheritance: diff --git a/dts/tests/TestSuite_rx_tx_offload.py b/dts/tests/TestSuite_rx_tx_offload.py new file mode 100644 index 0000000000..19a8e507f2 --- /dev/null +++ b/dts/tests/TestSuite_rx_tx_offload.py @@ -0,0 +1,126 @@ +# SPDX-License-Identifier: BSD-3-Clause +# Copyright(c) 2025 University of New Hampshire + +"""RX TX offload test suite. + +Test the testpmd feature of configuring RX and TX offloads. +""" + +from api.capabilities import NicCapability, requires_nic_capability +from api.testpmd import TestPmd +from api.testpmd.types import ( + OffloadConfiguration, + RxTxLiteralSwitch, +) +from framework.test_suite import TestSuite, func_test + + +class TestRxTxOffload(TestSuite): + """RX/TX offload test suite.""" + + def _check_config( + self, + testpmd: TestPmd, + port_offload: str | None, + rxtx: RxTxLiteralSwitch, + port_id: int, + /, + queue_offload: list[str | None] | None = None, + verify: bool = True, + ) -> bool: + config: OffloadConfiguration = testpmd.get_offload_config(rxtx, port_id, verify) + if config.port.name != port_offload: + return False + + if queue_offload: + for i, q in enumerate(config.queues): + if q.name != queue_offload[i]: + return False + return True + + def _set_all_queues_mbuf_fast_free( + self, testpmd: TestPmd, on: bool, port_id: int, num_queues: int, /, verify: bool = True + ) -> None: + for i in range(num_queues): + testpmd.set_queue_mbuf_fast_free(on, port_id, i, verify) + + @requires_nic_capability(NicCapability.PORT_TX_OFFLOAD_MBUF_FAST_FREE) + @func_test + def test_mbuf_fast_free_configuration_per_port(self) -> None: + """Ensure mbuf_fast_free can be configured with testpmd per port. + + Steps: + * Start up testpmd shell. + * Toggle mbuf_fast_free on per port. + * Toggle mbuf_fast_free off per port. + + Verify: + * Mbuf_fast_free starts disabled. + * Mbuf_fast_free can be configured on per port. + * Mbuf_fast_free can be configured off per port. + """ + with TestPmd() as testpmd: + verify = True + port_id = 0 + testpmd.start_all_ports() + + # Ensure MBUF_FAST_FREE is disabled by default and verify + self.verify( + self._check_config(testpmd, None, "tx", port_id, verify=verify), + "MBUF_FAST_FREE enabled on port start.", + ) + # Enable MBUF_FAST_FREE per port and verify + testpmd.set_port_mbuf_fast_free(True, port_id, verify) + self.verify( + self._check_config(testpmd, "MBUF_FAST_FREE", "tx", port_id, verify=verify), + "Failed to enable MBUF_FAST_FREE on port.", + ) + # Disable MBUF_FAST_FREE per port and verify + testpmd.set_port_mbuf_fast_free(False, port_id, verify) + self.verify( + self._check_config(testpmd, None, "tx", port_id, verify=verify), + "Failed to disable MBUF_FAST_FREE on port.", + ) + + @requires_nic_capability(NicCapability.QUEUE_TX_OFFLOAD_MBUF_FAST_FREE) + @func_test + def test_mbuf_fast_free_configuration_per_queue(self) -> None: + """Ensure mbuf_fast_free can be configured with testpmd. + + Steps: + * Start up testpmd shell. + * Toggle mbuf_fast_free on per queue. + * Toggle mbuf_fast_free off per queue. + + Verify: + * Mbuf_fast_free starts disabled. + * Mbuf_fast_free can be configured on per queue. + * Mbuf_fast_free can be configured off per queue. + """ + with TestPmd() as testpmd: + verify = True + port_id = 0 + num_queues = 4 + queue_off: list[str | None] | None = [None] * num_queues + queue_on: list[str | None] | None = ["MBUF_FAST_FREE"] * num_queues + + testpmd.set_ports_queues(num_queues) + testpmd.start_all_ports() + + # Ensure mbuf_fast_free is disabled by default on port and queues + self.verify( + self._check_config(testpmd, None, "tx", port_id, queue_off, verify=verify), + "MBUF_FAST_FREE enabled on queue start.", + ) + # Enable mbuf_fast_free per queue and verify + self._set_all_queues_mbuf_fast_free(testpmd, True, port_id, num_queues, verify) + self.verify( + self._check_config(testpmd, None, "tx", port_id, queue_on, verify), + "Failed to enable MBUF_FAST_FREE on all queues.", + ) + # Disable mbuf_fast_free per queue and verify + self._set_all_queues_mbuf_fast_free(testpmd, False, port_id, num_queues, verify) + self.verify( + self._check_config(testpmd, None, "tx", port_id, queue_off, verify), + "Failed to disable MBUF_FAST_FREE on all queues.", + ) -- 2.50.1 ^ permalink raw reply related [flat|nested] 22+ messages in thread
* [PATCH v6 0/3] dts: add tx_offload support in dts [not found] <20250902114327.48185-1-abailey@iol.unh.edu> ` (4 preceding siblings ...) 2025-09-29 17:06 ` [PATCH v5 0/3] dts: add tx_offload support in dts Andrew Bailey @ 2025-09-29 17:27 ` Andrew Bailey 2025-09-29 17:27 ` [PATCH v6 1/3] dts: allow mbuf_fast_free to be set with testpmd shell Andrew Bailey ` (2 more replies) 5 siblings, 3 replies; 22+ messages in thread From: Andrew Bailey @ 2025-09-29 17:27 UTC (permalink / raw) To: luca.vizzarro; +Cc: dev, dmarx, ivan.malov, probb, Andrew Bailey This patchset introduces the support for Tx offload configuration through DTS, allowing test cases to be written utilizing Tx offload capabilities. Along with configuring these capabilities, they are also added to the NIC capabilities class, in which they can be required by test suites. Finally, a test suite was created using the aforementioned changes to update the Rx\Tx offload test suite in legacy DTS. --- v2: * Removed mentions of mbuf_fast_free being configured for Rx queues/ports as this is not accurate behaviour. * Clarify argument descriptions in docstrings. v3: * Added seperation between port and queue capabilites as it is relevant to the added test case that queues support mbuf fast free configuration. * Homogenized methods for getting Rx and Tx offload capabilities and configurations * Moved to use the text parser to gather the configuration, rather than returning the raw string output. * Updated test suites to use the new ports/queues offload flags in the requires decorator * Updated mbuf fast free test suite to test ports and queues individually. Along with updating the way it confirms the configuration to be consistent with the new process of getting the configuration. * Moved the get configuration method to the get nic capability patch as it is more relevant to that patches context. v4: * Cleaned up some typing issues in testpmd, and moved where prefixes are passed to the capability flags. * Added documentation page for test suite. * Removed use of optional in the added test suite. v5: * Moved configuration and capability handling to proper files in the api directory. * Updated Tx capability flags to adhere to the new way of handling them. * Test suites no longer need to worry about using the flag prefixes when analyzing offload configurations, but will still need to for required capabilities. Andrew Bailey (3): dts: allow mbuf_fast_free to be set with testpmd shell dts: add TX offload capabilities to NIC capabilities dts: update tx_offload test from old dts doc/api/dts/tests.TestSuite_rx_tx_offload.rst | 8 + dts/api/capabilities.py | 126 ++++++++-- dts/api/testpmd/__init__.py | 157 +++++++++++- dts/api/testpmd/types.py | 227 +++++++++++++----- dts/framework/parser.py | 30 +++ dts/framework/testbed_model/capability.py | 109 +++++++-- dts/tests/TestSuite_checksum_offload.py | 10 +- dts/tests/TestSuite_pmd_buffer_scatter.py | 4 +- dts/tests/TestSuite_rx_tx_offload.py | 126 ++++++++++ dts/tests/TestSuite_vlan.py | 4 +- 10 files changed, 683 insertions(+), 118 deletions(-) create mode 100644 doc/api/dts/tests.TestSuite_rx_tx_offload.rst create mode 100644 dts/tests/TestSuite_rx_tx_offload.py -- 2.50.1 ^ permalink raw reply [flat|nested] 22+ messages in thread
* [PATCH v6 1/3] dts: allow mbuf_fast_free to be set with testpmd shell 2025-09-29 17:27 ` [PATCH v6 0/3] dts: add tx_offload support in dts Andrew Bailey @ 2025-09-29 17:27 ` Andrew Bailey 2025-09-30 12:51 ` Luca Vizzarro 2025-09-29 17:27 ` [PATCH v6 2/3] dts: add TX offload capabilities to NIC capabilities Andrew Bailey 2025-09-29 17:27 ` [PATCH v6 3/3] dts: update tx_offload test from old dts Andrew Bailey 2 siblings, 1 reply; 22+ messages in thread From: Andrew Bailey @ 2025-09-29 17:27 UTC (permalink / raw) To: luca.vizzarro; +Cc: dev, dmarx, ivan.malov, probb, Andrew Bailey Currently, there is no way in the testpmd shell class to set the mbuf fast free offload configuration for queues or ports. This prohibits any test suites to be written utilizing this offload configuration. Introduce methods that support calls to testpmd in order to allow the configuration of mbuf fast free. Signed-off-by: Andrew Bailey <abailey@iol.unh.edu> --- dts/api/testpmd/__init__.py | 60 +++++++++++++++++++++++++++++++++++++ 1 file changed, 60 insertions(+) diff --git a/dts/api/testpmd/__init__.py b/dts/api/testpmd/__init__.py index a060ab5639..39696ddde2 100644 --- a/dts/api/testpmd/__init__.py +++ b/dts/api/testpmd/__init__.py @@ -1292,3 +1292,63 @@ def get_capabilities_physical_function( supported_capabilities.add(NicCapability.PHYSICAL_FUNCTION) else: unsupported_capabilities.add(NicCapability.PHYSICAL_FUNCTION) + + @_requires_stopped_ports + def set_port_mbuf_fast_free( + self, + on: bool, + port_id: int, + /, + verify: bool = True, + ) -> None: + """Sets the mbuf_fast_free configuration for the Tx offload of a given port. + + Args: + on: If :data:`True` mbuf_fast_free will be enabled, disable it otherwise. + port_id: The ID of the port to configure mbuf_fast_free on. + verify: If :data:`True` the output of the command will be scanned in an attempt to + verify that the mbuf_fast_free was set successfully. + + Raises: + InteractiveCommandExecutionError: If mbuf_fast_free could not be set successfully. + """ + mbuf_output = self.send_command( + f"port config {port_id} tx_offload mbuf_fast_free {"on" if on else "off"}" + ) + + if verify and "Error" in mbuf_output: + raise InteractiveCommandExecutionError( + f"Unable to set mbuf_fast_free config on port {port_id}:\n{mbuf_output}" + ) + + @_requires_stopped_ports + def set_queue_mbuf_fast_free( + self, + on: bool, + port_id: int, + /, + queue_id: int = 0, + verify: bool = True, + ) -> None: + """Sets the Tx mbuf_fast_free configuration of the specified queue on a given port. + + Args: + on: If :data:`True` the mbuf_fast_free configuration will be enabled, otherwise + disabled. + port_id: The ID of the port containing the queues. + queue_id: The ID of the queue to configure mbuf_fast_free on. + verify: If :data:`True` the output of the command will be scanned in an attempt to + verify that mbuf_fast_free was set successfully on all ports. + + Raises: + InteractiveCommandExecutionError: If all queues could not be set successfully. + """ + toggle = "on" if on else "off" + output = self.send_command( + f"port {port_id} txq {queue_id} tx_offload mbuf_fast_free {toggle}" + ) + if verify and "Error" in output: + self._logger.debug(f"Set queue offload config error\n{output}") + raise InteractiveCommandExecutionError( + f"Failed to get offload config on port {port_id}, queue {queue_id}:\n{output}" + ) -- 2.50.1 ^ permalink raw reply related [flat|nested] 22+ messages in thread
* Re: [PATCH v6 1/3] dts: allow mbuf_fast_free to be set with testpmd shell 2025-09-29 17:27 ` [PATCH v6 1/3] dts: allow mbuf_fast_free to be set with testpmd shell Andrew Bailey @ 2025-09-30 12:51 ` Luca Vizzarro 0 siblings, 0 replies; 22+ messages in thread From: Luca Vizzarro @ 2025-09-30 12:51 UTC (permalink / raw) To: Andrew Bailey; +Cc: dev, dmarx, ivan.malov, probb Reviewed-by: Luca Vizzarro <luca.vizzarro@arm.com> ^ permalink raw reply [flat|nested] 22+ messages in thread
* [PATCH v6 2/3] dts: add TX offload capabilities to NIC capabilities 2025-09-29 17:27 ` [PATCH v6 0/3] dts: add tx_offload support in dts Andrew Bailey 2025-09-29 17:27 ` [PATCH v6 1/3] dts: allow mbuf_fast_free to be set with testpmd shell Andrew Bailey @ 2025-09-29 17:27 ` Andrew Bailey 2025-09-30 12:55 ` Luca Vizzarro 2025-09-29 17:27 ` [PATCH v6 3/3] dts: update tx_offload test from old dts Andrew Bailey 2 siblings, 1 reply; 22+ messages in thread From: Andrew Bailey @ 2025-09-29 17:27 UTC (permalink / raw) To: luca.vizzarro Cc: dev, dmarx, ivan.malov, probb, Andrew Bailey, Jeremy Spewock Currently, there is no support for tracking tx_offload capabilities and there is no separation between port capabilities and queue capabilities. This is an issue if a test case requires a tx_offload capability or if a test case requires that a card supports a capability on a queue. This causes test cases with said requirements to not be skipped when appropriate. Add tx_offload capabilities and distinguish capabilities between ports and queues. Signed-off-by: Andrew Bailey <abailey@iol.unh.edu> Signed-off-by: Jeremy Spewock <jspewock@iol.unh.edu> --- dts/api/capabilities.py | 126 ++++++++++-- dts/api/testpmd/__init__.py | 97 ++++++++- dts/api/testpmd/types.py | 227 +++++++++++++++------- dts/framework/parser.py | 30 +++ dts/framework/testbed_model/capability.py | 109 +++++++++-- dts/tests/TestSuite_checksum_offload.py | 10 +- dts/tests/TestSuite_pmd_buffer_scatter.py | 4 +- dts/tests/TestSuite_vlan.py | 4 +- 8 files changed, 489 insertions(+), 118 deletions(-) diff --git a/dts/api/capabilities.py b/dts/api/capabilities.py index 1a79413f6f..243759668f 100644 --- a/dts/api/capabilities.py +++ b/dts/api/capabilities.py @@ -77,45 +77,65 @@ class NicCapability(IntEnum): #: Scattered packets Rx enabled. SCATTERED_RX_ENABLED = 0 #: Device supports VLAN stripping. - RX_OFFLOAD_VLAN_STRIP = auto() + PORT_RX_OFFLOAD_VLAN_STRIP = auto() + QUEUE_RX_OFFLOAD_VLAN_STRIP = auto() #: Device supports L3 checksum offload. - RX_OFFLOAD_IPV4_CKSUM = auto() + PORT_RX_OFFLOAD_IPV4_CKSUM = auto() + QUEUE_RX_OFFLOAD_IPV4_CKSUM = auto() #: Device supports L4 checksum offload. - RX_OFFLOAD_UDP_CKSUM = auto() + PORT_RX_OFFLOAD_UDP_CKSUM = auto() + QUEUE_RX_OFFLOAD_UDP_CKSUM = auto() #: Device supports L4 checksum offload. - RX_OFFLOAD_TCP_CKSUM = auto() + PORT_RX_OFFLOAD_TCP_CKSUM = auto() + QUEUE_RX_OFFLOAD_TCP_CKSUM = auto() #: Device supports Large Receive Offload. - RX_OFFLOAD_TCP_LRO = auto() + PORT_RX_OFFLOAD_TCP_LRO = auto() + QUEUE_RX_OFFLOAD_TCP_LRO = auto() #: Device supports QinQ (queue in queue) offload. - RX_OFFLOAD_QINQ_STRIP = auto() + PORT_RX_OFFLOAD_QINQ_STRIP = auto() + QUEUE_RX_OFFLOAD_QINQ_STRIP = auto() #: Device supports inner packet L3 checksum. - RX_OFFLOAD_OUTER_IPV4_CKSUM = auto() + PORT_RX_OFFLOAD_OUTER_IPV4_CKSUM = auto() + QUEUE_RX_OFFLOAD_OUTER_IPV4_CKSUM = auto() #: Device supports MACsec. - RX_OFFLOAD_MACSEC_STRIP = auto() + PORT_RX_OFFLOAD_MACSEC_STRIP = auto() + QUEUE_RX_OFFLOAD_MACSEC_STRIP = auto() #: Device supports filtering of a VLAN Tag identifier. - RX_OFFLOAD_VLAN_FILTER = auto() + PORT_RX_OFFLOAD_VLAN_FILTER = auto() + QUEUE_RX_OFFLOAD_VLAN_FILTER = auto() #: Device supports VLAN offload. - RX_OFFLOAD_VLAN_EXTEND = auto() + PORT_RX_OFFLOAD_VLAN_EXTEND = auto() + QUEUE_RX_OFFLOAD_VLAN_EXTEND = auto() #: Device supports receiving segmented mbufs. - RX_OFFLOAD_SCATTER = auto() + PORT_RX_OFFLOAD_SCATTER = auto() + QUEUE_RX_OFFLOAD_SCATTER = auto() #: Device supports Timestamp. - RX_OFFLOAD_TIMESTAMP = auto() + PORT_RX_OFFLOAD_TIMESTAMP = auto() + QUEUE_RX_OFFLOAD_TIMESTAMP = auto() #: Device supports crypto processing while packet is received in NIC. - RX_OFFLOAD_SECURITY = auto() + PORT_RX_OFFLOAD_SECURITY = auto() + QUEUE_RX_OFFLOAD_SECURITY = auto() #: Device supports CRC stripping. - RX_OFFLOAD_KEEP_CRC = auto() + PORT_RX_OFFLOAD_KEEP_CRC = auto() + QUEUE_RX_OFFLOAD_KEEP_CRC = auto() #: Device supports L4 checksum offload. - RX_OFFLOAD_SCTP_CKSUM = auto() + PORT_RX_OFFLOAD_SCTP_CKSUM = auto() + QUEUE_RX_OFFLOAD_SCTP_CKSUM = auto() #: Device supports inner packet L4 checksum. - RX_OFFLOAD_OUTER_UDP_CKSUM = auto() + PORT_RX_OFFLOAD_OUTER_UDP_CKSUM = auto() + QUEUE_RX_OFFLOAD_OUTER_UDP_CKSUM = auto() #: Device supports RSS hashing. - RX_OFFLOAD_RSS_HASH = auto() + PORT_RX_OFFLOAD_RSS_HASH = auto() + QUEUE_RX_OFFLOAD_RSS_HASH = auto() #: Device supports scatter Rx packets to segmented mbufs. - RX_OFFLOAD_BUFFER_SPLIT = auto() + PORT_RX_OFFLOAD_BUFFER_SPLIT = auto() + QUEUE_RX_OFFLOAD_BUFFER_SPLIT = auto() #: Device supports all checksum capabilities. - RX_OFFLOAD_CHECKSUM = auto() + PORT_RX_OFFLOAD_CHECKSUM = auto() + QUEUE_RX_OFFLOAD_CHECKSUM = auto() #: Device supports all VLAN capabilities. - RX_OFFLOAD_VLAN = auto() + PORT_RX_OFFLOAD_VLAN = auto() + QUEUE_RX_OFFLOAD_VLAN = auto() #: Device supports Rx queue setup after device started. RUNTIME_RX_QUEUE_SETUP = auto() #: Device supports Tx queue setup after device started. @@ -132,6 +152,72 @@ class NicCapability(IntEnum): FLOW_CTRL = auto() #: Device is running on a physical function. PHYSICAL_FUNCTION = auto() + #: + PORT_TX_OFFLOAD_VLAN_INSERT = auto() + QUEUE_TX_OFFLOAD_VLAN_INSERT = auto() + #: + PORT_TX_OFFLOAD_IPV4_CKSUM = auto() + QUEUE_TX_OFFLOAD_IPV4_CKSUM = auto() + #: + PORT_TX_OFFLOAD_UDP_CKSUM = auto() + QUEUE_TX_OFFLOAD_UDP_CKSUM = auto() + #: + PORT_TX_OFFLOAD_TCP_CKSUM = auto() + QUEUE_TX_OFFLOAD_TCP_CKSUM = auto() + #: + PORT_TX_OFFLOAD_SCTP_CKSUM = auto() + QUEUE_TX_OFFLOAD_SCTP_CKSUM = auto() + #: + PORT_TX_OFFLOAD_TCP_TSO = auto() + QUEUE_TX_OFFLOAD_TCP_TSO = auto() + #: + PORT_TX_OFFLOAD_UDP_TSO = auto() + QUEUE_TX_OFFLOAD_UDP_TSO = auto() + #: + PORT_TX_OFFLOAD_OUTER_IPV4_CKSUM = auto() + QUEUE_TX_OFFLOAD_OUTER_IPV4_CKSUM = auto() + #: + PORT_TX_OFFLOAD_QINQ_INSERT = auto() + QUEUE_TX_OFFLOAD_QINQ_INSERT = auto() + #: + PORT_TX_OFFLOAD_VXLAN_TNL_TSO = auto() + QUEUE_TX_OFFLOAD_VXLAN_TNL_TSO = auto() + #: + PORT_TX_OFFLOAD_GRE_TNL_TSO = auto() + QUEUE_TX_OFFLOAD_GRE_TNL_TSO = auto() + #: + PORT_TX_OFFLOAD_IPIP_TNL_TSO = auto() + QUEUE_TX_OFFLOAD_IPIP_TNL_TSO = auto() + #: + PORT_TX_OFFLOAD_GENEVE_TNL_TSO = auto() + QUEUE_TX_OFFLOAD_GENEVE_TNL_TSO = auto() + #: + PORT_TX_OFFLOAD_MACSEC_INSERT = auto() + QUEUE_TX_OFFLOAD_MACSEC_INSERT = auto() + #: + PORT_TX_OFFLOAD_MT_LOCKFREE = auto() + QUEUE_TX_OFFLOAD_MT_LOCKFREE = auto() + #: + PORT_TX_OFFLOAD_MULTI_SEGS = auto() + QUEUE_TX_OFFLOAD_MULTI_SEGS = auto() + #: + PORT_TX_OFFLOAD_MBUF_FAST_FREE = auto() + QUEUE_TX_OFFLOAD_MBUF_FAST_FREE = auto() + #: + PORT_TX_OFFLOAD_SECURITY = auto() + QUEUE_TX_OFFLOAD_SECURITY = auto() + #: + PORT_TX_OFFLOAD_UDP_TNL_TSO = auto() + QUEUE_TX_OFFLOAD_UDP_TNL_TSO = auto() + #: + PORT_TX_OFFLOAD_IP_TNL_TSO = auto() + QUEUE_TX_OFFLOAD_IP_TNL_TSO = auto() + #: + PORT_TX_OFFLOAD_OUTER_UDP_CKSUM = auto() + QUEUE_TX_OFFLOAD_OUTER_UDP_CKSUM = auto() + #: + PORT_TX_OFFLOAD_SEND_ON_TIMESTAMP = auto() + QUEUE_TX_OFFLOAD_SEND_ON_TIMESTAMP = auto() def requires_link_topology( diff --git a/dts/api/testpmd/__init__.py b/dts/api/testpmd/__init__.py index 39696ddde2..90c44b5adc 100644 --- a/dts/api/testpmd/__init__.py +++ b/dts/api/testpmd/__init__.py @@ -39,6 +39,8 @@ FlowRule, RxOffloadCapabilities, RxOffloadCapability, + RxOffloadConfiguration, + RxTxLiteralSwitch, TestPmdDevice, TestPmdPort, TestPmdPortFlowCtrl, @@ -46,6 +48,9 @@ TestPmdQueueInfo, TestPmdRxqInfo, TestPmdVerbosePacket, + TxOffloadCapabilities, + TxOffloadCapability, + TxOffloadConfiguration, VLANOffloadFlag, ) from framework.context import get_ctx @@ -1190,13 +1195,14 @@ def _update_capabilities_from_flag( unsupported_capabilities: MutableSet["NicCapability"], flag_class: type[Flag], supported_flags: Flag, + prefix: str = "", ) -> None: """Divide all flags from `flag_class` into supported and unsupported.""" for flag in flag_class: if flag in supported_flags: - supported_capabilities.add(NicCapability[str(flag.name)]) + supported_capabilities.add(NicCapability[f"{prefix}{flag.name}"]) else: - unsupported_capabilities.add(NicCapability[str(flag.name)]) + unsupported_capabilities.add(NicCapability[f"{prefix}{flag.name}"]) @_requires_started_ports def get_capabilities_rxq_info( @@ -1293,6 +1299,55 @@ def get_capabilities_physical_function( else: unsupported_capabilities.add(NicCapability.PHYSICAL_FUNCTION) + @staticmethod + def get_offload_capabilities_func( + rxtx: RxTxLiteralSwitch, + ) -> Callable[["TestPmd", MutableSet["NicCapability"], MutableSet["NicCapability"]], None]: + """High-order function that returns a method for gathering Rx/Tx offload capabilities. + + Args: + rxtx: whether to gather the rx or tx capabilities in the returned method. + + Returns: + A method for gathering Rx/Tx offload capabilities that meets the required structure. + """ + + def get_capabilities( + self: "TestPmd", + supported_capabilities: MutableSet["NicCapability"], + unsupported_capabilities: MutableSet["NicCapability"], + ) -> None: + """Get all rx/tx offload capabilities and divide them into supported and unsupported. + + Args: + self: The shell instance to get the capabilities from. + supported_capabilities: Supported capabilities will be added to this set. + unsupported_capabilities: Unsupported capabilities will be added to this set. + """ + self._logger.info(f"Getting {rxtx} offload capabilities.") + command = f"show port {self.ports[0].id} {rxtx}_offload capabilities" + offload_capabilities_out = self.send_command(command) + + capabilities = TxOffloadCapabilities if rxtx == "tx" else RxOffloadCapabilities + offload_capabilities = capabilities.parse(offload_capabilities_out) + + self._update_capabilities_from_flag( + supported_capabilities, + unsupported_capabilities, + TxOffloadCapability if rxtx == "tx" else RxOffloadCapability, + offload_capabilities.per_port | offload_capabilities.per_queue, + prefix=f"PORT_{rxtx.upper()}_OFFLOAD_", + ) + self._update_capabilities_from_flag( + supported_capabilities, + unsupported_capabilities, + TxOffloadCapability if rxtx == "tx" else RxOffloadCapability, + offload_capabilities.per_queue, + prefix=f"QUEUE_{rxtx.upper()}_OFFLOAD_", + ) + + return get_capabilities + @_requires_stopped_ports def set_port_mbuf_fast_free( self, @@ -1352,3 +1407,41 @@ def set_queue_mbuf_fast_free( raise InteractiveCommandExecutionError( f"Failed to get offload config on port {port_id}, queue {queue_id}:\n{output}" ) + + @_requires_started_ports + def get_offload_config( + self, + rxtx: RxTxLiteralSwitch, + port_id: int, + /, + verify: bool = True, + ) -> RxOffloadConfiguration | TxOffloadConfiguration: + """Get the Rx or Tx offload configuration of the queues from the given port. + + Args: + rxtx: Whether to get the Rx or Tx configuration of the given queues. + port_id: The port ID that contains the desired queues. + verify: If :data:`True` the output of the command will be scanned in an attempt to + verify that the offload configuration was retrieved successfully on all queues. + + Returns: + An offload configuration containing the capabilities of the port and queues. + + Raises: + InteractiveCommandExecutionError: If all queue offload configurations could not be + retrieved. + """ + config_output = self.send_command(f"show port {port_id} {rxtx}_offload configuration") + if verify: + if ( + f"Rx Offloading Configuration of port {port_id}" not in config_output + and f"Tx Offloading Configuration of port {port_id}" not in config_output + ): + self._logger.debug(f"Get port offload config error\n{config_output}") + raise InteractiveCommandExecutionError( + f"Failed to get offload config on port {port_id}:\n{config_output}" + ) + if rxtx == "rx": + return RxOffloadConfiguration.parse(config_output) + else: + return TxOffloadConfiguration.parse(config_output) diff --git a/dts/api/testpmd/types.py b/dts/api/testpmd/types.py index d1ebf6f2d1..46ae034cec 100644 --- a/dts/api/testpmd/types.py +++ b/dts/api/testpmd/types.py @@ -18,6 +18,8 @@ from framework.parser import ParserFn, TextParser from framework.utils import REGEX_FOR_MAC_ADDRESS, StrEnum +RxTxLiteralSwitch = Literal["rx", "tx"] + class TestPmdDevice: """The data of a device that testpmd can recognize. @@ -1246,7 +1248,99 @@ class TestPmdVerbosePacket(TextParser): ) -class RxOffloadCapability(Flag): +class OffloadCapability(Flag): + """Flags generated from RxOffloadCapabilites and TxOffloadCapabilities classes.""" + + @classmethod + def from_string(cls, line: str) -> Self: + """Make an instance from a string containing the flag names separated with a space. + + Args: + line: The line to parse. + + Returns: + A new instance containing all found flags. + """ + flag = cls(0) + for flag_name in line.split(): + flag |= cls[flag_name] + return flag + + @classmethod + def from_list(cls, lines: list[str]) -> list[Self]: + """Gather capabilities from a list of strings. + + Args: + lines: The list of capabilities to make flags from. + """ + return [cls.from_string(line) for line in lines] + + @classmethod + def make_parser( + cls, per_port: Literal["port", "queue"], /, find_multiple: bool = False + ) -> ParserFn: + """Make a parser function. + + Args: + per_port: If :data:`True`, will return capabilities per port. If :data:`False`, + will return capabilities per queue. + find_multiple: If :data:`True`, will use :func:`TextParser.find_all` to find all + matches for the regex query and return a list of instances based on those matches. + If :data:`False`, will return a single instance of the flag based off a single + match. + + Returns: + ParserFn: A dictionary for the `dataclasses.field` metadata argument containing a + parser function that makes an instance of this flag from text. + """ + granularity = per_port.capitalize() + regex = rf"{granularity}[\s\[\]\d]+:(.*)$" + if find_multiple: + return TextParser.wrap(TextParser.find_all(regex, re.MULTILINE), cls.from_list) + return TextParser.wrap(TextParser.find(regex, re.MULTILINE), cls.from_string) + + +class TxOffloadCapability(OffloadCapability): + """TX offload capabilities of a device. + + The flags are taken from ``lib/ethdev/rte_ethdev.h``. + They're prefixed with ``RTE_ETH_TX_OFFLOAD`` in ``lib/ethdev/rte_ethdev.h`` + instead of ``TX_OFFLOAD``, which is what testpmd changes the prefix to. + + The ``TX_OFFLOAD`` prefix has been preserved so that the same flag names can be used + in :class:`NicCapability`. The prefix is needed in :class:`NicCapability` since there's + no other qualifier which would sufficiently distinguish it from other capabilities. + + References: + DPDK lib: ``lib/ethdev/rte_ethdev.h`` + testpmd display function: ``app/test-pmd/cmdline.c:print_rx_offloads()`` + """ + + VLAN_INSERT = auto() + IPV4_CKSUM = auto() + UDP_CKSUM = auto() + TCP_CKSUM = auto() + SCTP_CKSUM = auto() + TCP_TSO = auto() + UDP_TSO = auto() + OUTER_IPV4_CKSUM = auto() + QINQ_INSERT = auto() + VXLAN_TNL_TSO = auto() + GRE_TNL_TSO = auto() + IPIP_TNL_TSO = auto() + GENEVE_TNL_TSO = auto() + MACSEC_INSERT = auto() + MT_LOCKFREE = auto() + MULTI_SEGS = auto() + MBUF_FAST_FREE = auto() + SECURITY = auto() + UDP_TNL_TSO = auto() + IP_TNL_TSO = auto() + OUTER_UDP_CKSUM = auto() + SEND_ON_TIMESTAMP = auto() + + +class RxOffloadCapability(OffloadCapability): """Rx offload capabilities of a device. The flags are taken from ``lib/ethdev/rte_ethdev.h``. @@ -1265,102 +1359,103 @@ class RxOffloadCapability(Flag): """ #: - RX_OFFLOAD_VLAN_STRIP = auto() + VLAN_STRIP = auto() #: Device supports L3 checksum offload. - RX_OFFLOAD_IPV4_CKSUM = auto() + IPV4_CKSUM = auto() #: Device supports L4 checksum offload. - RX_OFFLOAD_UDP_CKSUM = auto() + UDP_CKSUM = auto() #: Device supports L4 checksum offload. - RX_OFFLOAD_TCP_CKSUM = auto() + TCP_CKSUM = auto() #: Device supports Large Receive Offload. - RX_OFFLOAD_TCP_LRO = auto() + TCP_LRO = auto() #: Device supports QinQ (queue in queue) offload. - RX_OFFLOAD_QINQ_STRIP = auto() + QINQ_STRIP = auto() #: Device supports inner packet L3 checksum. - RX_OFFLOAD_OUTER_IPV4_CKSUM = auto() + OUTER_IPV4_CKSUM = auto() #: Device supports MACsec. - RX_OFFLOAD_MACSEC_STRIP = auto() + MACSEC_STRIP = auto() #: Device supports filtering of a VLAN Tag identifier. - RX_OFFLOAD_VLAN_FILTER = 1 << 9 + VLAN_FILTER = 1 << 9 #: Device supports VLAN offload. - RX_OFFLOAD_VLAN_EXTEND = auto() + VLAN_EXTEND = auto() #: Device supports receiving segmented mbufs. - RX_OFFLOAD_SCATTER = 1 << 13 + SCATTER = 1 << 13 #: Device supports Timestamp. - RX_OFFLOAD_TIMESTAMP = auto() + TIMESTAMP = auto() #: Device supports crypto processing while packet is received in NIC. - RX_OFFLOAD_SECURITY = auto() + SECURITY = auto() #: Device supports CRC stripping. - RX_OFFLOAD_KEEP_CRC = auto() + KEEP_CRC = auto() #: Device supports L4 checksum offload. - RX_OFFLOAD_SCTP_CKSUM = auto() + SCTP_CKSUM = auto() #: Device supports inner packet L4 checksum. - RX_OFFLOAD_OUTER_UDP_CKSUM = auto() + OUTER_UDP_CKSUM = auto() #: Device supports RSS hashing. - RX_OFFLOAD_RSS_HASH = auto() + RSS_HASH = auto() #: Device supports - RX_OFFLOAD_BUFFER_SPLIT = auto() + BUFFER_SPLIT = auto() #: Device supports all checksum capabilities. - RX_OFFLOAD_CHECKSUM = RX_OFFLOAD_IPV4_CKSUM | RX_OFFLOAD_UDP_CKSUM | RX_OFFLOAD_TCP_CKSUM + CHECKSUM = IPV4_CKSUM | UDP_CKSUM | TCP_CKSUM #: Device supports all VLAN capabilities. - RX_OFFLOAD_VLAN = ( - RX_OFFLOAD_VLAN_STRIP - | RX_OFFLOAD_VLAN_FILTER - | RX_OFFLOAD_VLAN_EXTEND - | RX_OFFLOAD_QINQ_STRIP - ) + VLAN = VLAN_STRIP | VLAN_FILTER | VLAN_EXTEND | QINQ_STRIP - @classmethod - def from_string(cls, line: str) -> Self: - """Make an instance from a string containing the flag names separated with a space. - Args: - line: The line to parse. +@dataclass +class OffloadCapabilities(TextParser): + """The result of testpmd's ``show port <port_id> rx/tx_offload capabilities`` command.""" - Returns: - A new instance containing all found flags. - """ - flag = cls(0) - for flag_name in line.split(): - flag |= cls[f"RX_OFFLOAD_{flag_name}"] - return flag + port_id: int = field(metadata=TextParser.find_int(r"Offloading Capabilities of port (\d+) :")) + #: Per-queue offload capabilities. + per_queue: OffloadCapability + #: Capabilities other than per-queue offload capabilities. + per_port: OffloadCapability - @classmethod - def make_parser(cls, per_port: bool) -> ParserFn: - """Make a parser function. - Args: - per_port: If :data:`True`, will return capabilities per port. If :data:`False`, - will return capabilities per queue. +@dataclass +class RxOffloadCapabilities(OffloadCapabilities): + """Extends :class:`OffloadCapabilities` with Rx specific functionality.""" - Returns: - ParserFn: A dictionary for the `dataclasses.field` metadata argument containing a - parser function that makes an instance of this flag from text. - """ - granularity = "Port" if per_port else "Queue" - return TextParser.wrap( - TextParser.find(rf"Per {granularity}\s+:(.*)$", re.MULTILINE), - cls.from_string, - ) + per_queue: OffloadCapability = field(metadata=RxOffloadCapability.make_parser("queue")) + per_port: OffloadCapability = field(metadata=RxOffloadCapability.make_parser("port")) @dataclass -class RxOffloadCapabilities(TextParser): - """The result of testpmd's ``show port <port_id> rx_offload capabilities`` command. +class TxOffloadCapabilities(OffloadCapabilities): + """Extends :class:`OffloadCapabilities` with Tx specific functionality.""" - References: - testpmd command function: ``app/test-pmd/cmdline.c:cmd_rx_offload_get_capa()`` - testpmd display function: ``app/test-pmd/cmdline.c:cmd_rx_offload_get_capa_parsed()`` - """ + per_queue: OffloadCapability = field(metadata=TxOffloadCapability.make_parser("queue")) + per_port: OffloadCapability = field(metadata=TxOffloadCapability.make_parser("port")) - #: - port_id: int = field( - metadata=TextParser.find_int(r"Rx Offloading Capabilities of port (\d+) :") + +@dataclass +class OffloadConfiguration(TextParser): + """The result of testpmd's ``show port <port_id> rx/tx_offload configuration`` command.""" + + port_id: int = field(metadata=TextParser.find_int(r"Offloading Configuration of port (\d+) :")) + #: Queue offload configurations. + queues: list[OffloadCapability] + #: Port offload configuration. + port: OffloadCapability + + +@dataclass +class RxOffloadConfiguration(OffloadConfiguration): + """Extends :class:`OffloadingConfiguration` with Rx specific functionality.""" + + queues: list[OffloadCapability] = field( + metadata=RxOffloadCapability.make_parser("queue", find_multiple=True) + ) + port: OffloadCapability = field(metadata=RxOffloadCapability.make_parser("port")) + + +@dataclass +class TxOffloadConfiguration(OffloadConfiguration): + """Extends :class:`OffloadingConfiguration` with Tx specific functionality.""" + + queues: list[OffloadCapability] = field( + metadata=TxOffloadCapability.make_parser("queue", find_multiple=True) ) - #: Per-queue Rx offload capabilities. - per_queue: RxOffloadCapability = field(metadata=RxOffloadCapability.make_parser(False)) - #: Capabilities other than per-queue Rx offload capabilities. - per_port: RxOffloadCapability = field(metadata=RxOffloadCapability.make_parser(True)) + port: OffloadCapability = field(metadata=TxOffloadCapability.make_parser("port")) @dataclass diff --git a/dts/framework/parser.py b/dts/framework/parser.py index 7254c75b71..4170cdb1dd 100644 --- a/dts/framework/parser.py +++ b/dts/framework/parser.py @@ -116,6 +116,36 @@ def _composite_parser_fn(text: str) -> Any: return ParserFn(TextParser_fn=_composite_parser_fn) + @staticmethod + def find_all( + pattern: str | re.Pattern[str], + flags: re.RegexFlag = re.RegexFlag(0), + ) -> ParserFn: + """Makes a parser function that finds all of the regular expression matches in the text. + + If there are no matches found in the text than None will be returned, otherwise a list + containing all matches will be returned. Patterns that contain multiple groups will pack + the matches for each group into a tuple. + + Args: + pattern: The regular expression pattern. + flags: The regular expression flags. Ignored if the given pattern is already compiled. + + Returns: + A :class:`ParserFn` that can be used as metadata for a dataclass field. + """ + if isinstance(pattern, str): + pattern = re.compile(pattern, flags) + + def _find_all(text: str) -> list[str] | None: + m = pattern.findall(text) + if len(m) == 0: + return None + + return m + + return ParserFn(TextParser_fn=_find_all) + @staticmethod def find( pattern: str | re.Pattern[str], diff --git a/dts/framework/testbed_model/capability.py b/dts/framework/testbed_model/capability.py index f67cff94dc..b166014e0c 100644 --- a/dts/framework/testbed_model/capability.py +++ b/dts/framework/testbed_model/capability.py @@ -227,28 +227,95 @@ def mapping(cap: NicCapability) -> TestPmdNicCapability: case NicCapability.SCATTERED_RX_ENABLED: return (TestPmd.get_capabilities_rxq_info, _add_remove_mtu(9000)) case ( - NicCapability.RX_OFFLOAD_VLAN_STRIP - | NicCapability.RX_OFFLOAD_IPV4_CKSUM - | NicCapability.RX_OFFLOAD_UDP_CKSUM - | NicCapability.RX_OFFLOAD_TCP_CKSUM - | NicCapability.RX_OFFLOAD_TCP_LRO - | NicCapability.RX_OFFLOAD_QINQ_STRIP - | NicCapability.RX_OFFLOAD_OUTER_IPV4_CKSUM - | NicCapability.RX_OFFLOAD_MACSEC_STRIP - | NicCapability.RX_OFFLOAD_VLAN_FILTER - | NicCapability.RX_OFFLOAD_VLAN_EXTEND - | NicCapability.RX_OFFLOAD_SCATTER - | NicCapability.RX_OFFLOAD_TIMESTAMP - | NicCapability.RX_OFFLOAD_SECURITY - | NicCapability.RX_OFFLOAD_KEEP_CRC - | NicCapability.RX_OFFLOAD_SCTP_CKSUM - | NicCapability.RX_OFFLOAD_OUTER_UDP_CKSUM - | NicCapability.RX_OFFLOAD_RSS_HASH - | NicCapability.RX_OFFLOAD_BUFFER_SPLIT - | NicCapability.RX_OFFLOAD_CHECKSUM - | NicCapability.RX_OFFLOAD_VLAN + NicCapability.PORT_RX_OFFLOAD_VLAN_STRIP + | NicCapability.PORT_RX_OFFLOAD_IPV4_CKSUM + | NicCapability.PORT_RX_OFFLOAD_UDP_CKSUM + | NicCapability.PORT_RX_OFFLOAD_TCP_CKSUM + | NicCapability.PORT_RX_OFFLOAD_TCP_LRO + | NicCapability.PORT_RX_OFFLOAD_QINQ_STRIP + | NicCapability.PORT_RX_OFFLOAD_OUTER_IPV4_CKSUM + | NicCapability.PORT_RX_OFFLOAD_MACSEC_STRIP + | NicCapability.PORT_RX_OFFLOAD_VLAN_FILTER + | NicCapability.PORT_RX_OFFLOAD_VLAN_EXTEND + | NicCapability.PORT_RX_OFFLOAD_SCATTER + | NicCapability.PORT_RX_OFFLOAD_TIMESTAMP + | NicCapability.PORT_RX_OFFLOAD_SECURITY + | NicCapability.PORT_RX_OFFLOAD_KEEP_CRC + | NicCapability.PORT_RX_OFFLOAD_SCTP_CKSUM + | NicCapability.PORT_RX_OFFLOAD_OUTER_UDP_CKSUM + | NicCapability.PORT_RX_OFFLOAD_RSS_HASH + | NicCapability.PORT_RX_OFFLOAD_BUFFER_SPLIT + | NicCapability.PORT_RX_OFFLOAD_CHECKSUM + | NicCapability.PORT_RX_OFFLOAD_VLAN + | NicCapability.QUEUE_RX_OFFLOAD_VLAN_STRIP + | NicCapability.QUEUE_RX_OFFLOAD_IPV4_CKSUM + | NicCapability.QUEUE_RX_OFFLOAD_UDP_CKSUM + | NicCapability.QUEUE_RX_OFFLOAD_TCP_CKSUM + | NicCapability.QUEUE_RX_OFFLOAD_TCP_LRO + | NicCapability.QUEUE_RX_OFFLOAD_QINQ_STRIP + | NicCapability.QUEUE_RX_OFFLOAD_OUTER_IPV4_CKSUM + | NicCapability.QUEUE_RX_OFFLOAD_MACSEC_STRIP + | NicCapability.QUEUE_RX_OFFLOAD_VLAN_FILTER + | NicCapability.QUEUE_RX_OFFLOAD_VLAN_EXTEND + | NicCapability.QUEUE_RX_OFFLOAD_SCATTER + | NicCapability.QUEUE_RX_OFFLOAD_TIMESTAMP + | NicCapability.QUEUE_RX_OFFLOAD_SECURITY + | NicCapability.QUEUE_RX_OFFLOAD_KEEP_CRC + | NicCapability.QUEUE_RX_OFFLOAD_SCTP_CKSUM + | NicCapability.QUEUE_RX_OFFLOAD_OUTER_UDP_CKSUM + | NicCapability.QUEUE_RX_OFFLOAD_RSS_HASH + | NicCapability.QUEUE_RX_OFFLOAD_BUFFER_SPLIT + | NicCapability.QUEUE_RX_OFFLOAD_CHECKSUM + | NicCapability.QUEUE_RX_OFFLOAD_VLAN ): - return (TestPmd.get_capabilities_rx_offload, None) + return (TestPmd.get_offload_capabilities_func("rx"), None) + case ( + NicCapability.PORT_TX_OFFLOAD_VLAN_INSERT + | NicCapability.PORT_TX_OFFLOAD_IPV4_CKSUM + | NicCapability.PORT_TX_OFFLOAD_UDP_CKSUM + | NicCapability.PORT_TX_OFFLOAD_TCP_CKSUM + | NicCapability.PORT_TX_OFFLOAD_SCTP_CKSUM + | NicCapability.PORT_TX_OFFLOAD_TCP_TSO + | NicCapability.PORT_TX_OFFLOAD_UDP_TSO + | NicCapability.PORT_TX_OFFLOAD_OUTER_IPV4_CKSUM + | NicCapability.PORT_TX_OFFLOAD_QINQ_INSERT + | NicCapability.PORT_TX_OFFLOAD_VXLAN_TNL_TSO + | NicCapability.PORT_TX_OFFLOAD_GRE_TNL_TSO + | NicCapability.PORT_TX_OFFLOAD_IPIP_TNL_TSO + | NicCapability.PORT_TX_OFFLOAD_GENEVE_TNL_TSO + | NicCapability.PORT_TX_OFFLOAD_MACSEC_INSERT + | NicCapability.PORT_TX_OFFLOAD_MT_LOCKFREE + | NicCapability.PORT_TX_OFFLOAD_MULTI_SEGS + | NicCapability.PORT_TX_OFFLOAD_MBUF_FAST_FREE + | NicCapability.PORT_TX_OFFLOAD_SECURITY + | NicCapability.PORT_TX_OFFLOAD_UDP_TNL_TSO + | NicCapability.PORT_TX_OFFLOAD_IP_TNL_TSO + | NicCapability.PORT_TX_OFFLOAD_OUTER_UDP_CKSUM + | NicCapability.PORT_TX_OFFLOAD_SEND_ON_TIMESTAMP + | NicCapability.QUEUE_TX_OFFLOAD_VLAN_INSERT + | NicCapability.QUEUE_TX_OFFLOAD_IPV4_CKSUM + | NicCapability.QUEUE_TX_OFFLOAD_UDP_CKSUM + | NicCapability.QUEUE_TX_OFFLOAD_TCP_CKSUM + | NicCapability.QUEUE_TX_OFFLOAD_SCTP_CKSUM + | NicCapability.QUEUE_TX_OFFLOAD_TCP_TSO + | NicCapability.QUEUE_TX_OFFLOAD_UDP_TSO + | NicCapability.QUEUE_TX_OFFLOAD_OUTER_IPV4_CKSUM + | NicCapability.QUEUE_TX_OFFLOAD_QINQ_INSERT + | NicCapability.QUEUE_TX_OFFLOAD_VXLAN_TNL_TSO + | NicCapability.QUEUE_TX_OFFLOAD_GRE_TNL_TSO + | NicCapability.QUEUE_TX_OFFLOAD_IPIP_TNL_TSO + | NicCapability.QUEUE_TX_OFFLOAD_GENEVE_TNL_TSO + | NicCapability.QUEUE_TX_OFFLOAD_MACSEC_INSERT + | NicCapability.QUEUE_TX_OFFLOAD_MT_LOCKFREE + | NicCapability.QUEUE_TX_OFFLOAD_MULTI_SEGS + | NicCapability.QUEUE_TX_OFFLOAD_MBUF_FAST_FREE + | NicCapability.QUEUE_TX_OFFLOAD_SECURITY + | NicCapability.QUEUE_TX_OFFLOAD_UDP_TNL_TSO + | NicCapability.QUEUE_TX_OFFLOAD_IP_TNL_TSO + | NicCapability.QUEUE_TX_OFFLOAD_OUTER_UDP_CKSUM + | NicCapability.QUEUE_TX_OFFLOAD_SEND_ON_TIMESTAMP + ): + return (TestPmd.get_offload_capabilities_func("tx"), None) case ( NicCapability.RUNTIME_RX_QUEUE_SETUP | NicCapability.RUNTIME_TX_QUEUE_SETUP diff --git a/dts/tests/TestSuite_checksum_offload.py b/dts/tests/TestSuite_checksum_offload.py index 70ae9c124c..6e54e12d32 100644 --- a/dts/tests/TestSuite_checksum_offload.py +++ b/dts/tests/TestSuite_checksum_offload.py @@ -32,9 +32,9 @@ @requires_link_topology(LinkTopology.TWO_LINKS) -@requires_nic_capability(NicCapability.RX_OFFLOAD_IPV4_CKSUM) -@requires_nic_capability(NicCapability.RX_OFFLOAD_UDP_CKSUM) -@requires_nic_capability(NicCapability.RX_OFFLOAD_TCP_CKSUM) +@requires_nic_capability(NicCapability.PORT_RX_OFFLOAD_IPV4_CKSUM) +@requires_nic_capability(NicCapability.PORT_RX_OFFLOAD_UDP_CKSUM) +@requires_nic_capability(NicCapability.PORT_RX_OFFLOAD_TCP_CKSUM) class TestChecksumOffload(TestSuite): """Checksum offload test suite. @@ -291,7 +291,7 @@ def validate_rx_checksum(self) -> None: packet=packet_list[i], good_L4=False, good_IP=True, testpmd=testpmd, id=dport_id ) - @requires_nic_capability(NicCapability.RX_OFFLOAD_VLAN) + @requires_nic_capability(NicCapability.PORT_RX_OFFLOAD_VLAN) @func_test def vlan_checksum(self) -> None: """Test VLAN Rx checksum hardware offload and verify packet reception. @@ -350,7 +350,7 @@ def vlan_checksum(self) -> None: packet=packet_list[i], good_L4=False, good_IP=True, testpmd=testpmd, id=dport_id ) - @requires_nic_capability(NicCapability.RX_OFFLOAD_SCTP_CKSUM) + @requires_nic_capability(NicCapability.PORT_RX_OFFLOAD_SCTP_CKSUM) @func_test def validate_sctp_checksum(self) -> None: """Test SCTP Rx checksum hardware offload and verify packet reception. diff --git a/dts/tests/TestSuite_pmd_buffer_scatter.py b/dts/tests/TestSuite_pmd_buffer_scatter.py index 06d2e5f7e5..a1f4841acf 100644 --- a/dts/tests/TestSuite_pmd_buffer_scatter.py +++ b/dts/tests/TestSuite_pmd_buffer_scatter.py @@ -32,7 +32,7 @@ @requires_nic_capability(NicCapability.PHYSICAL_FUNCTION) -@requires_nic_capability(NicCapability.RX_OFFLOAD_SCATTER) +@requires_nic_capability(NicCapability.PORT_RX_OFFLOAD_SCATTER) class TestPmdBufferScatter(TestSuite): """DPDK PMD packet scattering test suite. @@ -146,7 +146,7 @@ def scatter_mbuf_2048(self) -> None: """ self._pmd_scatter(mb_size=2048) - @requires_nic_capability(NicCapability.RX_OFFLOAD_SCATTER) + @requires_nic_capability(NicCapability.PORT_RX_OFFLOAD_SCATTER) @func_test def scatter_mbuf_2048_with_offload(self) -> None: """Run the :meth:`pmd_scatter` test with `mb_size` set to 2048 and rx_scatter offload. diff --git a/dts/tests/TestSuite_vlan.py b/dts/tests/TestSuite_vlan.py index 6c1b181c74..b42f87d800 100644 --- a/dts/tests/TestSuite_vlan.py +++ b/dts/tests/TestSuite_vlan.py @@ -26,7 +26,7 @@ from framework.test_suite import TestSuite, func_test -@requires_nic_capability(NicCapability.RX_OFFLOAD_VLAN_FILTER) +@requires_nic_capability(NicCapability.PORT_RX_OFFLOAD_VLAN_FILTER) @requires_link_topology(LinkTopology.TWO_LINKS) class TestVlan(TestSuite): """DPDK VLAN test suite. @@ -140,7 +140,7 @@ def vlan_receipt_no_stripping(self) -> None: testpmd.start() self._send_vlan_packet_and_verify(should_receive=True, strip=False, vlan_id=1) - @requires_nic_capability(NicCapability.RX_OFFLOAD_VLAN_STRIP) + @requires_nic_capability(NicCapability.PORT_RX_OFFLOAD_VLAN_STRIP) @func_test def vlan_receipt_stripping(self) -> None: """Ensure VLAN packet received with no tag when receipts and header stripping are enabled. -- 2.50.1 ^ permalink raw reply related [flat|nested] 22+ messages in thread
* Re: [PATCH v6 2/3] dts: add TX offload capabilities to NIC capabilities 2025-09-29 17:27 ` [PATCH v6 2/3] dts: add TX offload capabilities to NIC capabilities Andrew Bailey @ 2025-09-30 12:55 ` Luca Vizzarro 0 siblings, 0 replies; 22+ messages in thread From: Luca Vizzarro @ 2025-09-30 12:55 UTC (permalink / raw) To: Andrew Bailey; +Cc: dev, dmarx, ivan.malov, probb, Jeremy Spewock Reviewed-by: Luca Vizzarro <luca.vizzarro@arm.com> ^ permalink raw reply [flat|nested] 22+ messages in thread
* [PATCH v6 3/3] dts: update tx_offload test from old dts 2025-09-29 17:27 ` [PATCH v6 0/3] dts: add tx_offload support in dts Andrew Bailey 2025-09-29 17:27 ` [PATCH v6 1/3] dts: allow mbuf_fast_free to be set with testpmd shell Andrew Bailey 2025-09-29 17:27 ` [PATCH v6 2/3] dts: add TX offload capabilities to NIC capabilities Andrew Bailey @ 2025-09-29 17:27 ` Andrew Bailey 2025-09-30 12:57 ` Luca Vizzarro 2 siblings, 1 reply; 22+ messages in thread From: Andrew Bailey @ 2025-09-29 17:27 UTC (permalink / raw) To: luca.vizzarro; +Cc: dev, dmarx, ivan.malov, probb, Andrew Bailey Currently, the RX/TX offload test in old DTS expects the TX ports to be initially configured to use mbuf fast free. This is no longer the case and must be updated to assume mbuf fast free is not initially utilized by capable NICs. Add updated test suite to test mbuf fast free configuration. Signed-off-by: Andrew Bailey <abailey@iol.unh.edu> --- doc/api/dts/tests.TestSuite_rx_tx_offload.rst | 8 ++ dts/tests/TestSuite_rx_tx_offload.py | 126 ++++++++++++++++++ 2 files changed, 134 insertions(+) create mode 100644 doc/api/dts/tests.TestSuite_rx_tx_offload.rst create mode 100644 dts/tests/TestSuite_rx_tx_offload.py diff --git a/doc/api/dts/tests.TestSuite_rx_tx_offload.rst b/doc/api/dts/tests.TestSuite_rx_tx_offload.rst new file mode 100644 index 0000000000..27834a74da --- /dev/null +++ b/doc/api/dts/tests.TestSuite_rx_tx_offload.rst @@ -0,0 +1,8 @@ +.. SPDX-License-Identifier: BSD-3-Clause + +rx_tx_offload Test Suite +======================== + +.. automodule:: tests.TestSuite_rx_tx_offload + :members: + :show-inheritance: diff --git a/dts/tests/TestSuite_rx_tx_offload.py b/dts/tests/TestSuite_rx_tx_offload.py new file mode 100644 index 0000000000..19a8e507f2 --- /dev/null +++ b/dts/tests/TestSuite_rx_tx_offload.py @@ -0,0 +1,126 @@ +# SPDX-License-Identifier: BSD-3-Clause +# Copyright(c) 2025 University of New Hampshire + +"""RX TX offload test suite. + +Test the testpmd feature of configuring RX and TX offloads. +""" + +from api.capabilities import NicCapability, requires_nic_capability +from api.testpmd import TestPmd +from api.testpmd.types import ( + OffloadConfiguration, + RxTxLiteralSwitch, +) +from framework.test_suite import TestSuite, func_test + + +class TestRxTxOffload(TestSuite): + """RX/TX offload test suite.""" + + def _check_config( + self, + testpmd: TestPmd, + port_offload: str | None, + rxtx: RxTxLiteralSwitch, + port_id: int, + /, + queue_offload: list[str | None] | None = None, + verify: bool = True, + ) -> bool: + config: OffloadConfiguration = testpmd.get_offload_config(rxtx, port_id, verify) + if config.port.name != port_offload: + return False + + if queue_offload: + for i, q in enumerate(config.queues): + if q.name != queue_offload[i]: + return False + return True + + def _set_all_queues_mbuf_fast_free( + self, testpmd: TestPmd, on: bool, port_id: int, num_queues: int, /, verify: bool = True + ) -> None: + for i in range(num_queues): + testpmd.set_queue_mbuf_fast_free(on, port_id, i, verify) + + @requires_nic_capability(NicCapability.PORT_TX_OFFLOAD_MBUF_FAST_FREE) + @func_test + def test_mbuf_fast_free_configuration_per_port(self) -> None: + """Ensure mbuf_fast_free can be configured with testpmd per port. + + Steps: + * Start up testpmd shell. + * Toggle mbuf_fast_free on per port. + * Toggle mbuf_fast_free off per port. + + Verify: + * Mbuf_fast_free starts disabled. + * Mbuf_fast_free can be configured on per port. + * Mbuf_fast_free can be configured off per port. + """ + with TestPmd() as testpmd: + verify = True + port_id = 0 + testpmd.start_all_ports() + + # Ensure MBUF_FAST_FREE is disabled by default and verify + self.verify( + self._check_config(testpmd, None, "tx", port_id, verify=verify), + "MBUF_FAST_FREE enabled on port start.", + ) + # Enable MBUF_FAST_FREE per port and verify + testpmd.set_port_mbuf_fast_free(True, port_id, verify) + self.verify( + self._check_config(testpmd, "MBUF_FAST_FREE", "tx", port_id, verify=verify), + "Failed to enable MBUF_FAST_FREE on port.", + ) + # Disable MBUF_FAST_FREE per port and verify + testpmd.set_port_mbuf_fast_free(False, port_id, verify) + self.verify( + self._check_config(testpmd, None, "tx", port_id, verify=verify), + "Failed to disable MBUF_FAST_FREE on port.", + ) + + @requires_nic_capability(NicCapability.QUEUE_TX_OFFLOAD_MBUF_FAST_FREE) + @func_test + def test_mbuf_fast_free_configuration_per_queue(self) -> None: + """Ensure mbuf_fast_free can be configured with testpmd. + + Steps: + * Start up testpmd shell. + * Toggle mbuf_fast_free on per queue. + * Toggle mbuf_fast_free off per queue. + + Verify: + * Mbuf_fast_free starts disabled. + * Mbuf_fast_free can be configured on per queue. + * Mbuf_fast_free can be configured off per queue. + """ + with TestPmd() as testpmd: + verify = True + port_id = 0 + num_queues = 4 + queue_off: list[str | None] | None = [None] * num_queues + queue_on: list[str | None] | None = ["MBUF_FAST_FREE"] * num_queues + + testpmd.set_ports_queues(num_queues) + testpmd.start_all_ports() + + # Ensure mbuf_fast_free is disabled by default on port and queues + self.verify( + self._check_config(testpmd, None, "tx", port_id, queue_off, verify=verify), + "MBUF_FAST_FREE enabled on queue start.", + ) + # Enable mbuf_fast_free per queue and verify + self._set_all_queues_mbuf_fast_free(testpmd, True, port_id, num_queues, verify) + self.verify( + self._check_config(testpmd, None, "tx", port_id, queue_on, verify), + "Failed to enable MBUF_FAST_FREE on all queues.", + ) + # Disable mbuf_fast_free per queue and verify + self._set_all_queues_mbuf_fast_free(testpmd, False, port_id, num_queues, verify) + self.verify( + self._check_config(testpmd, None, "tx", port_id, queue_off, verify), + "Failed to disable MBUF_FAST_FREE on all queues.", + ) -- 2.50.1 ^ permalink raw reply related [flat|nested] 22+ messages in thread
* Re: [PATCH v6 3/3] dts: update tx_offload test from old dts 2025-09-29 17:27 ` [PATCH v6 3/3] dts: update tx_offload test from old dts Andrew Bailey @ 2025-09-30 12:57 ` Luca Vizzarro 0 siblings, 0 replies; 22+ messages in thread From: Luca Vizzarro @ 2025-09-30 12:57 UTC (permalink / raw) To: Andrew Bailey; +Cc: dev, dmarx, ivan.malov, probb Dependent on successful testing: Reviewed-by: Luca Vizzarro <luca.vizzarro@arm.com> ^ permalink raw reply [flat|nested] 22+ messages in thread
end of thread, other threads:[~2025-09-30 12:57 UTC | newest]
Thread overview: 22+ messages (download: mbox.gz follow: Atom feed
-- links below jump to the message on this page --
[not found] <20250902114327.48185-1-abailey@iol.unh.edu>
2025-09-02 11:43 ` [PATCH v1 2/3] dts: add reception check to checksum offload suite Andrew Bailey
2025-09-02 11:43 ` [PATCH v1 3/3] dts: all are one Andrew Bailey
2025-09-02 11:48 ` [PATCH v1 0/3] dts: add tx_offload support in dts Andrew Bailey
2025-09-24 16:47 ` [PATCH v4 0/3] dts:add " Andrew Bailey
2025-09-24 16:47 ` [PATCH v4 1/3] dts: allow mbuf_fast_free to be set with testpmd shell Andrew Bailey
2025-09-24 20:51 ` Patrick Robb
2025-09-25 16:01 ` Luca Vizzarro
2025-09-24 16:47 ` [PATCH v4 2/3] dts: add TX offload capabilities to NIC capabilities Andrew Bailey
2025-09-24 20:51 ` Patrick Robb
2025-09-25 16:05 ` Luca Vizzarro
2025-09-24 16:47 ` [PATCH v4 3/3] dts: update tx_offload test from old dts Andrew Bailey
2025-09-24 20:53 ` Patrick Robb
2025-09-29 17:06 ` [PATCH v5 0/3] dts: add tx_offload support in dts Andrew Bailey
2025-09-29 17:06 ` [PATCH v5 1/3] dts: allow mbuf_fast_free to be set with testpmd shell Andrew Bailey
2025-09-29 17:06 ` [PATCH v5 3/3] dts: update tx_offload test from old dts Andrew Bailey
2025-09-29 17:27 ` [PATCH v6 0/3] dts: add tx_offload support in dts Andrew Bailey
2025-09-29 17:27 ` [PATCH v6 1/3] dts: allow mbuf_fast_free to be set with testpmd shell Andrew Bailey
2025-09-30 12:51 ` Luca Vizzarro
2025-09-29 17:27 ` [PATCH v6 2/3] dts: add TX offload capabilities to NIC capabilities Andrew Bailey
2025-09-30 12:55 ` Luca Vizzarro
2025-09-29 17:27 ` [PATCH v6 3/3] dts: update tx_offload test from old dts Andrew Bailey
2025-09-30 12:57 ` Luca Vizzarro
This is a public inbox, see mirroring instructions for how to clone and mirror all data and code used for this inbox; as well as URLs for NNTP newsgroup(s).