From: Florian Fainelli <florian.fainelli@broadcom.com>
To: netdev@vger.kernel.org
Cc: "Florian Fainelli" <florian.fainelli@broadcom.com>,
"Rafał Miłecki" <rafal@milecki.pl>,
"Broadcom internal kernel review list"
<bcm-kernel-feedback-list@broadcom.com>,
"Andrew Lunn" <andrew+netdev@lunn.ch>,
"David S. Miller" <davem@davemloft.net>,
"Eric Dumazet" <edumazet@kernel.org>,
"Jakub Kicinski" <kuba@kernel.org>,
"Paolo Abeni" <pabeni@redhat.com>,
"Rob Herring" <robh@kernel.org>,
"Krzysztof Kozlowski" <krzk+dt@kernel.org>,
"Conor Dooley" <conor+dt@kernel.org>,
"Simon Horman" <horms@kernel.org>,
"Jonathan Corbet" <corbet@lwn.net>,
"Jonas Gorski" <jonas.gorski@gmail.com>,
"Vladimir Oltean" <olteanv@gmail.com>,
"Pablo Neira Ayuso" <pablo@netfilter.org>,
"Florian Westphal" <fw@strlen.de>, "Phil Sutter" <phil@nwl.cc>,
devicetree@vger.kernel.org (open list:OPEN FIRMWARE AND
FLATTENED DEVICE TREE BINDINGS),
linux-kernel@vger.kernel.org (open list),
linux-doc@vger.kernel.org (open list:DOCUMENTATION),
netfilter-devel@vger.kernel.org (open list:NETFILTER),
coreteam@netfilter.org (open list:NETFILTER)
Subject: [PATCH net-next 8/9] net: add KUnit coverage for FA and flowtable path validation
Date: Mon, 16 Nov 2026 14:25:18 -0800 [thread overview]
Message-ID: <20261116222519.1416501-9-florian.fainelli@broadcom.com> (raw)
In-Reply-To: <20261116222519.1416501-1-florian.fainelli@broadcom.com>
Exercise Northstar NAT fields, byte order, protocol-aware hash learning,
TCP control identity, lookup gating, MTU tracking and owner
invalidation. Check B53 UDF layout and every IPv4 packet length, failed-
guard readiness, and FA/ordinary switch tags.
Test cached-route owner validation with route-cookie expiry, changed or
invalid neighbours, absent route context and unsupported stacked paths.
Require explicit owner validation to detect an expired validation-only
dst even though the generic packet/GC helper ignores that reference.
Add seven scenarios using real route initialization and the private GC
step: ordinary direct software forwarding, validation-only references,
direct tunnels with and without hardware requested, neighbour routes
with and without hardware requested, and XFRM. Check legacy validation
policy, GC teardown and balanced dst references. The validation-only
scenario fails both packet and GC expectations before the policy fix.
The independent netfilter prerequisite already carries its two lifetime
tests and standalone configuration. Extend that test configuration's
help for these path cases, embed private tests in their parent units,
and keep the combined FA configuration beside the backend.
Signed-off-by: Florian Fainelli <florian.fainelli@broadcom.com>
---
MAINTAINERS | 3 +
drivers/net/dsa/b53/Kconfig | 11 +
drivers/net/dsa/b53/b53_common.c | 4 +
drivers/net/dsa/b53/b53_fa_test.c | 102 +++
drivers/net/ethernet/broadcom/.kunitconfig | 21 +
drivers/net/ethernet/broadcom/Kconfig | 11 +
.../net/ethernet/broadcom/bcm-ns-fa-test.c | 661 ++++++++++++++++++
drivers/net/ethernet/broadcom/bcm-ns-fa.c | 4 +
net/dsa/Kconfig | 11 +
net/dsa/tag_brcm.c | 4 +
net/dsa/tag_brcm_test.c | 199 ++++++
net/netfilter/Kconfig | 10 +-
net/netfilter/nf_flow_table_core_test.c | 85 +++
net/netfilter/nf_flow_table_offload.c | 4 +
net/netfilter/nf_flow_table_offload_test.c | 129 ++++
15 files changed, 1254 insertions(+), 5 deletions(-)
create mode 100644 drivers/net/dsa/b53/b53_fa_test.c
create mode 100644 drivers/net/ethernet/broadcom/.kunitconfig
create mode 100644 drivers/net/ethernet/broadcom/bcm-ns-fa-test.c
create mode 100644 net/dsa/tag_brcm_test.c
create mode 100644 net/netfilter/nf_flow_table_offload_test.c
diff --git a/MAINTAINERS b/MAINTAINERS
index 80969b91af40..c05ac2258889 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -5305,6 +5305,7 @@ F: drivers/net/dsa/bcm_sf2*
F: include/linux/dsa/brcm.h
F: include/linux/platform_data/b53.h
F: net/dsa/tag_brcm.c
+F: net/dsa/tag_brcm_test.c
BROADCOM BCM2711/BCM2835 ARM ARCHITECTURE
M: Florian Fainelli <florian.fainelli@broadcom.com>
@@ -5671,6 +5672,8 @@ S: Maintained
F: Documentation/devicetree/bindings/net/brcm,amac.yaml
F: Documentation/devicetree/bindings/net/brcm,bcm4708-fa.yaml
F: Documentation/devicetree/bindings/net/brcm,bcm5301x-gmac.yaml
+F: drivers/net/dsa/b53/b53_fa_test.c
+F: drivers/net/ethernet/broadcom/.kunitconfig
F: drivers/net/ethernet/broadcom/bcm-ns-fa*
F: drivers/net/ethernet/broadcom/bgmac*
F: drivers/net/ethernet/broadcom/unimac.h
diff --git a/drivers/net/dsa/b53/Kconfig b/drivers/net/dsa/b53/Kconfig
index 8e2a8c20bc4a..5a03bacef2e5 100644
--- a/drivers/net/dsa/b53/Kconfig
+++ b/drivers/net/dsa/b53/Kconfig
@@ -13,6 +13,17 @@ menuconfig B53
BCM5325E, BCM5365, BCM539x, BCM53115 and BCM53125 as well as BCM63XX
integrated switches.
+config B53_FA_KUNIT_TEST
+ bool "KUnit tests for B53 FA exception guards" if !KUNIT_ALL_TESTS
+ depends on KUNIT=y && B53
+ default KUNIT_ALL_TESTS
+ help
+ Tests are compiled into the parent driver and require built-in KUnit.
+ Verify the original FA classifier field layout and complete packet
+ length range used to divert unsafe packets around the accelerator.
+ Check cross-word destination MAC encoding and every 16-bit IPv4
+ packet length against the standard MTU without accessing hardware.
+
config B53_SPI_DRIVER
tristate "B53 SPI connected switch driver"
depends on B53 && SPI
diff --git a/drivers/net/dsa/b53/b53_common.c b/drivers/net/dsa/b53/b53_common.c
index 3e8c9679836d..25bb23a51952 100644
--- a/drivers/net/dsa/b53/b53_common.c
+++ b/drivers/net/dsa/b53/b53_common.c
@@ -3802,6 +3802,10 @@ int b53_switch_register(struct b53_device *dev)
}
EXPORT_SYMBOL(b53_switch_register);
+#if IS_ENABLED(CONFIG_B53_FA_KUNIT_TEST)
+#include "b53_fa_test.c"
+#endif
+
MODULE_AUTHOR("Jonas Gorski <jogo@openwrt.org>");
MODULE_DESCRIPTION("B53 switch library");
MODULE_LICENSE("Dual BSD/GPL");
diff --git a/drivers/net/dsa/b53/b53_fa_test.c b/drivers/net/dsa/b53/b53_fa_test.c
new file mode 100644
index 000000000000..1806c87a54fb
--- /dev/null
+++ b/drivers/net/dsa/b53/b53_fa_test.c
@@ -0,0 +1,102 @@
+// SPDX-License-Identifier: GPL-2.0-only
+#include <kunit/test.h>
+
+static int b53_fa_test_write16(struct b53_device *dev, u8 page, u8 reg, u16 value)
+{
+ u16 *control = dev->priv;
+
+ if (page != B53_CFP_PAGE || reg != B53_CFP_CTRL)
+ return -EINVAL;
+ *control = value;
+ return 0;
+}
+
+static void b53_fa_test_port_guards(struct kunit *test)
+{
+ static const struct b53_io_ops ops = { .write16 = b53_fa_test_write16 };
+ struct b53_device *dev = kunit_kzalloc(test, sizeof(*dev), GFP_KERNEL);
+ struct dsa_switch_tree tree = {};
+ struct dsa_switch ds = { .dst = &tree };
+ struct dsa_port control = {
+ .ds = &ds, .index = 5, .type = DSA_PORT_TYPE_CPU,
+ .conduit_admin_up = true, .conduit_oper_up = true,
+ };
+ u16 map = 0;
+
+ KUNIT_ASSERT_NOT_NULL(test, dev);
+ INIT_LIST_HEAD(&tree.ports);
+ list_add(&control.list, &tree.ports);
+ dev->ds = &ds;
+ dev->ops = &ops;
+ dev->priv = ↦
+ dev->fa_cfp_enabled = true;
+ dev->fa_cfp_ports = BIT(0) | BIT(1);
+ mutex_init(&dev->reg_mutex);
+
+ /* Bridge changes must not resurrect incomplete or failed guards. */
+ KUNIT_ASSERT_EQ(test, b53_fa_port(dev, 0, false), 0);
+ KUNIT_EXPECT_EQ(test, map, (u16)0);
+ dev->fa_guards_ready = true;
+ KUNIT_ASSERT_EQ(test, b53_fa_port(dev, 0, true), 0);
+ KUNIT_EXPECT_EQ(test, map, (u16)(BIT(0) | BIT(1)));
+ dev->fa_guards_failed = true;
+ KUNIT_ASSERT_EQ(test, b53_fa_port(dev, 0, false), 0);
+ KUNIT_EXPECT_EQ(test, map, (u16)0);
+ KUNIT_ASSERT_EQ(test, b53_fa_port(dev, 0, true), 0);
+ KUNIT_EXPECT_EQ(test, map, (u16)0);
+ KUNIT_EXPECT_EQ(test, dev->fa_cfp_ports, (u16)(BIT(0) | BIT(1)));
+ dev->fa_guards_failed = false;
+ control.conduit_oper_up = false;
+ KUNIT_ASSERT_EQ(test, b53_fa_port(dev, 0, false), 0);
+ KUNIT_EXPECT_EQ(test, map, (u16)0);
+}
+
+static void b53_fa_test_length_range(struct kunit *test)
+{
+ unsigned int length, i;
+
+ for (length = 0; length <= U16_MAX; length++) {
+ bool trap = false;
+
+ for (i = 0; i < ARRAY_SIZE(b53_fa_lengths); i++)
+ if ((length & b53_fa_lengths[i][1]) == b53_fa_lengths[i][0])
+ trap = true;
+ KUNIT_ASSERT_EQ_MSG(test, trap, length > ETH_DATA_LEN, "length %u", length);
+ }
+}
+
+static void b53_fa_test_udf_layout(struct kunit *test)
+{
+ u32 data[8] = {}, mask[8] = {};
+
+ b53_fa_udf(data, mask, 2, 1501, 0xffff);
+ KUNIT_EXPECT_EQ(test, data[1], 0x0005dd00U);
+ KUNIT_EXPECT_EQ(test, mask[1], 0x00ffff00U);
+ KUNIT_EXPECT_EQ(test, mask[5], (u32)BIT(26));
+ memset(data, 0, sizeof(data));
+ memset(mask, 0, sizeof(mask));
+ b53_fa_udf(data, mask, 3, 0x0200, 0xffff);
+ b53_fa_udf(data, mask, 4, 0x0000, 0xffff);
+ b53_fa_udf(data, mask, 5, 0x0101, 0xffff);
+ KUNIT_EXPECT_EQ(test, data[1], 0U);
+ KUNIT_EXPECT_EQ(test, data[2], 0x01000002U);
+ KUNIT_EXPECT_EQ(test, data[3], 1U);
+ KUNIT_EXPECT_EQ(test, mask[1], 0xff000000U);
+ KUNIT_EXPECT_EQ(test, mask[2], 0xffffffffU);
+ KUNIT_EXPECT_EQ(test, mask[3], 0x000000ffU);
+ KUNIT_EXPECT_EQ(test, mask[5], (u32)(BIT(27) | BIT(28) | BIT(29)));
+}
+
+static struct kunit_case b53_fa_cases[] = {
+ KUNIT_CASE(b53_fa_test_port_guards),
+ KUNIT_CASE(b53_fa_test_length_range),
+ KUNIT_CASE(b53_fa_test_udf_layout),
+ {}
+};
+
+static struct kunit_suite b53_fa_suite = {
+ .name = "b53-fa-guards",
+ .test_cases = b53_fa_cases,
+};
+
+kunit_test_suite(b53_fa_suite);
diff --git a/drivers/net/ethernet/broadcom/.kunitconfig b/drivers/net/ethernet/broadcom/.kunitconfig
new file mode 100644
index 000000000000..9772432ffc32
--- /dev/null
+++ b/drivers/net/ethernet/broadcom/.kunitconfig
@@ -0,0 +1,21 @@
+CONFIG_KUNIT=y
+CONFIG_DEBUG_KERNEL=y
+CONFIG_NET_DEV_REFCNT_TRACKER=y
+CONFIG_COMPILE_TEST=y
+CONFIG_NET=y
+CONFIG_INET=y
+CONFIG_NETDEVICES=y
+CONFIG_NET_VENDOR_BROADCOM=y
+CONFIG_NETFILTER=y
+CONFIG_NF_CONNTRACK=y
+CONFIG_NF_TABLES=y
+CONFIG_NF_FLOW_TABLE=y
+CONFIG_NF_FLOW_TABLE_KUNIT_TEST=y
+CONFIG_NET_DSA=y
+CONFIG_OF=y
+CONFIG_BCM_NS_FA=y
+CONFIG_BCM_NS_FA_KUNIT_TEST=y
+CONFIG_NET_DSA_TAG_BRCM_FA=y
+CONFIG_NET_DSA_TAG_BRCM_FA_KUNIT_TEST=y
+CONFIG_B53=y
+CONFIG_B53_FA_KUNIT_TEST=y
diff --git a/drivers/net/ethernet/broadcom/Kconfig b/drivers/net/ethernet/broadcom/Kconfig
index 865b346a7249..f6cbe63b576b 100644
--- a/drivers/net/ethernet/broadcom/Kconfig
+++ b/drivers/net/ethernet/broadcom/Kconfig
@@ -190,6 +190,17 @@ config BCM_NS_FA_FAULT_INJECTION
reprobe and leaves forwarding to software. Intended for driver testing.
Injection is disabled by default and can be armed through debugfs.
+config BCM_NS_FA_KUNIT_TEST
+ bool "KUnit tests for the Northstar flow accelerator" if !KUNIT_ALL_TESTS
+ depends on KUNIT=y && BCM_NS_FA
+ default KUNIT_ALL_TESTS
+ help
+ Test NAT action validation, table field encoding, and RX hash learning.
+ Exercise upper-device inspection under RCU with real netdevices.
+ Tests are compiled into the parent driver and require built-in KUnit.
+ These tests run without an accelerator and do not simulate table I/O.
+ Use the hardware validation plan to check actual forwarding.
+
config BGMAC_BCMA
tristate "Broadcom iProc GBit BCMA support"
depends on BCM_NS_FA || !BCM_NS_FA
diff --git a/drivers/net/ethernet/broadcom/bcm-ns-fa-test.c b/drivers/net/ethernet/broadcom/bcm-ns-fa-test.c
new file mode 100644
index 000000000000..59406f84809e
--- /dev/null
+++ b/drivers/net/ethernet/broadcom/bcm-ns-fa-test.c
@@ -0,0 +1,661 @@
+// SPDX-License-Identifier: GPL-2.0-only
+/* Included in bcm-ns-fa.c to exercise private table formats and validation. */
+#include <kunit/test.h>
+#include <net/lwtunnel.h>
+#include <net/nexthop.h>
+#include <linux/rtnetlink.h>
+
+static const struct net_device_ops fa_test_netdev_ops;
+
+static void fa_test_free_netdev(void *data)
+{
+ struct net_device *dev = data;
+
+ if (dev->reg_state == NETREG_REGISTERED)
+ unregister_netdev(dev);
+ free_netdev(dev);
+}
+
+static void fa_test_upper_device_rcu(struct kunit *test)
+{
+ struct net_device *lower, *upper;
+ bool has_upper;
+ int err;
+
+ lower = alloc_etherdev(0);
+ KUNIT_ASSERT_NOT_NULL(test, lower);
+ err = kunit_add_action_or_reset(test, fa_test_free_netdev, lower);
+ KUNIT_ASSERT_EQ(test, err, 0);
+ upper = alloc_etherdev(0);
+ KUNIT_ASSERT_NOT_NULL(test, upper);
+ err = kunit_add_action_or_reset(test, fa_test_free_netdev, upper);
+ KUNIT_ASSERT_EQ(test, err, 0);
+ lower->netdev_ops = &fa_test_netdev_ops;
+ upper->netdev_ops = &fa_test_netdev_ops;
+ eth_hw_addr_random(lower);
+ eth_hw_addr_random(upper);
+ KUNIT_ASSERT_EQ(test, register_netdev(lower), 0);
+ KUNIT_ASSERT_EQ(test, register_netdev(upper), 0);
+
+ /* Rule workers inspect topology under RCU without taking RTNL. */
+ rcu_read_lock();
+ has_upper = fa_has_upper_dev_rcu(lower);
+ rcu_read_unlock();
+ KUNIT_EXPECT_FALSE(test, has_upper);
+
+ rtnl_lock();
+ err = netdev_upper_dev_link(lower, upper, NULL);
+ rtnl_unlock();
+ KUNIT_ASSERT_EQ(test, err, 0);
+ rcu_read_lock();
+ has_upper = fa_has_upper_dev_rcu(lower);
+ rcu_read_unlock();
+ KUNIT_EXPECT_TRUE(test, has_upper);
+
+ rtnl_lock();
+ netdev_upper_dev_unlink(lower, upper);
+ rtnl_unlock();
+ rcu_read_lock();
+ has_upper = fa_has_upper_dev_rcu(lower);
+ rcu_read_unlock();
+ KUNIT_EXPECT_FALSE(test, has_upper);
+}
+
+static u64 fa_test_bits(const u32 *data, unsigned int low, unsigned int width)
+{
+ u64 val = 0;
+ unsigned int i;
+
+ for (i = 0; i < width; i++)
+ if (data[(low + i) / 32] & BIT((low + i) % 32))
+ val |= BIT_ULL(i);
+ return val;
+}
+
+static void fa_test_encode(struct kunit *test)
+{
+ struct fa_rule rule = {
+ .tuple = { cpu_to_be32(0xc0000202), cpu_to_be32(0xc6336402),
+ cpu_to_be16(0x1234), cpu_to_be16(0xabcd) },
+ .remap_ip = 0xcb007109,
+ .remap_port = 0x5678,
+ .action = FA_ACT_REMAP_IP | FA_ACT_REMAP_PORT,
+ .direction = FA_DIR_DNAT,
+ };
+ u32 data[8] = {};
+
+ fa_encode(&rule, 3, 127, 4, data);
+ /* Compare against the bit ranges in the hardware table definition,
+ * including fields that straddle words and host/network byte order.
+ */
+ KUNIT_EXPECT_EQ(test, fa_test_bits(data, 0, 35), 0ULL);
+ KUNIT_EXPECT_EQ(test, fa_test_bits(data, 35, 2), 3ULL);
+ KUNIT_EXPECT_EQ(test, fa_test_bits(data, 37, 1), 0ULL);
+ KUNIT_EXPECT_EQ(test, fa_test_bits(data, 38, 2), 3ULL);
+ KUNIT_EXPECT_EQ(test, fa_test_bits(data, 40, 7), 127ULL);
+ KUNIT_EXPECT_EQ(test, fa_test_bits(data, 47, 32), 0xcb007109ULL);
+ KUNIT_EXPECT_EQ(test, fa_test_bits(data, 79, 16), 0x5678ULL);
+ KUNIT_EXPECT_EQ(test, fa_test_bits(data, 95, 16), 0xabcdULL);
+ KUNIT_EXPECT_EQ(test, fa_test_bits(data, 111, 16), 0x1234ULL);
+ KUNIT_EXPECT_EQ(test, fa_test_bits(data, 127, 1), 0ULL);
+ KUNIT_EXPECT_EQ(test, fa_test_bits(data, 128, 32), 0xc6336402ULL);
+ KUNIT_EXPECT_EQ(test, fa_test_bits(data, 160, 32), 0xc0000202ULL);
+ KUNIT_EXPECT_EQ(test, fa_test_bits(data, 192, 1), 1ULL);
+ KUNIT_EXPECT_EQ(test, fa_test_bits(data, 193, 10), 16ULL);
+ KUNIT_EXPECT_EQ(test, fa_test_bits(data, 209, 3), 1ULL);
+ KUNIT_EXPECT_EQ(test, fa_test_bits(data, 212, 1), 1ULL);
+ KUNIT_EXPECT_EQ(test, fa_test_bits(data, 255, 1), 1ULL);
+}
+
+static void fa_test_mac_encode(struct kunit *test)
+{
+ const u8 addr[ETH_ALEN] = { 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54 };
+ u32 data[8] = {};
+
+ fa_mac_encode(addr, true, false, data);
+ KUNIT_EXPECT_EQ(test, fa_test_bits(data, 0, 1), 1ULL);
+ KUNIT_EXPECT_EQ(test, fa_test_bits(data, 1, 48), 0xfedcba987654ULL);
+ KUNIT_EXPECT_EQ(test, fa_test_bits(data, 49, 15), 0ULL);
+ memset(data, 0, sizeof(data));
+ fa_mac_encode(addr, false, false, data);
+ KUNIT_EXPECT_EQ(test, fa_test_bits(data, 0, 1), 0ULL);
+ KUNIT_EXPECT_EQ(test, fa_test_bits(data, 1, 48), 0xfedcba987654ULL);
+ memset(data, 0, sizeof(data));
+ fa_mac_encode(addr, false, true, data);
+ KUNIT_EXPECT_EQ(test, fa_test_bits(data, 0, 1), 0ULL);
+ KUNIT_EXPECT_EQ(test, fa_test_bits(data, 1, 2), 2ULL);
+ KUNIT_EXPECT_EQ(test, fa_test_bits(data, 3, 16), 0ULL);
+ KUNIT_EXPECT_EQ(test, fa_test_bits(data, 19, 48), 0xfedcba987654ULL);
+ KUNIT_EXPECT_EQ(test, fa_test_bits(data, 67, 29), 0ULL);
+ /* Hit-count bits must exclude the adjacent timestamp and action bits. */
+ data[0] = U32_MAX;
+ data[1] = U32_MAX;
+ KUNIT_EXPECT_EQ(test, fa_hits(data), U32_MAX);
+ data[0] = 7;
+ data[1] = ~7U;
+ KUNIT_EXPECT_EQ(test, fa_hits(data), 0U);
+}
+
+static void fa_test_nat_actions(struct kunit *test)
+{
+ struct fa_rule rule = { .direction = FA_DIR_UNSET, .l4proto = IPPROTO_UDP };
+ struct flow_action_entry act = {
+ .mangle = {
+ .htype = FLOW_ACT_MANGLE_HDR_TYPE_IP4,
+ .offset = offsetof(struct iphdr, saddr),
+ .val = (__force u32)cpu_to_be32(0xc0000201),
+ },
+ };
+
+ KUNIT_ASSERT_EQ(test, fa_mangle(&rule, &act), 0);
+ KUNIT_EXPECT_EQ(test, rule.remap_ip, 0xc0000201U);
+ KUNIT_EXPECT_EQ(test, rule.direction, 0);
+ act.mangle.htype = FLOW_ACT_MANGLE_HDR_TYPE_UDP;
+ act.mangle.offset = 0;
+ act.mangle.mask = (__force u32)cpu_to_be32(0x0000ffff);
+ act.mangle.val = (__force u32)cpu_to_be32(0xabcd0000);
+ KUNIT_ASSERT_EQ(test, fa_mangle(&rule, &act), 0);
+ KUNIT_EXPECT_EQ(test, rule.remap_port, (u16)0xabcd);
+ KUNIT_EXPECT_EQ(test, rule.action, (u8)3);
+ /* Opposite-side rewrites cannot share a hardware entry. */
+ act.mangle.mask = (__force u32)cpu_to_be32(0xffff0000);
+ KUNIT_EXPECT_EQ(test, fa_mangle(&rule, &act), -EOPNOTSUPP);
+ /* Partial IPv4 masks and arbitrary offsets must not be accepted. */
+ act.mangle.htype = FLOW_ACT_MANGLE_HDR_TYPE_IP4;
+ act.mangle.offset = offsetof(struct iphdr, daddr);
+ act.mangle.mask = 1;
+ KUNIT_EXPECT_EQ(test, fa_mangle(&rule, &act), -EOPNOTSUPP);
+ act.mangle.mask = 0;
+ act.mangle.offset = offsetof(struct iphdr, ttl);
+ KUNIT_EXPECT_EQ(test, fa_mangle(&rule, &act), -EOPNOTSUPP);
+}
+
+static void fa_test_ethernet_actions(struct kunit *test)
+{
+ const u8 expected[12] = { 0x02, 1, 2, 3, 4, 5, 0x02, 6, 7, 8, 9, 10 };
+ struct fa_rule rule = {};
+ struct flow_action_entry act = {
+ .mangle.htype = FLOW_ACT_MANGLE_HDR_TYPE_ETH,
+ };
+ int i;
+
+ for (i = 0; i < sizeof(expected); i += 4) {
+ act.mangle.offset = i;
+ memcpy(&act.mangle.val, expected + i, 4);
+ KUNIT_ASSERT_EQ(test, fa_mangle(&rule, &act), 0);
+ }
+ KUNIT_EXPECT_MEMEQ(test, rule.eth, expected, sizeof(expected));
+ KUNIT_EXPECT_PTR_EQ(test, memchr_inv(rule.eth_mask, 0xff, 12), NULL);
+ act.mangle.offset = 9;
+ KUNIT_EXPECT_EQ(test, fa_mangle(&rule, &act), -EOPNOTSUPP);
+}
+
+static void fa_test_rx_learning(struct kunit *test)
+{
+ struct bcm_ns_fa *fa = kunit_kzalloc(test, sizeof(*fa), GFP_KERNEL);
+ struct sk_buff *skb;
+ struct ethhdr *eth;
+ struct iphdr *ip;
+ struct udphdr *udp;
+ u8 *tag;
+
+ KUNIT_ASSERT_NOT_NULL(test, fa);
+ fa->learned = kunit_kcalloc(test, FA_SLOTS, sizeof(*fa->learned), GFP_KERNEL);
+ KUNIT_ASSERT_NOT_NULL(test, fa->learned);
+ spin_lock_init(&fa->learn_lock);
+ INIT_LIST_HEAD(&fa->entries);
+ skb = alloc_skb(64, GFP_KERNEL);
+ KUNIT_ASSERT_NOT_NULL(test, skb);
+ tag = skb_put_zero(skb, 4 + ETH_HLEN + sizeof(*ip) + sizeof(*udp));
+ tag[0] = FA_MISS_OPCODE << 5;
+ tag[1] = 0xfe;
+ tag[3] = 3;
+ eth = (void *)(tag + 4);
+ eth->h_proto = htons(ETH_P_IP);
+ eth->h_dest[0] = 2;
+ ip = (void *)(eth + 1);
+ ip->version = 4;
+ ip->ihl = 5;
+ ip->protocol = IPPROTO_UDP;
+ ip->tot_len = htons(sizeof(*ip) + sizeof(*udp));
+ ip->saddr = htonl(0xc0000201);
+ ip->daddr = htonl(0xc6336402);
+ udp = (void *)(ip + 1);
+ udp->source = htons(1234);
+ udp->dest = htons(5678);
+ ip->check = ip_fast_csum(ip, ip->ihl);
+ bcm_ns_fa_rx(fa, skb);
+ KUNIT_EXPECT_EQ(test, fa->learn_next, 1U);
+ KUNIT_EXPECT_TRUE(test, fa->learned[0].valid);
+ KUNIT_EXPECT_EQ(test, fa->learned[0].hash, (u8)0xfe);
+ KUNIT_EXPECT_EQ(test, fa->learned[0].port, (u8)3);
+ KUNIT_EXPECT_EQ(test, fa->learned[0].tuple.src, htonl(0xc0000201));
+ KUNIT_EXPECT_EQ(test, fa->learned[0].tuple.dport, htons(5678));
+ /* Preserve metadata for the brcm-fa DSA tagger. */
+ KUNIT_EXPECT_EQ(test, tag[0], (u8)(FA_MISS_OPCODE << 5));
+ ip->frag_off = htons(IP_MF);
+ ip->check = 0;
+ ip->check = ip_fast_csum(ip, ip->ihl);
+ bcm_ns_fa_rx(fa, skb);
+ KUNIT_EXPECT_EQ(test, fa->learn_next, 1U);
+ ip->frag_off = 0;
+ ip->check = 0;
+ ip->check = ip_fast_csum(ip, ip->ihl);
+ tag[2] = 1;
+ bcm_ns_fa_rx(fa, skb);
+ KUNIT_EXPECT_EQ(test, fa->learn_next, 1U);
+ tag[2] = 0;
+ ip->protocol = IPPROTO_TCP;
+ bcm_ns_fa_rx(fa, skb);
+ KUNIT_EXPECT_EQ(test, fa->learn_next, 1U);
+ ip->protocol = IPPROTO_UDP;
+ eth->h_proto = htons(ETH_P_8021Q);
+ bcm_ns_fa_rx(fa, skb);
+ KUNIT_EXPECT_EQ(test, fa->learn_next, 1U);
+ skb_trim(skb, 3);
+ bcm_ns_fa_rx(fa, skb);
+ KUNIT_EXPECT_EQ(test, fa->learn_next, 1U);
+ kfree_skb(skb);
+}
+
+static void fa_test_tcp_encode_and_mangle(struct kunit *test)
+{
+ struct fa_rule rule = { .l4proto = IPPROTO_TCP, .direction = FA_DIR_UNSET };
+ struct flow_action_entry act = {
+ .mangle = {
+ .htype = FLOW_ACT_MANGLE_HDR_TYPE_TCP,
+ .mask = (__force u32)cpu_to_be32(0xffff0000),
+ .val = (__force u32)cpu_to_be32(0x00001234),
+ },
+ };
+ u32 data[8] = {};
+
+ KUNIT_ASSERT_EQ(test, fa_mangle(&rule, &act), 0);
+ KUNIT_EXPECT_EQ(test, rule.remap_port, (u16)0x1234);
+ KUNIT_EXPECT_EQ(test, rule.direction, 1);
+ act.mangle.htype = FLOW_ACT_MANGLE_HDR_TYPE_UDP;
+ KUNIT_EXPECT_EQ(test, fa_mangle(&rule, &act), -EOPNOTSUPP);
+ fa_encode(&rule, 1, 2, 3, data);
+ KUNIT_EXPECT_EQ(test, fa_test_bits(data, 127, 1), 1ULL);
+ rule.l4proto = IPPROTO_UDP;
+ fa_encode(&rule, 1, 2, 3, data);
+ KUNIT_EXPECT_EQ(test, fa_test_bits(data, 127, 1), 0ULL);
+}
+
+static void fa_test_tcp_identity(struct kunit *test)
+{
+ struct fa_rule rule = {
+ .tuple = { cpu_to_be32(0xc0000202), cpu_to_be32(0xc6336402),
+ cpu_to_be16(40000), cpu_to_be16(5001) },
+ .l4proto = IPPROTO_TCP,
+ .remap_ip = 0xcb007101,
+ .remap_port = 45000,
+ .action = FA_ACT_REMAP_IP | FA_ACT_REMAP_PORT,
+ };
+ struct fa_flow entry = { .l4proto = IPPROTO_TCP, .in_port = 3 };
+ struct fa_learned learn = { .valid = true, .l4proto = IPPROTO_UDP };
+ struct fa_tuple reply, control;
+
+ fa_reply_tuple(&rule, &reply);
+ KUNIT_EXPECT_EQ(test, reply.src, rule.tuple.dst);
+ KUNIT_EXPECT_EQ(test, reply.dst, htonl(rule.remap_ip));
+ KUNIT_EXPECT_EQ(test, reply.sport, rule.tuple.dport);
+ KUNIT_EXPECT_EQ(test, reply.dport, htons(rule.remap_port));
+ rule.direction = FA_DIR_DNAT;
+ fa_reply_tuple(&rule, &reply);
+ KUNIT_EXPECT_EQ(test, reply.src, htonl(rule.remap_ip));
+ KUNIT_EXPECT_EQ(test, reply.dst, rule.tuple.src);
+ KUNIT_EXPECT_EQ(test, reply.sport, htons(rule.remap_port));
+ KUNIT_EXPECT_EQ(test, reply.dport, rule.tuple.sport);
+
+ entry.tuple = rule.tuple;
+ control = rule.tuple;
+ KUNIT_EXPECT_TRUE(test, fa_control_match(&entry, &control, 3, true));
+ KUNIT_EXPECT_FALSE(test, fa_control_match(&entry, &control, 2, true));
+ control.sport++;
+ KUNIT_EXPECT_FALSE(test, fa_control_match(&entry, &control, 3, true));
+ KUNIT_EXPECT_TRUE(test, fa_control_match(&entry, &control, 3, false));
+ entry.l4proto = IPPROTO_UDP;
+ KUNIT_EXPECT_FALSE(test, fa_control_match(&entry, &control, 3, false));
+
+ /* Equal TCP/UDP four-tuples must never share a learned hash. A TCP
+ * control packet also invalidates observations from the old lifetime.
+ */
+ learn.tuple = rule.tuple;
+ KUNIT_EXPECT_FALSE(test, fa_learn_matches(&learn, &rule, 0));
+ learn.l4proto = IPPROTO_TCP;
+ KUNIT_EXPECT_TRUE(test, fa_learn_matches(&learn, &rule, 0));
+ KUNIT_EXPECT_FALSE(test, fa_learn_matches(&learn, &rule, 1));
+ rule.l4proto = IPPROTO_UDP;
+ learn.l4proto = IPPROTO_UDP;
+ /* UDP uses the route/neighbour epoch, independent of TCP controls. */
+ KUNIT_EXPECT_TRUE(test, fa_learn_matches(&learn, &rule, 0));
+ KUNIT_EXPECT_FALSE(test, fa_learn_matches(&learn, &rule, 1));
+}
+
+static void fa_test_tcp_rx_control(struct kunit *test)
+{
+ struct bcm_ns_fa *fa = kunit_kzalloc(test, sizeof(*fa), GFP_KERNEL);
+ struct sk_buff *skb;
+ struct ethhdr *eth;
+ struct iphdr *ip;
+ struct tcphdr *tcp;
+ u8 *tag;
+
+ KUNIT_ASSERT_NOT_NULL(test, fa);
+ fa->learned = kunit_kcalloc(test, FA_SLOTS, sizeof(*fa->learned), GFP_KERNEL);
+ KUNIT_ASSERT_NOT_NULL(test, fa->learned);
+ INIT_LIST_HEAD(&fa->entries);
+ spin_lock_init(&fa->learn_lock);
+ skb = alloc_skb(128, GFP_KERNEL);
+ KUNIT_ASSERT_NOT_NULL(test, skb);
+ tag = skb_put_zero(skb, FA_TAG_LEN + ETH_HLEN + sizeof(*ip) + sizeof(*tcp));
+ tag[0] = FA_MISS_OPCODE << 5;
+ tag[1] = 0xab;
+ tag[3] = 2;
+ eth = (void *)(tag + FA_TAG_LEN);
+ eth->h_proto = htons(ETH_P_IP);
+ ip = (void *)(eth + 1);
+ ip->version = 4;
+ ip->ihl = 5;
+ ip->protocol = IPPROTO_TCP;
+ ip->tot_len = htons(sizeof(*ip) + sizeof(*tcp));
+ ip->saddr = htonl(0xc0000202);
+ ip->daddr = htonl(0xc6336402);
+ ip->check = ip_fast_csum(ip, ip->ihl);
+ tcp = (void *)(ip + 1);
+ tcp->doff = 5;
+ tcp->source = htons(40000);
+ tcp->dest = htons(5001);
+ tcp->syn = 1;
+ bcm_ns_fa_rx(fa, skb);
+ KUNIT_EXPECT_EQ(test, fa->learn_next, 0U);
+ KUNIT_EXPECT_EQ(test, fa->control_generation, 1UL);
+ tcp->syn = 0;
+ tcp->ack = 1;
+ bcm_ns_fa_rx(fa, skb);
+ KUNIT_EXPECT_EQ(test, fa->learn_next, 1U);
+ KUNIT_EXPECT_EQ(test, fa->learned[0].l4proto, (u8)IPPROTO_TCP);
+ KUNIT_EXPECT_EQ(test, fa->learned[0].hash, (u8)0xab);
+ KUNIT_EXPECT_EQ(test, fa->learned[0].generation, 1UL);
+ /* Opcode-zero switch traps contain no hash, but still retire TCP. */
+ tag[0] = 0;
+ tag[1] = 1;
+ tag[2] = BIT(3);
+ tcp->fin = 1;
+ bcm_ns_fa_rx(fa, skb);
+ KUNIT_EXPECT_EQ(test, fa->learn_next, 1U);
+ KUNIT_EXPECT_EQ(test, fa->control_generation, 2UL);
+ tcp->fin = 0;
+ tcp->rst = 1;
+ bcm_ns_fa_rx(fa, skb);
+ KUNIT_EXPECT_EQ(test, fa->control_generation, 3UL);
+ tcp->doff = 4;
+ bcm_ns_fa_rx(fa, skb);
+ KUNIT_EXPECT_EQ(test, fa->control_generation, 3UL);
+ kfree_skb(skb);
+}
+
+static void fa_test_tcp_control_readiness(struct kunit *test)
+{
+ struct bcm_ns_fa *fa = kunit_kzalloc(test, sizeof(*fa), GFP_KERNEL);
+
+ KUNIT_ASSERT_NOT_NULL(test, fa);
+ fa->regs = (void __iomem *)kunit_kzalloc(test, 0xc0, GFP_KERNEL);
+ fa->learned = kunit_kcalloc(test, FA_SLOTS, sizeof(*fa->learned), GFP_KERNEL);
+ KUNIT_ASSERT_NOT_NULL(test, fa->regs);
+ KUNIT_ASSERT_NOT_NULL(test, fa->learned);
+ mutex_init(&fa->lock);
+ spin_lock_init(&fa->learn_lock);
+ fa_control_state_change(fa, true);
+ KUNIT_EXPECT_TRUE(test, fa->tcp_ready);
+ fa_control_state_change(fa, false);
+ KUNIT_EXPECT_FALSE(test, fa->tcp_ready);
+ fa->stopping = true;
+ fa_control_state_change(fa, true);
+ KUNIT_EXPECT_FALSE(test, fa->tcp_ready);
+}
+
+static void fa_test_lookup_gate_preserves_tags(struct kunit *test)
+{
+ struct bcm_ns_fa *fa = kunit_kzalloc(test, sizeof(*fa), GFP_KERNEL);
+ u32 *regs = kunit_kzalloc(test, 0xc0, GFP_KERNEL);
+ u32 control = FA_CTL_CRC_OVERWRITE | FA_CTL_NO_DA_CHECK;
+ u32 header = FA_BRCM_HW | FA_BRCM_RX | FA_BRCM_TX | FA_BRCM_PARSE_EXCEPTIONS;
+
+ KUNIT_ASSERT_NOT_NULL(test, fa);
+ KUNIT_ASSERT_NOT_NULL(test, regs);
+ fa->regs = (void __iomem *)regs;
+ writel(control, fa->regs + FA_CTL);
+ writel(header, fa->regs + FA_BRCM_HDR);
+ fa->enabled = true;
+ fa->tcp_ready = true;
+ fa->route_mtu_ok = true;
+ fa_lookup_update(fa);
+ KUNIT_EXPECT_EQ(test, readl(fa->regs + FA_L2_ETHERTYPE),
+ (u32)(ETH_P_IP | ETH_P_IPV6 << 16));
+ fa->control_pending = true;
+ fa_lookup_update(fa);
+ KUNIT_EXPECT_EQ(test, readl(fa->regs + FA_L2_ETHERTYPE), 0U);
+ fa->control_pending = false;
+ fa_lookup_update(fa);
+ KUNIT_EXPECT_NE(test, readl(fa->regs + FA_L2_ETHERTYPE), 0U);
+ fa->route_mtu_ok = false;
+ fa_lookup_update(fa);
+ KUNIT_EXPECT_EQ(test, readl(fa->regs + FA_L2_ETHERTYPE), 0U);
+ fa->route_mtu_ok = true;
+ fa->tcp_ready = false;
+ fa_lookup_update(fa);
+ KUNIT_EXPECT_EQ(test, readl(fa->regs + FA_L2_ETHERTYPE), 0U);
+ fa->tcp_ready = true;
+ fa->enabled = false;
+ fa_lookup_update(fa);
+ KUNIT_EXPECT_EQ(test, readl(fa->regs + FA_L2_ETHERTYPE), 0U);
+ KUNIT_EXPECT_EQ(test, readl(fa->regs + FA_CTL), control);
+ KUNIT_EXPECT_EQ(test, readl(fa->regs + FA_BRCM_HDR), header);
+}
+
+static void fa_test_mtu_cleanup(void *ptr)
+{
+ struct bcm_ns_fa *fa = ptr;
+
+ fa_fib_reset(&fa->fib_nb);
+}
+
+static void fa_test_route_mtu(struct kunit *test)
+{
+ struct bcm_ns_fa *fa = kunit_kzalloc(test, sizeof(*fa), GFP_KERNEL);
+ struct dst_metrics metrics = {};
+ struct fib_info fi = { .fib_metrics = &metrics };
+ struct fib_entry_notifier_info entry = {
+ .info.family = AF_INET, .fi = &fi, .tb_id = RT_TABLE_MAIN,
+ .dst = 0xc0000200, .dst_len = 24,
+ };
+
+ KUNIT_ASSERT_NOT_NULL(test, fa);
+ spin_lock_init(&fa->learn_lock);
+ hash_init(fa->mtu_routes);
+ KUNIT_ASSERT_EQ(test, kunit_add_action_or_reset(test, fa_test_mtu_cleanup, fa), 0);
+
+ fa_mtu_route_update(fa, FIB_EVENT_ENTRY_REPLACE, &entry);
+ KUNIT_EXPECT_TRUE(test, fa->route_mtu_ok);
+ metrics.metrics[RTAX_MTU - 1] = 1500;
+ fa_mtu_route_update(fa, FIB_EVENT_ENTRY_REPLACE, &entry);
+ KUNIT_EXPECT_TRUE(test, fa->route_mtu_ok);
+ metrics.metrics[RTAX_MTU - 1] = 1200;
+ fa_mtu_route_update(fa, FIB_EVENT_ENTRY_REPLACE, &entry);
+ KUNIT_EXPECT_FALSE(test, fa->route_mtu_ok);
+ KUNIT_EXPECT_EQ(test, fa->nr_mtu_routes, 1U);
+ /* Replays/replacements are idempotent; tables and prefixes are distinct. */
+ fa_mtu_route_update(fa, FIB_EVENT_ENTRY_REPLACE, &entry);
+ KUNIT_EXPECT_EQ(test, fa->nr_mtu_routes, 1U);
+ entry.tb_id++;
+ fa_mtu_route_update(fa, FIB_EVENT_ENTRY_REPLACE, &entry);
+ entry.dst_len++;
+ fa_mtu_route_update(fa, FIB_EVENT_ENTRY_REPLACE, &entry);
+ KUNIT_EXPECT_EQ(test, fa->nr_mtu_routes, 3U);
+ fa_mtu_route_update(fa, FIB_EVENT_ENTRY_DEL, &entry);
+ entry.dst_len--;
+ metrics.metrics[RTAX_MTU - 1] = 1500;
+ fa_mtu_route_update(fa, FIB_EVENT_ENTRY_REPLACE, &entry);
+ KUNIT_EXPECT_FALSE(test, fa->route_mtu_ok);
+ entry.tb_id--;
+ fa_mtu_route_update(fa, FIB_EVENT_ENTRY_REPLACE, &entry);
+ KUNIT_EXPECT_EQ(test, fa->nr_mtu_routes, 0U);
+ KUNIT_EXPECT_TRUE(test, fa->route_mtu_ok);
+ /* A registration retry must discard a partial replay before starting over. */
+ metrics.metrics[RTAX_MTU - 1] = 1000;
+ fa_mtu_route_update(fa, FIB_EVENT_ENTRY_REPLACE, &entry);
+ fa_fib_reset(&fa->fib_nb);
+ KUNIT_EXPECT_TRUE(test, hash_empty(fa->mtu_routes));
+ KUNIT_EXPECT_TRUE(test, fa->route_mtu_ok);
+}
+
+static void fa_test_route_mtu_capacity(struct kunit *test)
+{
+ struct bcm_ns_fa *fa = kunit_kzalloc(test, sizeof(*fa), GFP_KERNEL);
+ struct dst_metrics metrics = {};
+ struct fib_info fi = { .fib_metrics = &metrics };
+ struct fib_entry_notifier_info entry = {
+ .info.family = AF_INET, .fi = &fi, .tb_id = RT_TABLE_MAIN, .dst_len = 32,
+ };
+ unsigned int i;
+
+ KUNIT_ASSERT_NOT_NULL(test, fa);
+ spin_lock_init(&fa->learn_lock);
+ hash_init(fa->mtu_routes);
+ KUNIT_ASSERT_EQ(test, kunit_add_action_or_reset(test, fa_test_mtu_cleanup, fa), 0);
+ /* Ordinary routes consume no tracking memory, regardless of FIB size. */
+ for (i = 0; i < 10000; i++) {
+ entry.dst = i;
+ fa_mtu_route_update(fa, FIB_EVENT_ENTRY_REPLACE, &entry);
+ }
+ KUNIT_EXPECT_EQ(test, fa->nr_mtu_routes, 0U);
+ KUNIT_EXPECT_TRUE(test, fa->route_mtu_ok);
+ metrics.metrics[RTAX_MTU - 1] = 1200;
+ for (i = 0; i <= FA_MTU_ROUTES_MAX; i++) {
+ entry.dst = i;
+ fa_mtu_route_update(fa, FIB_EVENT_ENTRY_REPLACE, &entry);
+ }
+ KUNIT_EXPECT_EQ(test, fa->nr_mtu_routes, (unsigned int)FA_MTU_ROUTES_MAX);
+ KUNIT_EXPECT_TRUE(test, fa->mtu_tracking_failed);
+ for (i = 0; i < FA_MTU_ROUTES_MAX; i++) {
+ entry.dst = i;
+ fa_mtu_route_update(fa, FIB_EVENT_ENTRY_DEL, &entry);
+ }
+ KUNIT_EXPECT_EQ(test, fa->nr_mtu_routes, 0U);
+ KUNIT_EXPECT_FALSE(test, fa->route_mtu_ok);
+ fa_fib_reset(&fa->fib_nb);
+ KUNIT_EXPECT_TRUE(test, fa->route_mtu_ok);
+}
+
+static void fa_test_route_suitability(struct kunit *test)
+{
+ struct dst_metrics metrics = {};
+ struct fib_info fi = { .fib_metrics = &metrics, .fib_nhs = 1 };
+ struct fib_nh_common nhc = {};
+ struct fib_result res = { .fi = &fi, .nhc = &nhc, .type = RTN_UNICAST };
+ struct fa_rule rule = {};
+
+ rule.out = kunit_kzalloc(test, sizeof(*rule.out), GFP_KERNEL);
+ KUNIT_ASSERT_NOT_NULL(test, rule.out);
+ nhc.nhc_dev = rule.out;
+ KUNIT_EXPECT_EQ(test, fa_route_supported(&rule, &res), 0);
+ /* A partial driver-side lookup cannot establish a stale owner. */
+ fi.fib_nhs = 2;
+ KUNIT_EXPECT_EQ(test, fa_route_supported(&rule, &res), -EOPNOTSUPP);
+ fi.fib_nhs = 1;
+ fi.nh = kunit_kzalloc(test, sizeof(*fi.nh), GFP_KERNEL);
+ KUNIT_ASSERT_NOT_NULL(test, fi.nh);
+ KUNIT_EXPECT_EQ(test, fa_route_supported(&rule, &res), -EOPNOTSUPP);
+ fi.nh = NULL;
+ nhc.nhc_lwtstate = kunit_kzalloc(test, sizeof(*nhc.nhc_lwtstate), GFP_KERNEL);
+ KUNIT_ASSERT_NOT_NULL(test, nhc.nhc_lwtstate);
+ KUNIT_EXPECT_EQ(test, fa_route_supported(&rule, &res), -EOPNOTSUPP);
+ nhc.nhc_lwtstate = NULL;
+ metrics.metrics[RTAX_MTU - 1] = 1200;
+ KUNIT_EXPECT_EQ(test, fa_route_supported(&rule, &res), -EOPNOTSUPP);
+ metrics.metrics[RTAX_MTU - 1] = 0;
+ nhc.nhc_gw_family = AF_INET6;
+ KUNIT_EXPECT_EQ(test, fa_route_supported(&rule, &res), -EOPNOTSUPP);
+ nhc.nhc_gw_family = 0;
+ nhc.nhc_dev = NULL;
+ KUNIT_EXPECT_EQ(test, fa_route_supported(&rule, &res), -EOPNOTSUPP);
+ nhc.nhc_dev = rule.out;
+ res.type = RTN_BLACKHOLE;
+ KUNIT_EXPECT_EQ(test, fa_route_supported(&rule, &res), -EOPNOTSUPP);
+}
+
+struct fa_test_owner {
+ struct bcm_ns_fa *fa;
+ unsigned int calls;
+ bool lookup_stopped;
+};
+
+static void fa_test_owner_invalidate(unsigned long cookie)
+{
+ struct fa_test_owner *owner = (struct fa_test_owner *)cookie;
+
+ owner->calls++;
+ owner->lookup_stopped = !readl(owner->fa->regs + FA_L2_ETHERTYPE);
+}
+
+static void fa_test_empty_work(struct work_struct *work)
+{
+}
+
+static void fa_test_invalidation(struct kunit *test)
+{
+ struct bcm_ns_fa *fa = kunit_kzalloc(test, sizeof(*fa), GFP_KERNEL);
+ struct fa_test_owner owner = { .fa = fa };
+ struct fa_flow entry = {
+ .cookie = (unsigned long)&owner,
+ .invalidate = fa_test_owner_invalidate,
+ };
+
+ KUNIT_ASSERT_NOT_NULL(test, fa);
+ fa->regs = (void __iomem *)kunit_kzalloc(test, 0xc0, GFP_KERNEL);
+ KUNIT_ASSERT_NOT_NULL(test, fa->regs);
+ spin_lock_init(&fa->learn_lock);
+ INIT_WORK(&fa->control_work, fa_test_empty_work);
+ INIT_LIST_HEAD(&fa->entries);
+ list_add(&entry.list, &fa->entries);
+ fa->enabled = true;
+ fa->tcp_ready = true;
+ fa->route_mtu_ok = true;
+ fa_lookup_update(fa);
+ fa_invalidate(fa);
+ flush_work(&fa->control_work);
+ KUNIT_EXPECT_EQ(test, owner.calls, 1U);
+ KUNIT_EXPECT_TRUE(test, owner.lookup_stopped);
+ KUNIT_EXPECT_TRUE(test, test_bit(FA_FLOW_CLOSING, &entry.flags));
+ KUNIT_EXPECT_TRUE(test, fa->control_pending);
+ KUNIT_EXPECT_TRUE(test, fa->route_mtu_ok);
+ KUNIT_EXPECT_EQ(test, fa->invalidate_generation, 1UL);
+}
+
+static struct kunit_case fa_test_cases[] = {
+ KUNIT_CASE(fa_test_upper_device_rcu),
+ KUNIT_CASE(fa_test_encode),
+ KUNIT_CASE(fa_test_mac_encode),
+ KUNIT_CASE(fa_test_nat_actions),
+ KUNIT_CASE(fa_test_ethernet_actions),
+ KUNIT_CASE(fa_test_rx_learning),
+ KUNIT_CASE(fa_test_tcp_encode_and_mangle),
+ KUNIT_CASE(fa_test_tcp_identity),
+ KUNIT_CASE(fa_test_tcp_rx_control),
+ KUNIT_CASE(fa_test_tcp_control_readiness),
+ KUNIT_CASE(fa_test_lookup_gate_preserves_tags),
+ KUNIT_CASE(fa_test_route_mtu),
+ KUNIT_CASE(fa_test_route_mtu_capacity),
+ KUNIT_CASE(fa_test_route_suitability),
+ KUNIT_CASE(fa_test_invalidation),
+ {}
+};
+
+static struct kunit_suite fa_test_suite = {
+ .name = "bcm-ns-fa",
+ .test_cases = fa_test_cases,
+};
+
+kunit_test_suite(fa_test_suite);
diff --git a/drivers/net/ethernet/broadcom/bcm-ns-fa.c b/drivers/net/ethernet/broadcom/bcm-ns-fa.c
index 8665ba94cbab..4ee8e5c18bb8 100644
--- a/drivers/net/ethernet/broadcom/bcm-ns-fa.c
+++ b/drivers/net/ethernet/broadcom/bcm-ns-fa.c
@@ -1893,5 +1893,9 @@ struct bcm_ns_fa *bcm_ns_fa_init(struct net_device *dev)
}
EXPORT_SYMBOL_GPL(bcm_ns_fa_init);
+#if IS_ENABLED(CONFIG_BCM_NS_FA_KUNIT_TEST)
+#include "bcm-ns-fa-test.c"
+#endif
+
MODULE_DESCRIPTION("Broadcom Northstar IPv4 TCP/UDP NAT flow accelerator");
MODULE_LICENSE("GPL");
diff --git a/net/dsa/Kconfig b/net/dsa/Kconfig
index 2dffff2f6c34..33fa69d3f216 100644
--- a/net/dsa/Kconfig
+++ b/net/dsa/Kconfig
@@ -78,6 +78,17 @@ config NET_DSA_TAG_BRCM_FA
switch port. Transmit uses the ordinary prepended Broadcom tag.
Enable this for a B53 switch explicitly connected to an accelerator.
+config NET_DSA_TAG_BRCM_FA_KUNIT_TEST
+ bool "KUnit tests for Broadcom FA tags" if !KUNIT_ALL_TESTS
+ depends on KUNIT=y && NET_DSA_TAG_BRCM_FA
+ default KUNIT_ALL_TESTS
+ help
+ Tests are compiled into the parent driver and require built-in KUnit.
+ Verify FA miss demultiplexing, parser-status handling, and rejection
+ of unsupported opcodes without changing ordinary Broadcom tagging.
+ Exercise source-port demultiplexing and consumption of the metadata
+ tag through the receive path, without requiring a physical switch.
+
config NET_DSA_TAG_HELLCREEK
tristate "Tag driver for Hirschmann Hellcreek TSN switches"
help
diff --git a/net/dsa/tag_brcm.c b/net/dsa/tag_brcm.c
index 8d13a3c7de5e..4a2c0a51db97 100644
--- a/net/dsa/tag_brcm.c
+++ b/net/dsa/tag_brcm.c
@@ -526,5 +526,9 @@ static struct dsa_tag_driver *dsa_tag_driver_array[] = {
module_dsa_tag_drivers(dsa_tag_driver_array);
+#if IS_ENABLED(CONFIG_NET_DSA_TAG_BRCM_FA_KUNIT_TEST)
+#include "tag_brcm_test.c"
+#endif
+
MODULE_DESCRIPTION("DSA tag driver for Broadcom switches using in-frame headers");
MODULE_LICENSE("GPL");
diff --git a/net/dsa/tag_brcm_test.c b/net/dsa/tag_brcm_test.c
new file mode 100644
index 000000000000..85499461e86b
--- /dev/null
+++ b/net/dsa/tag_brcm_test.c
@@ -0,0 +1,199 @@
+// SPDX-License-Identifier: GPL-2.0-only
+/* Included in tag_brcm.c: test the real receive path with a minimal DSA tree. */
+#include <kunit/test.h>
+
+struct brcm_fa_test_ctx {
+ struct dsa_switch_tree tree;
+ struct dsa_switch ds;
+ struct dsa_port cpu, user;
+ struct net_device *conduit, *port;
+};
+
+static void brcm_fa_test_free_netdev(void *ptr)
+{
+ free_netdev(ptr);
+}
+
+static int brcm_fa_test_init(struct kunit *test)
+{
+ struct brcm_fa_test_ctx *ctx;
+ struct dsa_user_priv *priv;
+ int err;
+
+ ctx = kunit_kzalloc(test, sizeof(*ctx), GFP_KERNEL);
+ KUNIT_ASSERT_NOT_NULL(test, ctx);
+ ctx->conduit = alloc_etherdev(0);
+ KUNIT_ASSERT_NOT_NULL(test, ctx->conduit);
+ err = kunit_add_action_or_reset(test, brcm_fa_test_free_netdev, ctx->conduit);
+ if (err)
+ return err;
+ ctx->port = alloc_etherdev(sizeof(*priv));
+ KUNIT_ASSERT_NOT_NULL(test, ctx->port);
+ err = kunit_add_action_or_reset(test, brcm_fa_test_free_netdev, ctx->port);
+ if (err)
+ return err;
+ INIT_LIST_HEAD(&ctx->tree.ports);
+ ctx->ds.dst = &ctx->tree;
+ ctx->cpu.index = 8;
+ ctx->cpu.type = DSA_PORT_TYPE_CPU;
+ ctx->cpu.ds = &ctx->ds;
+ ctx->cpu.dst = &ctx->tree;
+ ctx->user.ds = &ctx->ds;
+ ctx->user.dst = &ctx->tree;
+ ctx->user.index = 3;
+ ctx->user.type = DSA_PORT_TYPE_USER;
+ ctx->user.user = ctx->port;
+ list_add(&ctx->user.list, &ctx->tree.ports);
+ ctx->conduit->dsa_ptr = &ctx->cpu;
+ priv = netdev_priv(ctx->port);
+ priv->dp = &ctx->user;
+ test->priv = ctx;
+ return 0;
+}
+
+static struct sk_buff *brcm_fa_test_skb(u8 opcode, u8 status, u8 port)
+{
+ struct sk_buff *skb = alloc_skb(64, GFP_KERNEL);
+ u8 *data;
+
+ if (!skb)
+ return NULL;
+ data = skb_put_zero(skb, 64);
+ data[0] = opcode << BRCM_OPCODE_SHIFT;
+ data[1] = 0xff; /* Hash: not a classification identifier. */
+ data[2] = status;
+ data[3] = port;
+ /* Reproduce eth_type_trans(): the tagger gets data after ETH_HLEN. */
+ skb_reset_mac_header(skb);
+ skb_pull(skb, ETH_HLEN);
+ return skb;
+}
+
+static void brcm_fa_test_miss(struct kunit *test)
+{
+ struct brcm_fa_test_ctx *ctx = test->priv;
+ struct sk_buff *skb, *result;
+ u8 *start;
+
+ /* A parser failure is for the software IP stack to handle; it must
+ * not be confused with the reserved bits in a normal switch reason.
+ */
+ skb = brcm_fa_test_skb(BRCM_FA_OPCODE_MISS, 0xff, 3);
+ KUNIT_ASSERT_NOT_NULL(test, skb);
+ start = skb->data;
+ result = brcm_fa_tag_rcv(skb, ctx->conduit);
+ KUNIT_ASSERT_NOT_NULL(test, result);
+ KUNIT_EXPECT_PTR_EQ(test, result->dev, ctx->port);
+ KUNIT_EXPECT_PTR_EQ(test, result->data, start + BRCM_TAG_LEN);
+ KUNIT_EXPECT_EQ(test, result->len, 64U - ETH_HLEN - BRCM_TAG_LEN);
+ kfree_skb(result);
+}
+
+static void brcm_fa_test_opcodes(struct kunit *test)
+{
+ struct brcm_fa_test_ctx *ctx = test->priv;
+ struct sk_buff *skb, *result;
+ int opcode;
+
+ for (opcode = 0; opcode < 8; opcode++) {
+ skb = brcm_fa_test_skb(opcode, 0, 3);
+ KUNIT_ASSERT_NOT_NULL(test, skb);
+ result = brcm_fa_tag_rcv(skb, ctx->conduit);
+ if (!opcode || opcode == BRCM_FA_OPCODE_MISS) {
+ KUNIT_ASSERT_NOT_NULL(test, result);
+ kfree_skb(result);
+ } else {
+ KUNIT_EXPECT_PTR_EQ(test, result, NULL);
+ }
+ }
+}
+
+static void brcm_fa_test_strict_normal_tag(struct kunit *test)
+{
+ struct brcm_fa_test_ctx *ctx = test->priv;
+ struct sk_buff *skb;
+
+ skb = brcm_fa_test_skb(BRCM_FA_OPCODE_MISS, 0, 3);
+ KUNIT_ASSERT_NOT_NULL(test, skb);
+ KUNIT_EXPECT_PTR_EQ(test, brcm_tag_rcv_ll(skb, ctx->conduit, ETH_HLEN, false), NULL);
+ skb = brcm_fa_test_skb(0, BRCM_EG_RC_RSVD, 3);
+ KUNIT_ASSERT_NOT_NULL(test, skb);
+ KUNIT_EXPECT_PTR_EQ(test, brcm_fa_tag_rcv(skb, ctx->conduit), NULL);
+ skb = brcm_fa_test_skb(BRCM_FA_OPCODE_MISS, 0, 7);
+ KUNIT_ASSERT_NOT_NULL(test, skb);
+ KUNIT_EXPECT_PTR_EQ(test, brcm_fa_tag_rcv(skb, ctx->conduit), NULL);
+}
+
+struct brcm_fa_control_test {
+ unsigned int calls, port;
+ __be16 protocol;
+};
+
+static void brcm_fa_test_receive(void *priv, struct sk_buff *skb, unsigned int port)
+{
+ struct brcm_fa_control_test *state = priv;
+
+ state->calls++;
+ state->port = port;
+ state->protocol = eth_hdr(skb)->h_proto;
+}
+
+static void brcm_fa_test_auxiliary_control(struct kunit *test)
+{
+ struct brcm_fa_test_ctx *ctx = test->priv;
+ struct brcm_fa_control_test state = {};
+ struct brcm_fa_control control = {
+ .conduit = ctx->port,
+ .receive = brcm_fa_test_receive,
+ .priv = &state,
+ };
+ struct dsa_port *data_cpu;
+ struct sk_buff *skb, *result;
+ u8 *data;
+
+ data_cpu = kunit_kzalloc(test, sizeof(*data_cpu), GFP_KERNEL);
+ KUNIT_ASSERT_NOT_NULL(test, data_cpu);
+ data_cpu->ds = &ctx->ds;
+ data_cpu->type = DSA_PORT_TYPE_CPU;
+ data_cpu->index = 8;
+ data_cpu->conduit = ctx->port;
+ list_add(&data_cpu->list, &ctx->tree.ports);
+ ctx->cpu.index = 5;
+ skb = alloc_skb(64, GFP_KERNEL);
+ KUNIT_ASSERT_NOT_NULL(test, skb);
+ data = skb_put_zero(skb, 64);
+ data[0] = 2;
+ data[6] = 2;
+ data[13] = 1; /* Classification ID. */
+ data[14] = BRCM_EG_RC_PROT_TERM;
+ data[15] = 3;
+ put_unaligned_be16(ETH_P_IP, data + 16);
+ skb_reset_mac_header(skb);
+ skb_pull(skb, ETH_HLEN);
+ brcm_fa_control_register(&control);
+ result = brcm_fa_tag_rcv(skb, ctx->conduit);
+ brcm_fa_control_unregister(&control);
+ KUNIT_ASSERT_NOT_NULL(test, result);
+ KUNIT_EXPECT_PTR_EQ(test, result->dev, ctx->port);
+ KUNIT_EXPECT_EQ(test, result->len, 64U - ETH_HLEN - BRCM_TAG_LEN);
+ KUNIT_EXPECT_EQ(test, state.calls, 1U);
+ KUNIT_EXPECT_EQ(test, state.port, 3U);
+ KUNIT_EXPECT_EQ(test, state.protocol, htons(ETH_P_IP));
+ kfree_skb(result);
+}
+
+static struct kunit_case brcm_fa_test_cases[] = {
+ KUNIT_CASE(brcm_fa_test_miss),
+ KUNIT_CASE(brcm_fa_test_auxiliary_control),
+ KUNIT_CASE(brcm_fa_test_opcodes),
+ KUNIT_CASE(brcm_fa_test_strict_normal_tag),
+ {}
+};
+
+static struct kunit_suite brcm_fa_test_suite = {
+ .name = "brcm-fa-tag",
+ .init = brcm_fa_test_init,
+ .test_cases = brcm_fa_test_cases,
+};
+
+kunit_test_suite(brcm_fa_test_suite);
diff --git a/net/netfilter/Kconfig b/net/netfilter/Kconfig
index f565f87b3a6c..311a1910f6be 100644
--- a/net/netfilter/Kconfig
+++ b/net/netfilter/Kconfig
@@ -719,14 +719,14 @@ config NF_FLOW_TABLE
To compile it as a module, choose M here.
config NF_FLOW_TABLE_KUNIT_TEST
- bool "KUnit tests for flowtable ownership" if !KUNIT_ALL_TESTS
+ bool "KUnit tests for flowtable ownership and cached paths" if !KUNIT_ALL_TESTS
depends on KUNIT=y && NF_FLOW_TABLE
default KUNIT_ALL_TESTS
help
- Test conntrack offload ownership during flowtable teardown.
- Require hash and asynchronous hardware deletion before re-enrolment.
- Verify that late notifications cannot release a replacement owner.
- These private tests are embedded in the flowtable core.
+ Test flowtable ownership during asynchronous hardware deletion and
+ repeated teardown notifications, and validate cached forwarding paths.
+ Tests cover route expiry, neighbour changes and unsupported contexts.
+ The tests are embedded in their parent translation units.
config NF_FLOW_TABLE_PROCFS
bool "Supply flow table statistics in procfs"
diff --git a/net/netfilter/nf_flow_table_core_test.c b/net/netfilter/nf_flow_table_core_test.c
index 378a1c60b50b..5c7645239d2e 100644
--- a/net/netfilter/nf_flow_table_core_test.c
+++ b/net/netfilter/nf_flow_table_core_test.c
@@ -72,9 +72,94 @@ static void nf_flow_test_hardware_retirement(struct kunit *test)
rhashtable_destroy(&table.rhashtable);
}
+static struct dst_entry *nf_flow_test_gc_dst_check(struct dst_entry *dst, u32 cookie)
+{
+ return dst->error ? NULL : dst;
+}
+
+static void nf_flow_test_gc_routes(struct kunit *test)
+{
+ static const struct {
+ const char *name;
+ enum flow_offload_xmit_type type;
+ bool keep_dst;
+ bool tunnel;
+ bool check;
+ } cases[] = {
+ { "software direct", FLOW_OFFLOAD_XMIT_DIRECT, false, false, false },
+ { "validation only", FLOW_OFFLOAD_XMIT_DIRECT, true, false, false },
+ { "direct tunnel", FLOW_OFFLOAD_XMIT_DIRECT, false, true, true },
+ { "HW direct tunnel", FLOW_OFFLOAD_XMIT_DIRECT, true, true, true },
+ { "neighbour", FLOW_OFFLOAD_XMIT_NEIGH, false, false, true },
+ { "HW neighbour", FLOW_OFFLOAD_XMIT_NEIGH, true, false, true },
+ { "XFRM", FLOW_OFFLOAD_XMIT_XFRM, true, false, true },
+ };
+ static struct dst_ops ops = {
+ .family = AF_INET,
+ .check = nf_flow_test_gc_dst_check,
+ };
+ static struct nf_flowtable_type type;
+ unsigned int i, dir;
+
+ for (i = 0; i < ARRAY_SIZE(cases); i++) {
+ struct nf_flowtable table = { .type = &type };
+ struct nf_flow_route route = {};
+ struct flow_offload *flow;
+ struct net_device *dev;
+ struct rtable *rt;
+ struct nf_conn *ct;
+
+ flow = kunit_kzalloc(test, sizeof(*flow), GFP_KERNEL);
+ dev = kunit_kzalloc(test, sizeof(*dev), GFP_KERNEL);
+ rt = kunit_kcalloc(test, FLOW_OFFLOAD_DIR_MAX, sizeof(*rt), GFP_KERNEL);
+ ct = kunit_kzalloc(test, sizeof(*ct), GFP_KERNEL);
+ KUNIT_ASSERT_NOT_NULL(test, flow);
+ KUNIT_ASSERT_NOT_NULL(test, dev);
+ KUNIT_ASSERT_NOT_NULL(test, rt);
+ KUNIT_ASSERT_NOT_NULL(test, ct);
+ dev_net_set(dev, &init_net);
+ dev->mtu = 1500;
+ ct->tuplehash[0].tuple.dst.protonum = IPPROTO_ICMP;
+ refcount_set(&ct->ct_general.use, 2);
+ flow->ct = ct;
+ flow->timeout = nf_flowtable_time_stamp + NF_FLOW_TIMEOUT;
+ /* Avoid queuing real DELETE/STATS work from this private GC test. */
+ set_bit(NF_FLOW_HW, &flow->flags);
+ set_bit(NF_FLOW_HW_DYING, &flow->flags);
+ set_bit(IPS_OFFLOAD_BIT, &ct->status);
+ for (dir = 0; dir < FLOW_OFFLOAD_DIR_MAX; dir++) {
+ struct dst_entry *dst = &rt[dir].dst;
+
+ dst->dev = dev;
+ dst->ops = &ops;
+ dst->obsolete = DST_OBSOLETE_FORCE_CHK;
+ dst_init_metrics(dst, dst_default_metrics.metrics, true);
+ /* One fixture reference and one transferred route reference. */
+ rcuref_init(&dst->__rcuref, 2);
+ flow->tuplehash[dir].tuple.l3proto = NFPROTO_IPV4;
+ route.tuple[dir].dst = dst;
+ route.tuple[dir].xmit_type = cases[i].type;
+ route.tuple[dir].in.num_tuns = cases[i].tunnel;
+ }
+ flow_offload_route_init(flow, &route, cases[i].keep_dst);
+ /* Simulate the expired dst returned after an IPv4 generation change. */
+ rt[0].dst.error = ENETUNREACH;
+ KUNIT_EXPECT_EQ_MSG(test,
+ !nf_flow_dst_check(&flow->tuplehash[0].tuple), cases[i].check,
+ "packet path: %s", cases[i].name);
+ nf_flow_offload_gc_step(&table, flow, NULL);
+ KUNIT_EXPECT_EQ_MSG(test, test_bit(NF_FLOW_TEARDOWN, &flow->flags),
+ cases[i].check, "GC path: %s", cases[i].name);
+ flow_offload_route_release(flow);
+ for (dir = 0; dir < FLOW_OFFLOAD_DIR_MAX; dir++)
+ KUNIT_EXPECT_EQ(test, rcuref_read(&rt[dir].dst.__rcuref), 1);
+ }
+}
+
static struct kunit_case nf_flow_lifetime_cases[] = {
KUNIT_CASE(nf_flow_test_teardown_repeat),
KUNIT_CASE(nf_flow_test_hardware_retirement),
+ KUNIT_CASE(nf_flow_test_gc_routes),
{}
};
diff --git a/net/netfilter/nf_flow_table_offload.c b/net/netfilter/nf_flow_table_offload.c
index 1f3adf70f598..272e96fa466b 100644
--- a/net/netfilter/nf_flow_table_offload.c
+++ b/net/netfilter/nf_flow_table_offload.c
@@ -1382,3 +1382,7 @@ void nf_flow_table_offload_exit(void)
destroy_workqueue(nf_flow_offload_del_wq);
destroy_workqueue(nf_flow_offload_stats_wq);
}
+
+#if IS_ENABLED(CONFIG_NF_FLOW_TABLE_KUNIT_TEST)
+#include "nf_flow_table_offload_test.c"
+#endif
diff --git a/net/netfilter/nf_flow_table_offload_test.c b/net/netfilter/nf_flow_table_offload_test.c
new file mode 100644
index 000000000000..7e1764a8298a
--- /dev/null
+++ b/net/netfilter/nf_flow_table_offload_test.c
@@ -0,0 +1,129 @@
+// SPDX-License-Identifier: GPL-2.0-only
+#include <kunit/test.h>
+
+struct nf_flow_test_path {
+ struct dst_entry dst;
+ struct neighbour neigh;
+};
+
+struct nf_flow_test_ctx {
+ struct flow_offload flow;
+ struct nf_flow_test_path paths[FLOW_OFFLOAD_DIR_MAX];
+ struct net_device *dev;
+};
+
+static struct dst_entry *nf_flow_test_dst_check(struct dst_entry *dst, u32 cookie)
+{
+ return !dst->error && cookie == 42 ? dst : NULL;
+}
+
+static struct neighbour *nf_flow_test_neigh(const struct dst_entry *dst,
+ struct sk_buff *skb, const void *address)
+{
+ struct nf_flow_test_path *path = container_of(dst, struct nf_flow_test_path, dst);
+
+ return neigh_clone(&path->neigh);
+}
+
+static int nf_flow_test_init(struct kunit *test)
+{
+ static struct dst_ops ops = {
+ .family = AF_INET,
+ .check = nf_flow_test_dst_check,
+ .neigh_lookup = nf_flow_test_neigh,
+ };
+ const u8 mac[ETH_ALEN] = { 2, 0, 0, 0, 0, 1 };
+ struct nf_flow_test_ctx *ctx;
+ unsigned int dir;
+
+ ctx = kunit_kzalloc(test, sizeof(*ctx), GFP_KERNEL);
+ if (!ctx)
+ return -ENOMEM;
+ ctx->dev = kunit_kzalloc(test, sizeof(*ctx->dev), GFP_KERNEL);
+ if (!ctx->dev)
+ return -ENOMEM;
+ ctx->dev->ifindex = 10;
+ ctx->dev->addr_len = ETH_ALEN;
+ for (dir = 0; dir < FLOW_OFFLOAD_DIR_MAX; dir++) {
+ struct flow_offload_tuple *tuple = &ctx->flow.tuplehash[dir].tuple;
+ struct nf_flow_test_path *path = &ctx->paths[dir];
+
+ path->dst.dev = ctx->dev;
+ path->dst.ops = &ops;
+ path->dst.obsolete = DST_OBSOLETE_FORCE_CHK;
+ path->neigh.dev = ctx->dev;
+ path->neigh.nud_state = NUD_REACHABLE;
+ refcount_set(&path->neigh.refcnt, 1);
+ seqlock_init(&path->neigh.ha_lock);
+ ether_addr_copy(path->neigh.ha, mac);
+ tuple->dir = dir;
+ tuple->dst_cache = &path->dst;
+ tuple->dst_cookie = 42;
+ tuple->dst_validation_only = true;
+ tuple->xmit_type = FLOW_OFFLOAD_XMIT_DIRECT;
+ tuple->out.ifidx = ctx->dev->ifindex;
+ ether_addr_copy(tuple->out.h_dest, mac);
+ }
+ test->priv = ctx;
+ return 0;
+}
+
+static void nf_flow_test_cached_path(struct kunit *test)
+{
+ struct nf_flow_test_ctx *ctx = test->priv;
+ unsigned long cookie = (unsigned long)&ctx->flow.tuplehash[0].tuple;
+
+ /* Validation uses the selected dst and its cookie, without a new FIB
+ * lookup that could omit mark/DSCP/oif from the owner's routing context.
+ */
+ KUNIT_EXPECT_EQ(test, nf_flow_offload_validate(cookie), 0);
+ ctx->paths[1].dst.error = ENETUNREACH;
+ /* On-demand validation still checks a driver-only reference. */
+ KUNIT_EXPECT_TRUE(test, nf_flow_dst_check(&ctx->flow.tuplehash[1].tuple));
+ KUNIT_EXPECT_EQ(test, nf_flow_offload_validate(cookie), -ESTALE);
+ ctx->paths[1].dst.error = 0;
+ ctx->flow.tuplehash[1].tuple.dst_cookie = 41;
+ KUNIT_EXPECT_EQ(test, nf_flow_offload_validate(cookie), -ESTALE);
+ KUNIT_EXPECT_EQ(test, refcount_read(&ctx->paths[0].neigh.refcnt), 1);
+}
+
+static void nf_flow_test_neighbour_change(struct kunit *test)
+{
+ struct nf_flow_test_ctx *ctx = test->priv;
+ unsigned long cookie = (unsigned long)&ctx->flow.tuplehash[1].tuple;
+
+ ctx->paths[0].neigh.ha[5]++;
+ KUNIT_EXPECT_EQ(test, nf_flow_offload_validate(cookie), -ESTALE);
+ ctx->paths[0].neigh.ha[5]--;
+ ctx->paths[0].neigh.nud_state = NUD_FAILED;
+ KUNIT_EXPECT_EQ(test, nf_flow_offload_validate(cookie), -ESTALE);
+ KUNIT_EXPECT_EQ(test, refcount_read(&ctx->paths[0].neigh.refcnt), 1);
+}
+
+static void nf_flow_test_unsupported_context(struct kunit *test)
+{
+ struct nf_flow_test_ctx *ctx = test->priv;
+ unsigned long cookie = (unsigned long)&ctx->flow.tuplehash[0].tuple;
+ struct dst_entry *dst = ctx->flow.tuplehash[0].tuple.dst_cache;
+
+ ctx->flow.tuplehash[0].tuple.dst_cache = NULL;
+ KUNIT_EXPECT_EQ(test, nf_flow_offload_validate(cookie), -EOPNOTSUPP);
+ ctx->flow.tuplehash[0].tuple.dst_cache = dst;
+ ctx->flow.tuplehash[0].tuple.out.ifidx++;
+ KUNIT_EXPECT_EQ(test, nf_flow_offload_validate(cookie), -EOPNOTSUPP);
+}
+
+static struct kunit_case nf_flow_path_cases[] = {
+ KUNIT_CASE(nf_flow_test_cached_path),
+ KUNIT_CASE(nf_flow_test_neighbour_change),
+ KUNIT_CASE(nf_flow_test_unsupported_context),
+ {}
+};
+
+static struct kunit_suite nf_flow_path_suite = {
+ .name = "nf-flow-path",
+ .init = nf_flow_test_init,
+ .test_cases = nf_flow_path_cases,
+};
+
+kunit_test_suite(nf_flow_path_suite);
--
2.53.0
next prev parent reply other threads:[~2026-11-16 22:26 UTC|newest]
Thread overview: 12+ messages / expand[flat|nested] mbox.gz Atom feed top
2026-11-16 22:25 [PATCH net-next 0/9] net: bgmac: add Northstar IPv4 TCP/UDP NAT flowtable offload Florian Fainelli
2026-11-16 22:25 ` [PATCH net-next 1/9] net: ethernet: bgmac: validate RX length against the DMA packet capacity Florian Fainelli
2026-11-16 22:25 ` [PATCH net-next 2/9] netfilter: flowtable: reject non-host IPv4 packets before lookup Florian Fainelli
2026-11-16 22:25 ` [PATCH net-next 3/9] netfilter: flowtable: retain offload ownership until deletion completes Florian Fainelli
2026-11-16 22:25 ` [PATCH net-next 4/9] dt-bindings: net: describe the Northstar flow accelerator Florian Fainelli
2026-11-16 22:25 ` [PATCH net-next 5/9] net: dsa: add Broadcom FA metadata and IPv4 exception paths Florian Fainelli
2026-11-16 22:25 ` [PATCH net-next 6/9] net: flow_offload: allow drivers to validate and invalidate cached paths Florian Fainelli
2026-11-16 22:25 ` [PATCH net-next 7/9] net: bgmac: add Northstar IPv4 TCP/UDP NAT flowtable offload Florian Fainelli
2026-11-16 22:25 ` Florian Fainelli [this message]
2026-11-16 22:25 ` [PATCH net-next 9/9] docs: net: document Northstar FA setup and NAT qualification Florian Fainelli
2026-11-16 22:38 ` [PATCH net-next 0/9] net: bgmac: add Northstar IPv4 TCP/UDP NAT flowtable offload netdev-bot+sinfo
2026-11-16 22:45 ` Florian Fainelli
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=20261116222519.1416501-9-florian.fainelli@broadcom.com \
--to=florian.fainelli@broadcom.com \
--cc=andrew+netdev@lunn.ch \
--cc=bcm-kernel-feedback-list@broadcom.com \
--cc=conor+dt@kernel.org \
--cc=corbet@lwn.net \
--cc=coreteam@netfilter.org \
--cc=davem@davemloft.net \
--cc=devicetree@vger.kernel.org \
--cc=edumazet@kernel.org \
--cc=fw@strlen.de \
--cc=horms@kernel.org \
--cc=jonas.gorski@gmail.com \
--cc=krzk+dt@kernel.org \
--cc=kuba@kernel.org \
--cc=linux-doc@vger.kernel.org \
--cc=linux-kernel@vger.kernel.org \
--cc=netdev@vger.kernel.org \
--cc=netfilter-devel@vger.kernel.org \
--cc=olteanv@gmail.com \
--cc=pabeni@redhat.com \
--cc=pablo@netfilter.org \
--cc=phil@nwl.cc \
--cc=rafal@milecki.pl \
--cc=robh@kernel.org \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox
all inboxes | Powered by JetHome®