[PATCH v2 0/2] Add and use neigh_parms_lookup_dev()

[PATCH v2 0/2] Add and use neigh_parms_lookup_dev()

[Paritosh Potukuchi]

This series follows up on a previous submission where it was suggested
that neigh_parms_lookup_dev() be accompanied by its users.

Patch 1 adds neigh_parms_lookup_dev() to expose per-device
neigh_parms lookup outside of the neighbour subsystem.

Patch 2 updates bonding to reuse an existing neigh_setup()
callback from the slave's neigh_parms when available, while
preserving the existing ndo_neigh_setup() fallback path.

v2:
 - Convert the previous submission into a patch series
 - Add bonding user of neigh_parms_lookup_dev() as requested.

Previous post's link:
https://lore.kernel.org/netdev/CAAVpQUBf+asQukcRw7sJz6vS2VdeNO5+Q5ucoCxf4JgK25nZ7g@mail.gmail.com/T/#t


Paritosh Potukuchi (2):
  net: neighbour: add neigh_parms_lookup_dev() helper
  bonding: reuse neigh_setup from slave neigh_parms

 drivers/net/bonding/bond_main.c | 10 +++++++++-
 include/net/neighbour.h         |  2 ++
 net/core/neighbour.c            |  8 ++++++++
 3 files changed, 19 insertions(+), 1 deletion(-)

-- 
2.43.0

[PATCH v2 1/2] net: neighbour: add neigh_parms_lookup_dev() helper

[Paritosh Potukuchi]

Provide a helper to lookup neigh_parms associated
with a given (neigh_table, net_device) pair.

The existing lookup_neigh_parms() helper is internal to the
neighbour subsystem and cannot be used by other subsystems.
Some stacked/virtual devices like bond require access to the
underlying device's neigh_parms.

neigh_parms_lookup_dev() is designed to be a wrapper around
lookup_neigh_parms(). The function provides controlled access
to per device neigh_parms.

The caller is expected to hold rcu_read_lock().

This does not break any existing functionality.

Signed-off-by: Paritosh Potukuchi <paritosh.potukuchi@amd.com>
---
 include/net/neighbour.h | 2 ++
 net/core/neighbour.c    | 8 ++++++++
 2 files changed, 10 insertions(+)

diff --git a/include/net/neighbour.h b/include/net/neighbour.h
index 8860cc2175fc..1b3b06eda886 100644
--- a/include/net/neighbour.h
+++ b/include/net/neighbour.h
@@ -438,6 +438,8 @@ int neigh_sysctl_register(struct net_device *dev, struct neigh_parms *p,
 			  proc_handler *proc_handler);
 void neigh_sysctl_unregister(struct neigh_parms *p);
 
+struct neigh_parms *neigh_parms_lookup_dev(struct neigh_table *tbl, struct net_device *dev);
+
 static inline void __neigh_parms_put(struct neigh_parms *parms)
 {
 	refcount_dec(&parms->refcnt);
diff --git a/net/core/neighbour.c b/net/core/neighbour.c
index 1349c0eedb64..6d32c2668af3 100644
--- a/net/core/neighbour.c
+++ b/net/core/neighbour.c
@@ -1757,6 +1757,14 @@ static inline struct neigh_parms *lookup_neigh_parms(struct neigh_table *tbl,
 	return NULL;
 }
 
+/* Caller must hold rcu_read_lock()*/
+
+struct neigh_parms *neigh_parms_lookup_dev(struct neigh_table *tbl, struct net_device *dev)
+{
+	return lookup_neigh_parms(tbl, dev_net(dev), dev->ifindex);
+}
+EXPORT_SYMBOL(neigh_parms_lookup_dev);
+
 struct neigh_parms *neigh_parms_alloc(struct net_device *dev,
 				      struct neigh_table *tbl)
 {
-- 
2.43.0

[PATCH v2 2/2] bonding: reuse neigh_setup from slave neigh_parms

[Paritosh Potukuchi]

bond_neigh_init() currently relies on the slave device's
ndo_neigh_setup() callback to obtain a neigh_setup() handler.

When an initialized neigh_parms instance already exists for the
slave device, reuse the neigh_setup() callback stored in it instead
of invoking ndo_neigh_setup() again.

If no neigh_parms instance is found, or no neigh_setup() callback is
present, retain the existing ndo_neigh_setup() fallback path.

This avoids unnecessary ndo_neigh_setup() invocations while preserving
existing behaviour.

Signed-off-by: Paritosh Potukuchi <paritosh.potukuchi@amd.com>
---
 drivers/net/bonding/bond_main.c | 10 +++++++++-
 1 file changed, 9 insertions(+), 1 deletion(-)

diff --git a/drivers/net/bonding/bond_main.c b/drivers/net/bonding/bond_main.c
index e044fc733b8c..d2e4dae4e97c 100644
--- a/drivers/net/bonding/bond_main.c
+++ b/drivers/net/bonding/bond_main.c
@@ -4719,7 +4719,7 @@ static int bond_neigh_init(struct neighbour *n)
 {
 	struct bonding *bond = netdev_priv(n->dev);
 	const struct net_device_ops *slave_ops;
-	struct neigh_parms parms;
+	struct neigh_parms parms, *p;
 	struct slave *slave;
 	int ret = 0;
 
@@ -4727,6 +4727,14 @@ static int bond_neigh_init(struct neighbour *n)
 	slave = bond_first_slave_rcu(bond);
 	if (!slave)
 		goto out;
+
+	p = neigh_parms_lookup_dev(n->tbl, slave->dev);
+
+	if (p && p->neigh_setup) {
+		ret = p->neigh_setup(n);
+		goto out;
+	}
+
 	slave_ops = slave->dev->netdev_ops;
 	if (!slave_ops->ndo_neigh_setup)
 		goto out;
-- 
2.43.0

Re: [PATCH v2 2/2] bonding: reuse neigh_setup from slave neigh_parms

[Kuniyuki Iwashima]

From: Paritosh Potukuchi <paritoshpotukuchi@gmail.com>
Date: Wed,  1 Jul 2026 08:16:00 +0000
> bond_neigh_init() currently relies on the slave device's
> ndo_neigh_setup() callback to obtain a neigh_setup() handler.
> 
> When an initialized neigh_parms instance already exists for the
> slave device, reuse the neigh_setup() callback stored in it instead
> of invoking ndo_neigh_setup() again.
> 
> If no neigh_parms instance is found, or no neigh_setup() callback is
> present, retain the existing ndo_neigh_setup() fallback path.
> 
> This avoids unnecessary ndo_neigh_setup() invocations while preserving
> existing behaviour.
> 
> Signed-off-by: Paritosh Potukuchi <paritosh.potukuchi@amd.com>
> ---
>  drivers/net/bonding/bond_main.c | 10 +++++++++-
>  1 file changed, 9 insertions(+), 1 deletion(-)
> 
> diff --git a/drivers/net/bonding/bond_main.c b/drivers/net/bonding/bond_main.c
> index e044fc733b8c..d2e4dae4e97c 100644
> --- a/drivers/net/bonding/bond_main.c
> +++ b/drivers/net/bonding/bond_main.c
> @@ -4719,7 +4719,7 @@ static int bond_neigh_init(struct neighbour *n)
>  {
>  	struct bonding *bond = netdev_priv(n->dev);
>  	const struct net_device_ops *slave_ops;
> -	struct neigh_parms parms;
> +	struct neigh_parms parms, *p;
>  	struct slave *slave;
>  	int ret = 0;
>  
> @@ -4727,6 +4727,14 @@ static int bond_neigh_init(struct neighbour *n)
>  	slave = bond_first_slave_rcu(bond);
>  	if (!slave)
>  		goto out;
> +
> +	p = neigh_parms_lookup_dev(n->tbl, slave->dev);

This introduces O(n) list traversal while it can be done
with fixed costs (3 dereferences + 1 call).

Since neigh_table is global (arp_tbl or nd_tbl), the O(n)
list traversal could take longer and rather de-optimise.


> +
> +	if (p && p->neigh_setup) {
> +		ret = p->neigh_setup(n);
> +		goto out;
> +	}
> +
>  	slave_ops = slave->dev->netdev_ops;
>  	if (!slave_ops->ndo_neigh_setup)
>  		goto out;
> -- 
> 2.43.0

Re: [PATCH v2 2/2] bonding: reuse neigh_setup from slave neigh_parms

[Paritosh Potukuchi]

Hi Kuniyuki,

>This introduces O(n) list traversal while it can be done
>with fixed costs (3 dereferences + 1 call).

>Since neigh_table is global (arp_tbl or nd_tbl), the O(n)
>list traversal could take longer and rather de-optimise.

Yes, that is true. One reason why I chose to do that is
because ndo_neigh_setup is a function primarily meant 
to setup the neigh_parms structure, when neigh_parms does
not exist.
On the other hand, lookup_neigh_parms is meant
to search for a near-complete neigh_parms structure,
that is already associated with a netdev. 
Even if we want to use ndo_neigh_setup, since it takes
less time, I would suggest using it as a fallback to 
not finding an already existing parms, setup.

Moreover, time complexity might not be an issue in this
path since, this is rarely used aggresively. 


One issue with ndo_neigh_setup in bond-like devices is
that, to get the underlying netdevs neigh_setup function,
it expects us to pass a dummy neigh_parms structure that 
has been zeroed out. This seems to be fragile as suggested
in a TODO in bond_neigh_init(). 
Generally its main goal is to fill the parms.neigh_setup 
field.

Can we populate a few more fields in the zeroed-
out parms structure, before passing to the driver in 
ndo_neigh_setup? That seems to be a much safer approach.

Regards,
Paritosh