All of lore.kernel.org
 help / color / mirror / Atom feed
From: sashiko-bot@kernel.org
To: "Florian Fainelli" <florian.fainelli@broadcom.com>
Cc: "open list:OPEN FIRMWARE AND FLATTENED DEVICE TREE BINDINGS"
	<devicetree@vger.kernel.org>,
	robh@kernel.org, conor+dt@kernel.org
Subject: Re: [PATCH net-next 7/9] net: bgmac: add Northstar IPv4 TCP/UDP NAT flowtable offload
Date: Tue, 17 Nov 2026 22:33:59 +0000	[thread overview]
Message-ID: <sashiko-outbox-219755@kernel.org> (raw)
In-Reply-To: <20261116222519.1416501-8-florian.fainelli@broadcom.com>

Thank you for your contribution! Sashiko AI review found 4 potential
issues to consider:
- [High] net: bgmac: incomplete TCP flow retirement in fa_insert() and
  fa_control_match()
- [Medium] net: bgmac: unlocked block_list access and missing netns
  check in bcm_ns_fa_setup_tc()
- [Medium] net: bgmac: untracked neighbours in fa_route_check() and
  eviction in fa_netevent()
- [Low] net: bgmac: unlocked list_del_rcu() on fa_write() error path in
  fa_insert()
It also noticed 1 related pre-existing issue this patch does not
introduce:
- [Medium] net: bgmac: fixed PHY resource leak on probe error and remove
  paths [1]
--

commit 90c733393e363fb5e285d7f2e6d82b71424dc058
Author: Florian Fainelli <florian.fainelli@broadcom.com>

net: bgmac: add Northstar IPv4 TCP/UDP NAT flowtable offload

This commit adds IPv4 TCP/UDP NAT flowtable hardware offload support for
the Broadcom Northstar BCM4708/BCM5301X inline flow accelerator on GMAC2.

> diff --git a/drivers/net/ethernet/broadcom/bcm-ns-fa.c b/drivers/net/ethernet/broadcom/bcm-ns-fa.c
> new file mode 100644
> index 0000000000000..8665ba94cbab6
> --- /dev/null
> +++ b/drivers/net/ethernet/broadcom/bcm-ns-fa.c
[ ... ]
> +static bool fa_control_match(const struct fa_flow *entry,
> +			     const struct fa_tuple *tuple, unsigned int port,
> +			     bool ports_valid)
> +{
> +	size_t len = ports_valid ? sizeof(*tuple) : offsetof(struct fa_tuple, sport);
> +
> +	return entry->l4proto == IPPROTO_TCP && entry->in_port == port &&
> +	       !memcmp(&entry->tuple, tuple, len);
> +}

[ ... ]

> +static int fa_netevent(struct notifier_block *nb, unsigned long event, void *ptr)
> +{
> +	struct bcm_ns_fa *fa = container_of(nb, struct bcm_ns_fa, netevent_nb);
> +	struct fa_neighbour *cached = NULL;
> +	struct neighbour *neighbour = ptr;
> +	bool invalidate = false;
> +	unsigned int i;
> +	char mac[ETH_ALEN];
> +	__be32 address;
> +	u8 state;
> +
> +	if (event == NETEVENT_IPV4_MPATH_HASH_UPDATE ||
> +	    event == NETEVENT_IPV4_FWD_UPDATE_PRIORITY_UPDATE) {
> +		if (ptr == &init_net)
> +			fa_invalidate(fa);
> +		return NOTIFY_DONE;
> +	}
> +	if (event == NETEVENT_REDIRECT) {
> +		struct netevent_redirect *redirect = ptr;
> +
> +		if (net_eq(dev_net(redirect->new->dev), &init_net))
> +			fa_invalidate(fa);
> +		return NOTIFY_DONE;
> +	}
> +	if (event != NETEVENT_NEIGH_UPDATE || neighbour->tbl->family != AF_INET ||
> +	    !fa_port(fa, neighbour->dev))
> +		return NOTIFY_DONE;
> +	state = READ_ONCE(neighbour->nud_state);
> +	address = get_unaligned((__be32 *)neighbour->primary_key);
> +	neigh_ha_snapshot(mac, neighbour, neighbour->dev);
> +	spin_lock_bh(&fa->learn_lock);
> +	for (i = 0; i < ARRAY_SIZE(fa->neighbours); i++) {
> +		struct fa_neighbour *candidate = &fa->neighbours[i];
> +
> +		if (candidate->valid && candidate->ifindex == neighbour->dev->ifindex &&
> +		    candidate->address == address) {
> +			cached = candidate;
> +			invalidate = !(state & NUD_VALID) || memcmp(candidate->mac, mac, ETH_ALEN);
> +			break;
> +		}
> +	}
> +	if (!cached) {
> +		cached = &fa->neighbours[fa->neighbour_next++ % FA_NEXTHOPS];
> +		invalidate = cached->valid || !(state & NUD_VALID) || !list_empty(&fa->entries);
> +	}
> +	*cached = (struct fa_neighbour) {
> +		.address = address, .ifindex = neighbour->dev->ifindex,
> +		.state = state, .valid = true,
> +	};
> +	memcpy(cached->mac, mac, ETH_ALEN);
> +	spin_unlock_bh(&fa->learn_lock);
> +	if (invalidate)
> +		fa_invalidate(fa);
> +	return NOTIFY_DONE;
> +}

[Severity: Medium]
Can an admitted flow's next-hop neighbour be missing from fa->neighbours[],
preventing fa_neighbour_activity() from sending reachability probes?

fa->neighbours[] is only populated on NETEVENT_NEIGH_UPDATE while
fa_port(fa, neighbour->dev) is true; neither fa_route_check() nor
fa_insert() records the neighbour of an admitted flow.  A neighbour
resolved before fa_port() became true (such as before carrier-up or via a
static entry) is never added, and an existing entry can also be evicted by
128 failed ARP updates because fa_netevent() unconditionally writes
non-NUD_VALID updates into the ring with valid = true.

In addition, when !cached is true, invalidate is false if cached->valid is
false, state is NUD_VALID, and list_empty(&fa->entries) is true.  If the
first flow has already passed fa_route_check() and fa_learn_lookup() and is
sleeping in fa_mac_get() before being added to fa->entries, a
NETEVENT_NEIGH_UPDATE changing that uncached neighbour to a new NUD_VALID
MAC skips fa_invalidate() and lets fa_insert() commit the stale MAC to
hardware.

> +
> +static void fa_control_work(struct work_struct *work)
> +{
> +	struct bcm_ns_fa *fa = container_of(work, struct bcm_ns_fa, control_work);
> +	unsigned long generation;
> +	unsigned int i;
> +
> +	mutex_lock(&fa->lock);
> +	for (;;) {
> +		spin_lock_bh(&fa->learn_lock);
> +		generation = fa->pending_generation;
> +		spin_unlock_bh(&fa->learn_lock);
> +		for (i = 0; i < FA_SLOTS; i++) {
> +			struct fa_flow *entry = fa->flows[i];
> +
> +			if (entry && test_bit(FA_FLOW_CLOSING, &entry->flags) && entry->reverse)
> +				set_bit(FA_FLOW_CLOSING, &entry->reverse->flags);
> +		}
> +		for (i = 0; i < FA_SLOTS; i++)
> +			if (fa->flows[i] && test_bit(FA_FLOW_CLOSING, &fa->flows[i]->flags))
> +				fa_uninstall(fa, i);

[ ... ]

> +	list_add_rcu(&entry->list, &fa->entries);
> +	spin_unlock_bh(&fa->learn_lock);
> +	fa_encode(&rule, po, nh, entry->out_port, data);
> +	/* Publish to NAPI before committing: a concurrent control trap must
> +	 * stop lookups even if it arrives while this entry is being written.
> +	 */
> +	fa_control_update(fa, 0, FA_CTL_NO_DA_CHECK);
> +	err = fa_write(fa, FA_FLOW_TABLE, slot, data);
> +	if (err) {
> +		fa_fail(fa);
> +		list_del_rcu(&entry->list);
> +		netdev_put(entry->in, &entry->in_tracker);
> +		netdev_put(entry->out, &entry->out_tracker);
> +		kfree_rcu(entry, rcu);
> +		return err;
> +	}

[Severity: Low]
Should list_del_rcu(&entry->list) on the fa_write() error path hold
spin_lock_bh(&fa->learn_lock)?

fa_insert() adds entry to fa->entries under fa->learn_lock and fa_destroy()
holds fa->learn_lock around list_del_rcu(), whereas fa_fail() releases
fa->learn_lock before list_del_rcu() runs here, racing with readers under
fa->learn_lock such as list_empty(&fa->entries) in fa_netevent().

> +	entry->installed = true;
> +	if (rule.l4proto == IPPROTO_TCP) {
> +		struct fa_flow *other;
> +
> +		list_for_each_entry(other, &fa->entries, list) {
> +			if (other == entry || other->l4proto != IPPROTO_TCP || other->reverse ||
> +			    test_bit(FA_FLOW_CLOSING, &other->flags) ||
> +			    other->in_port != entry->out_port ||
> +			    other->out_port != entry->in_port ||
> +			    memcmp(&other->tuple, &entry->reply, sizeof(other->tuple)) ||
> +			    memcmp(&other->reply, &entry->tuple, sizeof(other->reply)))
> +				continue;
> +			entry->reverse = other;
> +			other->reverse = entry;
> +			break;
> +		}
> +	}
> +	entry->lastused = jiffies;
> +	fa->flows[slot] = entry;
> +	fa->nr_flows++;
> +	return 0;

[Severity: High]
Can a TCP direction remain active in the hardware flow table after a TCP
FIN, RST, or SYN control packet arrives in the opposite direction?

When flow_offload_rule_add() installs a bidirectional TCP flow, it calls
FLOW_CLS_REPLACE for the original direction (other) and then the reply
direction (entry).  In fa_insert(), entry is added to fa->entries before
fa_write() sleeps in fa_table_begin(), while entry->reverse and
other->reverse are only linked after fa_write() returns:

CPU0 (workqueue)                  CPU1 (GMAC0 NAPI)
fa_insert() [reply: entry]
  spin_lock_bh(&fa->learn_lock)
  list_add_rcu(&entry->list, ...)
  spin_unlock_bh(&fa->learn_lock)
  fa_write()
    fa_table_begin()
      fsleep(20)
                                  fa_control_receive()
                                    fa_tcp_control() [original tuple]
                                      /* matches other, not entry */
                                      set_bit(FA_FLOW_CLOSING,
                                              &other->flags)
                                      queue_work(..., &fa->control_work)
  list_for_each_entry(other, ...)
    if (... || test_bit(FA_FLOW_CLOSING, &other->flags))
      continue;  <-- skips other, reverse not linked
  fa->flows[slot] = entry;
mutex_unlock(&fa->lock)

fa_control_work()
  /* other->reverse is NULL */
  fa_uninstall(other)
  fa->control_pending = false
  fa_lookup_update(fa)  <-- re-enables lookup with entry still installed

The same happens if other was already retired by fa_control_work() (while
still in fa->entries with FA_FLOW_CLOSING set awaiting FLOW_CLS_DESTROY)
before fa_insert() runs for entry.

Also, if only one direction of a TCP flow was offloaded (for example, when
only one direction's miss hash was learned on GMAC2 or the reply bucket was
full), entry->reverse is NULL and fa_control_match() only checks
entry->in_port and entry->tuple, ignoring entry->out_port and entry->reply.
Any FIN, RST, or SYN arriving in the reply direction will not match in
fa_tcp_control() and will leave the offloaded direction in hardware.

[ ... ]

> +int bcm_ns_fa_setup_tc(struct bcm_ns_fa *fa, enum tc_setup_type type, void *data)
> +{
> +	struct flow_block_offload *block = data;
> +	struct flow_block_cb *cb;
> +
> +	if (!fa || type != TC_SETUP_FT ||
> +	    block->binder_type != FLOW_BLOCK_BINDER_TYPE_CLSACT_INGRESS)
> +		return -EOPNOTSUPP;
> +	block->driver_block_list = &fa->block_list;
> +	/* DSA forwards each user-port bind to the same conduit. Keep one
> +	 * callback per flowtable, with a reference for each bound user port.
> +	 */
> +	switch (block->command) {
> +	case FLOW_BLOCK_BIND:
> +		cb = flow_block_cb_lookup(block->block, fa_block_cb, fa);
> +		if (cb) {
> +			flow_block_cb_incref(cb);
> +			return 0;
> +		}
> +		/* Different flowtables have independent cookies and policy. The
> +		 * hardware cannot partition tables by ingress port or netns.
> +		 */
> +		if (!list_empty(&fa->block_list))
> +			return -EBUSY;
> +		cb = flow_block_cb_alloc(fa_block_cb, fa, fa, NULL);
> +		if (IS_ERR(cb))
> +			return PTR_ERR(cb);
> +		flow_block_cb_incref(cb);
> +		flow_block_cb_add(cb, block);
> +		list_add_tail(&cb->driver_list, &fa->block_list);
> +		return 0;
> +	case FLOW_BLOCK_UNBIND:
> +		cb = flow_block_cb_lookup(block->block, fa_block_cb, fa);
> +		if (!cb)
> +			return -ENOENT;
> +		bcm_ns_fa_flush(fa);
> +		if (!flow_block_cb_decref(cb)) {
> +			flow_block_cb_remove(cb, block);
> +			list_del(&cb->driver_list);
> +		}
> +		return 0;
> +	default:
> +		return -EOPNOTSUPP;
> +	}
> +}

[Severity: Medium]
Does bcm_ns_fa_setup_tc() need to hold fa->lock and reject binds outside
init_net?

nf_tables calls ndo_setup_tc(TC_SETUP_FT) under the per-netns commit_mutex
and per-flowtable flow_block_lock without holding rtnl_lock() or fa->lock.
If a DSA user port is moved to another network namespace, flowtable bind
and unbind operations in that namespace can race with init_net on
fa->block_list without synchronization, and binding a flowtable in a
non-initial namespace occupies fa->block_list (even though fa_port()
rejects rules outside init_net), blocking init_net with -EBUSY and flushing
hardware flows on unbind.

> diff --git a/drivers/net/ethernet/broadcom/bgmac.c b/drivers/net/ethernet/broadcom/bgmac.c
> index 1c502bd64d7df..527f9842eb833 100644
> --- a/drivers/net/ethernet/broadcom/bgmac.c
> +++ b/drivers/net/ethernet/broadcom/bgmac.c
[ ... ]
> @@ -1560,6 +1579,17 @@ int bgmac_enet_probe(struct bgmac *bgmac)
>  	net_dev->hw_features = net_dev->features;
>  	net_dev->vlan_features = net_dev->features;
>  
> +	bgmac->fa = bcm_ns_fa_init(net_dev);
> +	if (IS_ERR(bgmac->fa)) {
> +		err = PTR_ERR(bgmac->fa);
> +		bgmac->fa = NULL;
> +		goto err_phy_disconnect;
> +	}

[Severity: Medium]
This problem wasn't introduced by this patch, but jumping to
err_phy_disconnect (as well as the existing register_netdev() error path
and bgmac_enet_remove()) only calls phy_disconnect() without unregistering
the fixed PHY [1]:

drivers/net/ethernet/broadcom/bgmac.c:bgmac_phy_connect_direct() {
    ...
	phy_dev = fixed_phy_register(&fphy_status, NULL);
	if (IS_ERR(phy_dev)) {
		dev_err(bgmac->dev, "Failed to register fixed PHY device\n");
		return PTR_ERR(phy_dev);
	}

	err = phy_connect_direct(bgmac->net_dev, phy_dev, bgmac_adjust_link,
				 PHY_INTERFACE_MODE_MII);
	if (err) {
		dev_err(bgmac->dev, "Connecting PHY failed\n");
		return err;
	}
    ...
}

When a fixed PHY was registered via bgmac_phy_connect_direct() or
of_phy_get_and_connect() with a fixed-link DT node, failing to call
fixed_phy_unregister() (or of_phy_deregister_fixed_link()) leaks the
phy_device and one of the 8 global fixed_phy_ids slots.

[1] https://sashiko.dev/#/bug/linux-e2734269-f662-4a85-ac81-0eead2b697c2

-- 
Sashiko AI review · https://sashiko.dev/#/patchset/20261116222519.1416501-1-florian.fainelli@broadcom.com?part=7

  reply	other threads:[~2026-11-17 22:34 UTC|newest]

Thread overview: 29+ 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-17 23:29   ` netdev-bot+sashiko
2026-11-17 23:43     ` 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-17 22:33   ` sashiko-bot
2026-11-17 23:29   ` netdev-bot+sashiko
2026-11-17 23:51     ` Florian Fainelli
2026-11-16 22:25 ` [PATCH net-next 3/9] netfilter: flowtable: retain offload ownership until deletion completes Florian Fainelli
2026-11-17 22:33   ` sashiko-bot
2026-11-17 23:29   ` netdev-bot+sashiko
2026-11-17 23:57     ` Florian Fainelli
2026-11-16 22:25 ` [PATCH net-next 4/9] dt-bindings: net: describe the Northstar flow accelerator Florian Fainelli
2026-11-17 23:29   ` netdev-bot+sashiko
2026-11-16 22:25 ` [PATCH net-next 5/9] net: dsa: add Broadcom FA metadata and IPv4 exception paths Florian Fainelli
2026-11-17 22:33   ` sashiko-bot
2026-11-17 23:29   ` netdev-bot+sashiko
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-17 23:29   ` netdev-bot+sashiko
2026-11-16 22:25 ` [PATCH net-next 7/9] net: bgmac: add Northstar IPv4 TCP/UDP NAT flowtable offload Florian Fainelli
2026-11-17 22:33   ` sashiko-bot [this message]
2026-11-17 23:29   ` netdev-bot+sashiko
2026-11-16 22:25 ` [PATCH net-next 8/9] net: add KUnit coverage for FA and flowtable path validation Florian Fainelli
2026-11-17 22:34   ` sashiko-bot
2026-11-17 23:29   ` netdev-bot+sashiko
2026-11-16 22:25 ` [PATCH net-next 9/9] docs: net: document Northstar FA setup and NAT qualification Florian Fainelli
2026-11-17 23:29   ` netdev-bot+sashiko
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=sashiko-outbox-219755@kernel.org \
    --to=sashiko-bot@kernel.org \
    --cc=conor+dt@kernel.org \
    --cc=devicetree@vger.kernel.org \
    --cc=florian.fainelli@broadcom.com \
    --cc=robh@kernel.org \
    --cc=sashiko-reviews@lists.linux.dev \
    /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 an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.