From patchwork Fri Jan 17 14:16:13 2025 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Peter Seiderer X-Patchwork-Id: 13943397 Received: from mout.gmx.net (mout.gmx.net [212.227.17.20]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 2388D13C9D4; Fri, 17 Jan 2025 14:16:46 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=212.227.17.20 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1737123409; cv=none; b=jnK3Cz6IpNc3cZL12XSRG7ZexScrTa6Krg1m5aj8E+O55oBxYL6vYEI/zW22W3Sq1h5qJune+xAlRZuo6gN8VzUoSQvfyDdbE61ZC8NznVzTdsi2hSdga5jcYiYnKA3UMW4qfGM36wJigeJp/oObYbyG7Tb7XhxczhaFKiUzHJk= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1737123409; c=relaxed/simple; bh=tDpGxlUjgzCrUkb+LA5g5Ksb/vYRXwQJ366h8g9Zm7I=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=S85Gk415KP7+1t7XNNoLW0hTheZ/1D5ugIvveROVw/J3jJccPRroVMkODg1W+WuUOpegUA3JWti77avlTzib7sIbKWWUr2t5ZxdEEzTh1m7A2i2Pmv5lCNhrI5wsBTNQVEHIJ5KChXCz55oFhbL7TkKzsQT10iwWKXjMaX1zC+M= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=quarantine dis=none) header.from=gmx.net; spf=pass smtp.mailfrom=gmx.net; dkim=pass (2048-bit key) header.d=gmx.net header.i=ps.report@gmx.net header.b=RYUGvHgG; arc=none smtp.client-ip=212.227.17.20 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=quarantine dis=none) header.from=gmx.net Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmx.net Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmx.net header.i=ps.report@gmx.net header.b="RYUGvHgG" DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmx.net; s=s31663417; t=1737123384; x=1737728184; i=ps.report@gmx.net; bh=tDpGxlUjgzCrUkb+LA5g5Ksb/vYRXwQJ366h8g9Zm7I=; h=X-UI-Sender-Class:From:To:Cc:Subject:Date:Message-ID:In-Reply-To: References:MIME-Version:Content-Transfer-Encoding:cc: content-transfer-encoding:content-type:date:from:message-id: mime-version:reply-to:subject:to; b=RYUGvHgGvKvRret/teD+dgg53/1SxGYgDpn7tUlewxJ2AGygkhWuGxK9GbgyJNcF 7+zRHfDvo6ZaIEsMWUidfPyWw1quNQPVd6jRA57d8O52gL893/z5MaJzeOsvgpEEJ lm6oxjQQNZXG1UhRlV7u11cA3g33zWQ6sZ8lhlFZIhcJALBhFu5hN5G9+IMjjrANL NVlBFiQDVjHRb9P5QYsQKJO98CKzhvT2hNzSheNGgbu2AuhhPGMpMhk1n/0yZ5pJ4 MSyX2/YLQt+9DY0M6V2QX4Rl9+TCq7hjA5Z8syREV3x9Z8rM8dU54Wf2YbKcHayE6 0n2Od1THA3Abh/pK4w== X-UI-Sender-Class: 724b4f7f-cbec-4199-ad4e-598c01a50d3a Received: from localhost.fritz.box ([82.135.81.138]) by mail.gmx.net (mrgmx104 [212.227.17.168]) with ESMTPSA (Nemesis) id 1MOiHf-1ttMpT0DsN-00UijE; Fri, 17 Jan 2025 15:16:24 +0100 From: Peter Seiderer To: netdev@vger.kernel.org Cc: linux-kernel@vger.kernel.org, linux-kselftest@vger.kernel.org, "David S . Miller" , Eric Dumazet , Jakub Kicinski , Paolo Abeni , Simon Horman , Shuah Khan , =?utf-8?q?T?= =?utf-8?q?oke_H=C3=B8iland-J=C3=B8rgensen?= , Frederic Weisbecker , Artem Chernyshev , Nam Cao , Peter Seiderer Subject: [PATCH net-next v1 5/5] selftest: net: add proc_net_pktgen Date: Fri, 17 Jan 2025 15:16:13 +0100 Message-ID: <20250117141613.691452-6-ps.report@gmx.net> X-Mailer: git-send-email 2.48.0 In-Reply-To: <20250117141613.691452-1-ps.report@gmx.net> References: <20250117141613.691452-1-ps.report@gmx.net> Precedence: bulk X-Mailing-List: linux-kselftest@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 X-Provags-ID: V03:K1:P369FKAzsZh96gtwAuCNgLtKXpp0IOwctMaHSoLtBu3l5pug8z4 Fu+hWhgqlNf79oK4jV/PGIRSdRMHSUlSCW9EHJRdqzVspu+NMVAWQwYwqf4+IRx6tOQJlF8 gJAV+q7EFzJy3FdN+7Otge7i882447HLlyxO5HFeB3SpDxvrzOesjJUa8NH21bT6+qNa/0I jk7/SUbnY+Yuu/KGOYSFg== X-Spam-Flag: NO UI-OutboundReport: notjunk:1;M01:P0:CypgL9uUFms=;90RFjsdt/PBFM3fzeyAlume+/Qb 3qY9zwcpwumvUkh7P/xjFfFTKxG61LTZY5W9PqrRyjL43UWwMR5xaPVIVWgw1XSdCHVseCP9N uPZsVHmasTkWuhK5O6LBMrhS7zt+fWeTrS2T0120+VWy4V+XCp3XcUJKW2iYpHD+PhGan+/XT lrwsId8S3r1os/7FXyVadPPEwUNZd84Nyu5FrlAnIac3FfnxYW079lwnukGy+f5D5Cst2WAMj c7U8osSRQicNDIipqttB425RpL1vlZaTFmjzyzbHiy8YyJPUGxnOeyrK9WGI3qgH5wzS0cXSI 5u1PAe5t8YYCxq63br0/rQWQNuUxIArbQOCuJ90WWrH2VyFNiXfOqhzu7ZA4DMbLQf6wYT5h/ 2+2Mqufor5QYWgK1HdVEoijSH4JAJ1SiMAje2QuGvzPM3yfZuRCJA2si8H8H1BKk4Sw8Pg1gK 0zu8dTqSXukRCHZHyPve1NmEt3vsbeudcItVlQAd+Ng/g2D7Pe5OQaiGAus0IN2blSinexT1B UosIE3vHj9smwSTmdddcoc9dxZcXk5YG33FG3K5aCCKDTg4OxgOrRPeaJDj7H8btHnqEQx1ZJ 2OZld3FQRxQ0Dn/Fik4PeOwhEeXk/5hfNpeaVAfBWIIJB5+8kjZOGqOAoY3eR3UT+ZfkGBxhe mgGnn9O/8ADQVHnDU554BeJt9xGViMZKrX5V7dqsbJWOPhYNq0f51PY1tL5mm+xP/JrM4j+2v OGMH6ewJYWGHK7MVWiSjWUIuEVBgVSp7SM210Nvg+fk48beo2CxeF0gIW/zr1twF7NZ5GTnSg s2n5J79TaYbQ6iVwDcvvd31DVrkxprDHCu+7hBf+vKnoe29dIATWuQS8P7+RAYhjTl8Z1ZTXT VYr4va0mryWFHlB3h0QH768kzGfoz+5x+pLoEyV9f4Lp4fjBKObd82GY9a10N3XYpxStpP3WP Iy8Y/LflPeOlQUT0bK1R2S3EebCI/yMgpOXyKTQezudyYksraOLgR58Kbr5A/EpVYhMLCXU7x hmYs25RtLRUpGsDK6QJw1jTzydJCfUpytEnQAl3RjAmSV0KJhKviFbx7Mi3FkPFyEExq8cdQN WM+HCjCZ536p/pYSviAoQrDhrP+gJs2rwe+ZujSFUMPNCymwFOjmVbpcRgkI77cu9wpuBYLbu 3873qv76YIHiQbLSLjnrXpk70tDcnRI1SgQ66QMwM4Pwcl7/1Baieuu2PrJKQWDo= Add some test for /proc/net/pktgen/... interface. Signed-off-by: Peter Seiderer --- tools/testing/selftests/net/Makefile | 1 + tools/testing/selftests/net/proc_net_pktgen.c | 575 ++++++++++++++++++ 2 files changed, 576 insertions(+) create mode 100644 tools/testing/selftests/net/proc_net_pktgen.c diff --git a/tools/testing/selftests/net/Makefile b/tools/testing/selftests/net/Makefile index 73ee88d6b043..095708cd8345 100644 --- a/tools/testing/selftests/net/Makefile +++ b/tools/testing/selftests/net/Makefile @@ -100,6 +100,7 @@ TEST_PROGS += vlan_bridge_binding.sh TEST_PROGS += bpf_offload.py TEST_PROGS += ipv6_route_update_soft_lockup.sh TEST_PROGS += busy_poll_test.sh +TEST_GEN_PROGS += proc_net_pktgen # YNL files, must be before "include ..lib.mk" YNL_GEN_FILES := busy_poller netlink-dumps diff --git a/tools/testing/selftests/net/proc_net_pktgen.c b/tools/testing/selftests/net/proc_net_pktgen.c new file mode 100644 index 000000000000..1d01fa2a96e9 --- /dev/null +++ b/tools/testing/selftests/net/proc_net_pktgen.c @@ -0,0 +1,575 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * proc_net_pktgen: kselftest for /proc/net/pktgen interface + * + * Copyright (c) 2025 Peter Seiderer + * + */ +#include +#include +#include + +#include "../kselftest_harness.h" + +static const char add_loopback_0[] = "add_device lo@0"; +static const char rm_loopback_0[] = "rem_device_all"; + +static const char wrong_ctrl_command[] = "forsureawrongcommand"; +static const char legacy_ctrl_command[] = "max_before_softirq"; + +static const char wrong_device_command[] = "forsurewrongcommand"; +static const char device_command_min_pkt_size_0[] = "min_pkt_size"; +static const char device_command_min_pkt_size_1[] = "min_pkt_size "; +static const char device_command_min_pkt_size_2[] = "min_pkt_size 0"; +static const char device_command_min_pkt_size_3[] = "min_pkt_size 1"; +static const char device_command_min_pkt_size_4[] = "min_pkt_size 100"; +static const char device_command_min_pkt_size_5[] = "min_pkt_size=1001"; +static const char device_command_min_pkt_size_6[] = "min_pkt_size =2002"; +static const char device_command_min_pkt_size_7[] = "min_pkt_size= 3003"; +static const char device_command_min_pkt_size_8[] = "min_pkt_size = 4004"; +static const char device_command_max_pkt_size_0[] = "max_pkt_size 200"; +static const char device_command_pkt_size_0[] = "pkt_size 300"; +static const char device_command_imix_weights_0[] = "imix_weights 0,7 576,4 1500,1"; +static const char device_command_imix_weights_1[] = "imix_weights 101,1 102,2 103,3 104,4 105,5 106,6 107,7 108,8 109,9 110,10 111,11 112,12 113,13 114,14 115,15 116,16 117,17 118,18 119,19 120,20"; +static const char device_command_imix_weights_2[] = "imix_weights 100,1 102,2 103,3 104,4 105,5 106,6 107,7 108,8 109,9 110,10 111,11 112,12 113,13 114,14 115,15 116,16 117,17 118,18 119,19 120,20 121,21"; +static const char device_command_debug_0[] = "debug 1"; +static const char device_command_debug_1[] = "debug 0"; +static const char device_command_frags_0[] = "frags 100"; +static const char device_command_delay_0[] = "delay 100"; +static const char device_command_delay_1[] = "delay 2147483647"; +static const char device_command_rate_0[] = "rate 100"; +static const char device_command_ratep_0[] = "ratep 200"; +static const char device_command_udp_src_min_0[] = "udp_src_min 1"; +static const char device_command_udp_dst_min_0[] = "udp_dst_min 2"; +static const char device_command_udp_src_max_0[] = "udp_src_max 3"; +static const char device_command_udp_dst_max_0[] = "udp_dst_max 4"; +static const char device_command_clone_skb_0[] = "clone_skb 1"; +static const char device_command_clone_skb_1[] = "clone_skb 0"; +static const char device_command_count_0[] = "count 100"; +static const char device_command_src_mac_count_0[] = "src_mac_count 100"; +static const char device_command_dst_mac_count_0[] = "dst_mac_count 100"; +static const char device_command_burst_0[] = "burst 0"; +static const char device_command_node_0[] = "node 100"; +static const char device_command_xmit_mode_0[] = "xmit_mode start_xmit"; +static const char device_command_xmit_mode_1[] = "xmit_mode netif_receive"; +static const char device_command_xmit_mode_2[] = "xmit_mode queue_xmit"; +static const char device_command_xmit_mode_3[] = "xmit_mode nonsense"; +static const char device_command_flag_0[] = "flag UDPCSUM"; +static const char device_command_flag_1[] = "flag !UDPCSUM"; +static const char device_command_flag_2[] = "flag nonsense"; +static const char device_command_dst_min_0[] = "dst_min 101.102.103.104"; +static const char device_command_dst_0[] = "dst 101.102.103.104"; +static const char device_command_dst_max_0[] = "dst_max 201.202.203.204"; +static const char device_command_dst6_0[] = "dst6 2001:db38:1234:0000:0000:0000:0000:0000"; +static const char device_command_dst6_min_0[] = "dst6_min 2001:db8:1234:0000:0000:0000:0000:0000"; +static const char device_command_dst6_max_0[] = "dst6_max 2001:db8:1234:0000:0000:0000:0000:0000"; +static const char device_command_src6_0[] = "src6 2001:db38:1234:0000:0000:0000:0000:0000"; +static const char device_command_src_min_0[] = "src_min 101.102.103.104"; +static const char device_command_src_max_0[] = "src_max 201.202.203.204"; +static const char device_command_dst_mac_0[] = "dst_mac 01:02:03:04:05:06"; +static const char device_command_src_mac_0[] = "src_mac 11:12:13:14:15:16"; +static const char device_command_clear_counters_0[] = "clear_counters"; +static const char device_command_flows_0[] = "flows 100"; +#if 0 // needs CONFIG_XFRM +static const char device_command_spi_0[] = "spi 100"; +#endif +static const char device_command_flowlen_0[] = "flowlen 100"; +static const char device_command_queue_map_min_0[] = "queue_map_min 1"; +static const char device_command_queue_map_max_0[] = "queue_map_max 2"; +static const char device_command_mpls_0[] = "mpls 00000001,000000f2,00000ff3,0000fff4,000ffff5,00fffff6,0ffffff7,fffffff8"; +static const char device_command_vlan_id_0[] = "vlan_id 1"; +static const char device_command_vlan_p_0[] = "vlan_p 1"; +static const char device_command_vlan_cfi_0[] = "vlan_cfi 1"; +static const char device_command_vlan_id_1[] = "vlan_id 4096"; +static const char device_command_svlan_id_0[] = "svlan_id 1"; +static const char device_command_svlan_p_0[] = "svlan_p 1"; +static const char device_command_svlan_cfi_0[] = "svlan_cfi 1"; +static const char device_command_svlan_id_1[] = "svlan_id 4096"; +static const char device_command_tos_0[] = "tos 0"; +static const char device_command_tos_1[] = "tos 0f"; +static const char device_command_tos_2[] = "tos 0ff"; +static const char device_command_traffic_class_0[] = "traffic_class f0"; +static const char device_command_skb_priority_0[] = "skb_priority 999"; + +FIXTURE(proc_net_pktgen) { + int ctrl_fd; + int device_fd; +}; + +FIXTURE_SETUP(proc_net_pktgen) { + ssize_t len; + + self->ctrl_fd = open("/proc/net/pktgen/kpktgend_0", O_RDWR); + ASSERT_GE(self->ctrl_fd, 0) TH_LOG("CONFIG_NET_PKTGEN not enabled, module pktgen nod loaded?"); + + len = write(self->ctrl_fd, add_loopback_0, sizeof(add_loopback_0)); + ASSERT_EQ(len, sizeof(add_loopback_0)) TH_LOG("device lo@0 already registered?"); + + self->device_fd = open("/proc/net/pktgen/lo@0", O_RDWR); + ASSERT_GE(self->device_fd, 0) TH_LOG("device entry for lo@0 missing?"); +} + +FIXTURE_TEARDOWN(proc_net_pktgen) { + int ret; + ssize_t len; + + ret = close(self->device_fd); + EXPECT_EQ(ret, 0); + + len = write(self->ctrl_fd, rm_loopback_0, sizeof(rm_loopback_0)); + EXPECT_EQ(len, sizeof(rm_loopback_0)); + + ret = close(self->ctrl_fd); + EXPECT_EQ(ret, 0); +} + +TEST_F(proc_net_pktgen, wrong_ctrl_command) { + for (int i = 0; i <= sizeof(wrong_ctrl_command); i++) { + ssize_t len = write(self->ctrl_fd, wrong_ctrl_command, i); + EXPECT_EQ(len, -1); + EXPECT_EQ(errno, EINVAL); + } +} + +TEST_F(proc_net_pktgen, legacy_ctrl_command) { + for (int i = 0; i <= sizeof(legacy_ctrl_command); i++) { + ssize_t len = write(self->ctrl_fd, legacy_ctrl_command, i); + if (i < (sizeof(legacy_ctrl_command) - 1)) { + // incomplete command string + EXPECT_EQ(len, -1); + EXPECT_EQ(errno, EINVAL); + } else { + // complete command string without/with trailing '\0' + EXPECT_EQ(len, i); + } + } +} + +TEST_F(proc_net_pktgen, wrong_device_command) { + for (int i = 0; i <= sizeof(wrong_device_command); i++) { + ssize_t len = write(self->device_fd, wrong_device_command, i); + EXPECT_EQ(len, -1); + EXPECT_EQ(errno, EINVAL); + } +} + +TEST_F(proc_net_pktgen, device_command_min_pkt_size) { + ssize_t len; + + // with trailing '\0' + len = write(self->device_fd, device_command_min_pkt_size_0, sizeof(device_command_min_pkt_size_0)); + EXPECT_EQ(len, -1); + EXPECT_EQ(errno, EINVAL); + + // without trailing '\0' + len = write(self->device_fd, device_command_min_pkt_size_0, sizeof(device_command_min_pkt_size_0) - 1); + EXPECT_EQ(len, -1); + EXPECT_EQ(errno, EINVAL); + + // with trailing '\0' + len = write(self->device_fd, device_command_min_pkt_size_1, sizeof(device_command_min_pkt_size_1)); + EXPECT_EQ(len, -1); + EXPECT_EQ(errno, EINVAL); + + // without trailing '\0' + len = write(self->device_fd, device_command_min_pkt_size_1, sizeof(device_command_min_pkt_size_1) - 1); + EXPECT_EQ(len, -1); + EXPECT_EQ(errno, EINVAL); + + // with trailing '\0' + len = write(self->device_fd, device_command_min_pkt_size_2, sizeof(device_command_min_pkt_size_2)); + EXPECT_EQ(len, sizeof(device_command_min_pkt_size_2)); + + // without trailing '\0' + len = write(self->device_fd, device_command_min_pkt_size_2, sizeof(device_command_min_pkt_size_2) - 1); + EXPECT_EQ(len, sizeof(device_command_min_pkt_size_2) - 1); + + len = write(self->device_fd, device_command_min_pkt_size_3, sizeof(device_command_min_pkt_size_3)); + EXPECT_EQ(len, sizeof(device_command_min_pkt_size_3)); + + len = write(self->device_fd, device_command_min_pkt_size_4, sizeof(device_command_min_pkt_size_4)); + EXPECT_EQ(len, sizeof(device_command_min_pkt_size_4)); + + len = write(self->device_fd, device_command_min_pkt_size_5, sizeof(device_command_min_pkt_size_5)); + EXPECT_EQ(len, sizeof(device_command_min_pkt_size_5)); + + len = write(self->device_fd, device_command_min_pkt_size_6, sizeof(device_command_min_pkt_size_6)); + EXPECT_EQ(len, sizeof(device_command_min_pkt_size_6)); + + len = write(self->device_fd, device_command_min_pkt_size_7, sizeof(device_command_min_pkt_size_7)); + EXPECT_EQ(len, sizeof(device_command_min_pkt_size_7)); + + len = write(self->device_fd, device_command_min_pkt_size_8, sizeof(device_command_min_pkt_size_8)); + EXPECT_EQ(len, sizeof(device_command_min_pkt_size_8)); +} + +TEST_F(proc_net_pktgen, device_command_max_pkt_size) { + ssize_t len; + + len = write(self->device_fd, device_command_max_pkt_size_0, sizeof(device_command_max_pkt_size_0)); + EXPECT_EQ(len, sizeof(device_command_max_pkt_size_0)); +} + +TEST_F(proc_net_pktgen, device_command_pkt_size) { + ssize_t len; + + len = write(self->device_fd, device_command_pkt_size_0, sizeof(device_command_pkt_size_0)); + EXPECT_EQ(len, sizeof(device_command_pkt_size_0)); +} + +TEST_F(proc_net_pktgen, device_command_imix_weights) { + ssize_t len; + + len = write(self->device_fd, device_command_imix_weights_0, sizeof(device_command_imix_weights_0)); + EXPECT_EQ(len, sizeof(device_command_imix_weights_0)); + + len = write(self->device_fd, device_command_imix_weights_1, sizeof(device_command_imix_weights_1)); + EXPECT_EQ(len, sizeof(device_command_imix_weights_1)); + + len = write(self->device_fd, device_command_imix_weights_2, sizeof(device_command_imix_weights_2)); + EXPECT_EQ(len, -1); + EXPECT_EQ(errno, E2BIG); +} + +TEST_F(proc_net_pktgen, device_command_debug) { + ssize_t len; + + // debug on + len = write(self->device_fd, device_command_debug_0, sizeof(device_command_debug_0)); + EXPECT_EQ(len, sizeof(device_command_debug_0)); + + // debug off + len = write(self->device_fd, device_command_debug_1, sizeof(device_command_debug_1)); + EXPECT_EQ(len, sizeof(device_command_debug_1)); +} + +TEST_F(proc_net_pktgen, device_command_frags) { + ssize_t len; + + len = write(self->device_fd, device_command_frags_0, sizeof(device_command_frags_0)); + EXPECT_EQ(len, sizeof(device_command_frags_0)); +} + +TEST_F(proc_net_pktgen, device_command_delay) { + ssize_t len; + + len = write(self->device_fd, device_command_delay_0, sizeof(device_command_delay_0)); + EXPECT_EQ(len, sizeof(device_command_delay_0)); + + len = write(self->device_fd, device_command_delay_1, sizeof(device_command_delay_1)); + EXPECT_EQ(len, sizeof(device_command_delay_1)); +} + +TEST_F(proc_net_pktgen, device_command_rate) { + ssize_t len; + + len = write(self->device_fd, device_command_rate_0, sizeof(device_command_rate_0)); + EXPECT_EQ(len, sizeof(device_command_rate_0)); +} + +TEST_F(proc_net_pktgen, device_command_ratep) { + ssize_t len; + + len = write(self->device_fd, device_command_ratep_0, sizeof(device_command_ratep_0)); + EXPECT_EQ(len, sizeof(device_command_ratep_0)); +} + +TEST_F(proc_net_pktgen, device_command_udp_src_min) { + ssize_t len; + + len = write(self->device_fd, device_command_udp_src_min_0, sizeof(device_command_udp_src_min_0)); + EXPECT_EQ(len, sizeof(device_command_udp_src_min_0)); +} + +TEST_F(proc_net_pktgen, device_command_udp_dst_min) { + ssize_t len; + + len = write(self->device_fd, device_command_udp_dst_min_0, sizeof(device_command_udp_dst_min_0)); + EXPECT_EQ(len, sizeof(device_command_udp_dst_min_0)); +} + +TEST_F(proc_net_pktgen, device_command_udp_src_max) { + ssize_t len; + + len = write(self->device_fd, device_command_udp_src_max_0, sizeof(device_command_udp_src_max_0)); + EXPECT_EQ(len, sizeof(device_command_udp_src_max_0)); +} + +TEST_F(proc_net_pktgen, device_command_udp_dst_max) { + ssize_t len; + + len = write(self->device_fd, device_command_udp_dst_max_0, sizeof(device_command_udp_dst_max_0)); + EXPECT_EQ(len, sizeof(device_command_udp_dst_max_0)); +} + +TEST_F(proc_net_pktgen, device_command_clone_skb) { + ssize_t len; + + // clone_skb on (gives EOPNOTSUPP on lo device) + len = write(self->device_fd, device_command_clone_skb_0, sizeof(device_command_clone_skb_0)); + EXPECT_EQ(len, -1); + EXPECT_EQ(errno, EOPNOTSUPP); + + // clone_skb off + len = write(self->device_fd, device_command_clone_skb_1, sizeof(device_command_clone_skb_1)); + EXPECT_EQ(len, sizeof(device_command_clone_skb_1)); +} + +TEST_F(proc_net_pktgen, device_command_count) { + ssize_t len; + + len = write(self->device_fd, device_command_count_0, sizeof(device_command_count_0)); + EXPECT_EQ(len, sizeof(device_command_count_0)); +} + +TEST_F(proc_net_pktgen, device_command_src_mac_count) { + ssize_t len; + + len = write(self->device_fd, device_command_src_mac_count_0, sizeof(device_command_src_mac_count_0)); + EXPECT_EQ(len, sizeof(device_command_src_mac_count_0)); +} + +TEST_F(proc_net_pktgen, device_command_dst_mac_count) { + ssize_t len; + + len = write(self->device_fd, device_command_dst_mac_count_0, sizeof(device_command_dst_mac_count_0)); + EXPECT_EQ(len, sizeof(device_command_dst_mac_count_0)); +} + +TEST_F(proc_net_pktgen, device_command_burst) { + ssize_t len; + + // burst off + len = write(self->device_fd, device_command_burst_0, sizeof(device_command_burst_0)); + EXPECT_EQ(len, sizeof(device_command_burst_0)); +} + +TEST_F(proc_net_pktgen, device_command_node) { + ssize_t len; + + len = write(self->device_fd, device_command_node_0, sizeof(device_command_node_0)); + EXPECT_EQ(len, sizeof(device_command_node_0)); +} + +TEST_F(proc_net_pktgen, device_command_xmit_mode) { + ssize_t len; + + len = write(self->device_fd, device_command_xmit_mode_0, sizeof(device_command_xmit_mode_0)); + EXPECT_EQ(len, sizeof(device_command_xmit_mode_0)); + + len = write(self->device_fd, device_command_xmit_mode_1, sizeof(device_command_xmit_mode_1)); + EXPECT_EQ(len, sizeof(device_command_xmit_mode_1)); + + len = write(self->device_fd, device_command_xmit_mode_2, sizeof(device_command_xmit_mode_2)); + EXPECT_EQ(len, sizeof(device_command_xmit_mode_2)); + + len = write(self->device_fd, device_command_xmit_mode_3, sizeof(device_command_xmit_mode_3)); + EXPECT_EQ(len, sizeof(device_command_xmit_mode_3)); +} + +TEST_F(proc_net_pktgen, device_command_flag) { + ssize_t len; + + // flag UDPCSUM on + len = write(self->device_fd, device_command_flag_0, sizeof(device_command_flag_0)); + EXPECT_EQ(len, sizeof(device_command_flag_0)); + + // flag UDPCSUM off + len = write(self->device_fd, device_command_flag_1, sizeof(device_command_flag_1)); + EXPECT_EQ(len, sizeof(device_command_flag_1)); + + // flag invalid + len = write(self->device_fd, device_command_flag_2, sizeof(device_command_flag_2)); + EXPECT_EQ(len, sizeof(device_command_flag_2)); +} + +TEST_F(proc_net_pktgen, device_command_dst_min) { + ssize_t len; + + len = write(self->device_fd, device_command_dst_min_0, sizeof(device_command_dst_min_0)); + EXPECT_EQ(len, sizeof(device_command_dst_min_0)); +} + +TEST_F(proc_net_pktgen, device_command_dst) { + ssize_t len; + + len = write(self->device_fd, device_command_dst_0, sizeof(device_command_dst_0)); + EXPECT_EQ(len, sizeof(device_command_dst_0)); +} + +TEST_F(proc_net_pktgen, device_command_dst_max) { + ssize_t len; + + len = write(self->device_fd, device_command_dst_max_0, sizeof(device_command_dst_max_0)); + EXPECT_EQ(len, sizeof(device_command_dst_max_0)); +} + +TEST_F(proc_net_pktgen, device_command_dst6) { + ssize_t len; + + len = write(self->device_fd, device_command_dst6_0, sizeof(device_command_dst6_0)); + EXPECT_EQ(len, sizeof(device_command_dst6_0)); +} + +TEST_F(proc_net_pktgen, device_command_dst6_min) { + ssize_t len; + + len = write(self->device_fd, device_command_dst6_min_0, sizeof(device_command_dst6_min_0)); + EXPECT_EQ(len, sizeof(device_command_dst6_min_0)); +} + +TEST_F(proc_net_pktgen, device_command_dst6_max) { + ssize_t len; + + len = write(self->device_fd, device_command_dst6_max_0, sizeof(device_command_dst6_max_0)); + EXPECT_EQ(len, sizeof(device_command_dst6_max_0)); +} + +TEST_F(proc_net_pktgen, device_command_src6) { + ssize_t len; + + len = write(self->device_fd, device_command_src6_0, sizeof(device_command_src6_0)); + EXPECT_EQ(len, sizeof(device_command_src6_0)); +} + +TEST_F(proc_net_pktgen, device_command_src_min) { + ssize_t len; + + len = write(self->device_fd, device_command_src_min_0, sizeof(device_command_src_min_0)); + EXPECT_EQ(len, sizeof(device_command_src_min_0)); +} + +TEST_F(proc_net_pktgen, device_command_src_max) { + ssize_t len; + + len = write(self->device_fd, device_command_src_max_0, sizeof(device_command_src_max_0)); + EXPECT_EQ(len, sizeof(device_command_src_max_0)); +} + +TEST_F(proc_net_pktgen, device_command_dst_mac) { + ssize_t len; + + len = write(self->device_fd, device_command_dst_mac_0, sizeof(device_command_dst_mac_0)); + EXPECT_EQ(len, sizeof(device_command_dst_mac_0)); +} + +TEST_F(proc_net_pktgen, device_command_src_mac) { + ssize_t len; + + len = write(self->device_fd, device_command_src_mac_0, sizeof(device_command_src_mac_0)); + EXPECT_EQ(len, sizeof(device_command_src_mac_0)); +} + +TEST_F(proc_net_pktgen, device_command_clear_counters) { + ssize_t len; + + len = write(self->device_fd, device_command_clear_counters_0, sizeof(device_command_clear_counters_0)); + EXPECT_EQ(len, sizeof(device_command_clear_counters_0)); +} + +TEST_F(proc_net_pktgen, device_command_flows) { + ssize_t len; + + len = write(self->device_fd, device_command_flows_0, sizeof(device_command_flows_0)); + EXPECT_EQ(len, sizeof(device_command_flows_0)); +} + +#if 0 // needs CONFIG_XFRM +TEST_F(proc_net_pktgen, device_command_spi) { + ssize_t len; + + len = write(self->device_fd, device_command_spi_0, sizeof(device_command_spi_0)); + EXPECT_EQ(len, sizeof(device_command_spi_0)); +} +#endif + +TEST_F(proc_net_pktgen, device_command_flowlen) { + ssize_t len; + + len = write(self->device_fd, device_command_flowlen_0, sizeof(device_command_flowlen_0)); + EXPECT_EQ(len, sizeof(device_command_flowlen_0)); +} + +TEST_F(proc_net_pktgen, device_command_queue_map_min) { + ssize_t len; + + len = write(self->device_fd, device_command_queue_map_min_0, sizeof(device_command_queue_map_min_0)); + EXPECT_EQ(len, sizeof(device_command_queue_map_min_0)); +} + +TEST_F(proc_net_pktgen, device_command_queue_map_max) { + ssize_t len; + + len = write(self->device_fd, device_command_queue_map_max_0, sizeof(device_command_queue_map_max_0)); + EXPECT_EQ(len, sizeof(device_command_queue_map_max_0)); +} + +TEST_F(proc_net_pktgen, device_command_mpls) { + ssize_t len; + + len = write(self->device_fd, device_command_mpls_0, sizeof(device_command_mpls_0)); + EXPECT_EQ(len, sizeof(device_command_mpls_0)); +} + +TEST_F(proc_net_pktgen, device_command_vlan_id) { + ssize_t len; + + len = write(self->device_fd, device_command_vlan_id_0, sizeof(device_command_vlan_id_0)); + EXPECT_EQ(len, sizeof(device_command_vlan_id_0)); + + len = write(self->device_fd, device_command_vlan_p_0, sizeof(device_command_vlan_p_0)); + EXPECT_EQ(len, sizeof(device_command_vlan_p_0)); + + len = write(self->device_fd, device_command_vlan_cfi_0, sizeof(device_command_vlan_cfi_0)); + EXPECT_EQ(len, sizeof(device_command_vlan_cfi_0)); + + len = write(self->device_fd, device_command_vlan_id_1, sizeof(device_command_vlan_id_1)); + EXPECT_EQ(len, sizeof(device_command_vlan_id_1)); +} + +TEST_F(proc_net_pktgen, device_command_svlan_id) { + ssize_t len; + + len = write(self->device_fd, device_command_svlan_id_0, sizeof(device_command_svlan_id_0)); + EXPECT_EQ(len, sizeof(device_command_svlan_id_0)); + + len = write(self->device_fd, device_command_svlan_p_0, sizeof(device_command_svlan_p_0)); + EXPECT_EQ(len, sizeof(device_command_svlan_p_0)); + + len = write(self->device_fd, device_command_svlan_cfi_0, sizeof(device_command_svlan_cfi_0)); + EXPECT_EQ(len, sizeof(device_command_svlan_cfi_0)); + + len = write(self->device_fd, device_command_svlan_id_1, sizeof(device_command_svlan_id_1)); + EXPECT_EQ(len, sizeof(device_command_svlan_id_1)); +} + + +TEST_F(proc_net_pktgen, device_command_tos) { + ssize_t len; + + len = write(self->device_fd, device_command_tos_0, sizeof(device_command_tos_0)); + EXPECT_EQ(len, sizeof(device_command_tos_0)); + + len = write(self->device_fd, device_command_tos_1, sizeof(device_command_tos_1)); + EXPECT_EQ(len, sizeof(device_command_tos_1)); + + len = write(self->device_fd, device_command_tos_2, sizeof(device_command_tos_2)); + EXPECT_EQ(len, sizeof(device_command_tos_2)); +} + + +TEST_F(proc_net_pktgen, device_command_traffic_class) { + ssize_t len; + + len = write(self->device_fd, device_command_traffic_class_0, sizeof(device_command_traffic_class_0)); + EXPECT_EQ(len, sizeof(device_command_traffic_class_0)); +} + +TEST_F(proc_net_pktgen, device_command_skb_priority) { + ssize_t len; + + len = write(self->device_fd, device_command_skb_priority_0, sizeof(device_command_skb_priority_0)); + EXPECT_EQ(len, sizeof(device_command_skb_priority_0)); +} + +TEST_HARNESS_MAIN