From patchwork Mon Mar 11 15:44:05 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Jeremy Spewock X-Patchwork-Id: 138165 X-Patchwork-Delegate: thomas@monjalon.net Return-Path: X-Original-To: patchwork@inbox.dpdk.org Delivered-To: patchwork@inbox.dpdk.org Received: from mails.dpdk.org (mails.dpdk.org [217.70.189.124]) by inbox.dpdk.org (Postfix) with ESMTP id 7278C43C89; Mon, 11 Mar 2024 16:45:39 +0100 (CET) Received: from mails.dpdk.org (localhost [127.0.0.1]) by mails.dpdk.org (Postfix) with ESMTP id D841340ED1; Mon, 11 Mar 2024 16:45:07 +0100 (CET) Received: from mail-qv1-f100.google.com (mail-qv1-f100.google.com [209.85.219.100]) by mails.dpdk.org (Postfix) with ESMTP id 70B1B40E8A for ; Mon, 11 Mar 2024 16:45:03 +0100 (CET) Received: by mail-qv1-f100.google.com with SMTP id 6a1803df08f44-690b100da62so31794716d6.1 for ; Mon, 11 Mar 2024 08:45:03 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=iol.unh.edu; s=unh-iol; t=1710171903; x=1710776703; darn=dpdk.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=M+wLiC6KkIoezNXInsP8UoQDPl4cZskSzrM6ZKajZWM=; b=AnP5qpW6ibZ8hwmBTZ0MuMWm1tGWCI4TCxWwAQWnNSDfvZM9HTn1baEn7pckTxZ/dB Mk9D8QBmffWCU4DqOWkZ9W2RrypIU62TJvsK3urhOgzUv5Rx4LHSU17qToiL0l2mlTsi I1Xe1Xiw51Fclv5820SKgaTLir6kq3ZsG2ZsQ= X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1710171903; x=1710776703; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=M+wLiC6KkIoezNXInsP8UoQDPl4cZskSzrM6ZKajZWM=; b=KEIVMD1nH2Dkdv0RPBvxQRAEL9GEXijesgGo96vFWdYOyAuXtnAhH/rq9JuP+Ki10C /BqQI8meF112JmIUpwHWC+TG8CV+KKRF84FLpm9fwUWn9VcICkUqb7a5zooDaVGBicva ANdW4ciCkAT/rC5FwdrILJ5/1B6FDqjTKDUxBexweqaXo5fxDfdmquP7hgqAH3wsbfK4 XKukn2w4Oj8iBLHVZNgvUg1gK0rPvg2Se85sxdIFE6ogQKWAV0ewzQaGQPBe3iC3/RrF 7d7fbUCqbuclpSJubYK0YqC67XmWlZLIBCK0L5S527uAIdcB8A1MNi116BfK9StNrQVw 2+EQ== X-Gm-Message-State: AOJu0YwzFcZjBs4p45clIkYaqJ/DtD2b/h1MLyCY+8zvL6G8EPr81ZWc P+e8MiC3OepwosET00ClACDxL2s+Qoct+X0Rl025ltQO8Y3hMNu7cPvsS9K0fnJyGhQIRAz4NqC r0S2sg+PG7ddHX9T5AQIdZiQranYNUEEC9fNr5ZNKZZKrL3mR X-Google-Smtp-Source: AGHT+IFEhmhLPhsnsCX4AjpfWJoRFEE/Aph7QY1ZafiHfPzku0ipVFG6h/haD6gn7zd3gguyL8daOtOqbjzS X-Received: by 2002:a05:6214:140b:b0:690:c04c:98b with SMTP id pr11-20020a056214140b00b00690c04c098bmr6922865qvb.6.1710171902872; Mon, 11 Mar 2024 08:45:02 -0700 (PDT) Received: from postal.iol.unh.edu (postal.iol.unh.edu. [2606:4100:3880:1234::84]) by smtp-relay.gmail.com with ESMTPS id c11-20020ad45aeb000000b006903c83219esm289161qvh.2.2024.03.11.08.45.02 (version=TLS1_2 cipher=ECDHE-ECDSA-AES128-GCM-SHA256 bits=128/128); Mon, 11 Mar 2024 08:45:02 -0700 (PDT) X-Relaying-Domain: iol.unh.edu Received: from iol.unh.edu (unknown [IPv6:2606:4100:3880:1271:90f9:1b64:f6e6:867f]) by postal.iol.unh.edu (Postfix) with ESMTP id 6C9626052471; Mon, 11 Mar 2024 11:45:02 -0400 (EDT) From: jspewock@iol.unh.edu To: Honnappa.Nagarahalli@arm.com, juraj.linkes@pantheon.tech, thomas@monjalon.net, wathsala.vithanage@arm.com, probb@iol.unh.edu, paul.szczepanek@arm.com, yoan.picchi@foss.arm.com, ferruh.yigit@amd.com, andrew.rybchenko@oktetlabs.ru Cc: dev@dpdk.org, Jeremy Spewock Subject: [PATCH v9 7/7] dts: add pmd_buffer_scatter test suite Date: Mon, 11 Mar 2024 11:44:05 -0400 Message-ID: <20240311154405.13269-8-jspewock@iol.unh.edu> X-Mailer: git-send-email 2.43.2 In-Reply-To: <20240311154405.13269-1-jspewock@iol.unh.edu> References: <20240110144249.20719-1-jspewock@iol.unh.edu> <20240311154405.13269-1-jspewock@iol.unh.edu> MIME-Version: 1.0 X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: DPDK patches and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dev-bounces@dpdk.org From: Jeremy Spewock This test suite provides testing of the support of scattered packets by Poll Mode Drivers using testpmd, verifying the ability to receive and transmit scattered multi-segment packets made up of multiple non-contiguous memory buffers. This is tested through 5 different cases in which the length of the packets sent are less than the mbuf size, equal to the mbuf size, and 1, 4, and 5 bytes greater than the mbuf size in order to show both the CRC and the packet data are capable of existing in the first, second, or both buffers. Naturally, if the PMD is capable of forwarding scattered packets which it receives as input, this shows it is capable of both receiving and transmitting scattered packets. Signed-off-by: Jeremy Spewock --- dts/tests/TestSuite_pmd_buffer_scatter.py | 132 ++++++++++++++++++++++ 1 file changed, 132 insertions(+) create mode 100644 dts/tests/TestSuite_pmd_buffer_scatter.py diff --git a/dts/tests/TestSuite_pmd_buffer_scatter.py b/dts/tests/TestSuite_pmd_buffer_scatter.py new file mode 100644 index 0000000000..6c035595c2 --- /dev/null +++ b/dts/tests/TestSuite_pmd_buffer_scatter.py @@ -0,0 +1,132 @@ +# SPDX-License-Identifier: BSD-3-Clause +# Copyright(c) 2023-2024 University of New Hampshire + +"""Multi-segment packet scattering testing suite. + +This testing suite tests the support of transmitting and receiving scattered packets. This is shown +by the Poll Mode Driver being able to forward scattered multi-segment packets composed of multiple +non-contiguous memory buffers. To ensure the receipt of scattered packets, the DMA rings of the +port's RX queues must be configured with mbuf data buffers whose size is less than the maximum +length. + +If it is the case that the Poll Mode Driver can forward scattered packets which it receives, then +this suffices to show the Poll Mode Driver is capable of both receiving and transmitting scattered +packets. +""" + +import struct + +from scapy.layers.inet import IP # type: ignore[import] +from scapy.layers.l2 import Ether # type: ignore[import] +from scapy.packet import Raw # type: ignore[import] +from scapy.utils import hexstr # type: ignore[import] + +from framework.remote_session.testpmd_shell import TestPmdForwardingModes, TestPmdShell +from framework.test_suite import TestSuite + + +class TestPmdBufferScatter(TestSuite): + """DPDK PMD packet scattering test suite. + + Configure the Rx queues to have mbuf data buffers whose sizes are smaller than the maximum + packet size. Specifically, set mbuf data buffers to have a size of 2048 to fit a full 1512-byte + (CRC included) ethernet frame in a mono-segment packet. The testing of scattered packets is + done by sending a packet whose length is greater than the size of the configured size of mbuf + data buffers. There are a total of 5 packets sent within test cases which have lengths less + than, equal to, and greater than the mbuf size. There are multiple packets sent with lengths + greater than the mbuf size in order to test cases such as: + + 1. A single byte of the CRC being in a second buffer while the remaining 3 bytes are stored in + the first buffer alongside packet data. + 2. The entire CRC being stored in a second buffer while all of the packet data is stored in the + first. + 3. Most of the packet data being stored in the first buffer and a single byte of packet data + stored in a second buffer alongside the CRC. + """ + + def set_up_suite(self) -> None: + """Set up the test suite. + + Setup: + Verify that we have at least 2 port links in the current execution and increase the MTU + of both ports on the traffic generator to 9000 to support larger packet sizes. + """ + self.verify( + len(self._port_links) > 1, + "There must be at least two port links to run the scatter test suite", + ) + + self.tg_node.main_session.configure_port_mtu(9000, self._tg_port_egress) + self.tg_node.main_session.configure_port_mtu(9000, self._tg_port_ingress) + + def scatter_pktgen_send_packet(self, pktsize: int) -> str: + """Generate and send a packet to the SUT then capture what is forwarded back. + + Generate an IP packet of a specific length and send it to the SUT, then capture the + resulting received packet and extract its payload. The desired length of the packet is met + by packing its payload with the letter "X" in hexadecimal. + + Args: + pktsize: Size of the packet to generate and send. + + Returns: + The payload of the received packet as a string. + """ + packet = Ether() / IP() / Raw() + packet.getlayer(2).load = "" + payload_len = pktsize - len(packet) - 4 + payload = ["58"] * payload_len + # pack the payload + for X_in_hex in payload: + packet.load += struct.pack("=B", int("%s%s" % (X_in_hex[0], X_in_hex[1]), 16)) + received_packets = self.send_packet_and_capture(packet) + self.verify(len(received_packets) > 0, "Did not receive any packets.") + load = hexstr(received_packets[0].getlayer(2), onlyhex=1) + + return load + + def pmd_scatter(self, mbsize: int) -> None: + """Testpmd support of receiving and sending scattered multi-segment packets. + + Support for scattered packets is shown by sending 5 packets of differing length + where the length of the packet is calculated by taking mbuf-size + an offset. The + offsets used in the test are -1, 0, 1, 4, 5 respectively. + + Test: + Start testpmd and run functional test with preset mbsize. + """ + testpmd = self.sut_node.create_interactive_shell( + TestPmdShell, + app_parameters=( + "--mbcache=200 " + f"--mbuf-size={mbsize} " + "--max-pkt-len=9000 " + "--port-topology=paired " + "--tx-offloads=0x00008000" + ), + privileged=True, + ) + testpmd.set_forward_mode(TestPmdForwardingModes.mac) + testpmd.start() + + for offset in [-1, 0, 1, 4, 5]: + recv_payload = self.scatter_pktgen_send_packet(mbsize + offset) + self._logger.debug(f"Payload of scattered packet after forwarding: \n{recv_payload}") + self.verify( + ("58 " * 8).strip() in recv_payload, + f"Payload of scattered packet did not match expected payload with offset {offset}.", + ) + testpmd.stop() + + def test_scatter_mbuf_2048(self) -> None: + """Run the :meth:`pmd_scatter` test with `mbsize` set to 2048.""" + self.pmd_scatter(mbsize=2048) + + def tear_down_suite(self) -> None: + """Tear down the test suite. + + Teardown: + Set the MTU of the tg_node back to a more standard size of 1500 + """ + self.tg_node.main_session.configure_port_mtu(1500, self._tg_port_egress) + self.tg_node.main_session.configure_port_mtu(1500, self._tg_port_ingress)