neighbour: Remove bare neighbour::next pointer

Remove the now-unused neighbour::next pointer, leaving struct neighbour
solely with the hlist_node implementation.

Signed-off-by: Gilad Naaman <gnaaman@drivenets.com>
Reviewed-by: Kuniyuki Iwashima <kuniyu@amazon.com>
Reviewed-by: Eric Dumazet <edumazet@google.com>
Link: https://patch.msgid.link/20241107160444.2913124-6-gnaaman@drivenets.com
Signed-off-by: Jakub Kicinski <kuba@kernel.org>

diff --git a/include/net/neighbour.h b/include/net/neighbour.h
index 94cf4f8c118fbd92252a54cd83ba5456e69af71c..40aac1e24c68b6c5765e36fc71b8d2a618cae64c 100644 (file)
--- a/include/net/neighbour.h
+++ b/include/net/neighbour.h
@@ -135,7 +135,6 @@ struct neigh_statistics {
 #define NEIGH_CACHE_STAT_INC(tbl, field) this_cpu_inc((tbl)->stats->field)
 
 struct neighbour {
-       struct neighbour __rcu  *next;
        struct hlist_node       hash;
        struct neigh_table      *tbl;
        struct neigh_parms      *parms;
@@ -191,7 +190,6 @@ struct pneigh_entry {
 #define NEIGH_NUM_HASH_RND     4
 
 struct neigh_hash_table {
-       struct neighbour __rcu  **hash_buckets;
        struct hlist_head       *hash_heads;
        unsigned int            hash_shift;
        __u32                   hash_rnd[NEIGH_NUM_HASH_RND];
@@ -354,7 +352,7 @@ int __neigh_event_send(struct neighbour *neigh, struct sk_buff *skb,
 int neigh_update(struct neighbour *neigh, const u8 *lladdr, u8 new, u32 flags,
                 u32 nlmsg_pid);
 void __neigh_set_probe_once(struct neighbour *neigh);
-bool neigh_remove_one(struct neighbour *ndel, struct neigh_table *tbl);
+bool neigh_remove_one(struct neighbour *ndel);
 void neigh_changeaddr(struct neigh_table *tbl, struct net_device *dev);
 int neigh_ifdown(struct neigh_table *tbl, struct net_device *dev);
 int neigh_carrier_down(struct neigh_table *tbl, struct net_device *dev);

diff --git a/net/core/neighbour.c b/net/core/neighbour.c
index f99354d768c24e681ab7400a5d7d763a3227384d..59f359c7b5e3f1b0edf7add4829c8079c8ac5159 100644 (file)
--- a/net/core/neighbour.c
+++ b/net/core/neighbour.c
@@ -204,18 +204,12 @@ static void neigh_update_flags(struct neighbour *neigh, u32 flags, int *notify,
        }
 }
 
-static bool neigh_del(struct neighbour *n, struct neighbour __rcu **np,
-                     struct neigh_table *tbl)
+bool neigh_remove_one(struct neighbour *n)
 {
        bool retval = false;
 
        write_lock(&n->lock);
        if (refcount_read(&n->refcnt) == 1) {
-               struct neighbour *neigh;
-
-               neigh = rcu_dereference_protected(n->next,
-                                                 lockdep_is_held(&tbl->lock));
-               rcu_assign_pointer(*np, neigh);
                hlist_del_rcu(&n->hash);
                neigh_mark_dead(n);
                retval = true;
@@ -226,29 +220,6 @@ static bool neigh_del(struct neighbour *n, struct neighbour __rcu **np,
        return retval;
 }
 
-bool neigh_remove_one(struct neighbour *ndel, struct neigh_table *tbl)
-{
-       struct neigh_hash_table *nht;
-       void *pkey = ndel->primary_key;
-       u32 hash_val;
-       struct neighbour *n;
-       struct neighbour __rcu **np;
-
-       nht = rcu_dereference_protected(tbl->nht,
-                                       lockdep_is_held(&tbl->lock));
-       hash_val = tbl->hash(pkey, ndel->dev, nht->hash_rnd);
-       hash_val = hash_val >> (32 - nht->hash_shift);
-
-       np = &nht->hash_buckets[hash_val];
-       while ((n = rcu_dereference_protected(*np,
-                                             lockdep_is_held(&tbl->lock)))) {
-               if (n == ndel)
-                       return neigh_del(n, np, tbl);
-               np = &n->next;
-       }
-       return false;
-}
-
 static int neigh_forced_gc(struct neigh_table *tbl)
 {
        int max_clean = atomic_read(&tbl->gc_entries) -
@@ -276,7 +247,7 @@ static int neigh_forced_gc(struct neigh_table *tbl)
                                remove = true;
                        write_unlock(&n->lock);
 
-                       if (remove && neigh_remove_one(n, tbl))
+                       if (remove && neigh_remove_one(n))
                                shrunk++;
                        if (shrunk >= max_clean)
                                break;
@@ -387,22 +358,15 @@ static void neigh_flush_dev(struct neigh_table *tbl, struct net_device *dev,
                                        lockdep_is_held(&tbl->lock));
 
        for (i = 0; i < (1 << nht->hash_shift); i++) {
-               struct neighbour __rcu **np = &nht->hash_buckets[i];
                struct hlist_node *tmp;
                struct neighbour *n;
 
                neigh_for_each_in_bucket_safe(n, tmp, &nht->hash_heads[i]) {
-                       if (dev && n->dev != dev) {
-                               np = &n->next;
+                       if (dev && n->dev != dev)
                                continue;
-                       }
-                       if (skip_perm && n->nud_state & NUD_PERMANENT) {
-                               np = &n->next;
+                       if (skip_perm && n->nud_state & NUD_PERMANENT)
                                continue;
-                       }
-                       rcu_assign_pointer(*np,
-                                  rcu_dereference_protected(n->next,
-                                               lockdep_is_held(&tbl->lock)));
+
                        hlist_del_rcu(&n->hash);
                        write_lock(&n->lock);
                        neigh_del_timer(n);
@@ -531,9 +495,7 @@ static void neigh_get_hash_rnd(u32 *x)
 
 static struct neigh_hash_table *neigh_hash_alloc(unsigned int shift)
 {
-       size_t hash_heads_size = (1 << shift) * sizeof(struct hlist_head);
-       size_t size = (1 << shift) * sizeof(struct neighbour *);
-       struct neighbour __rcu **buckets;
+       size_t size = (1 << shift) * sizeof(struct hlist_head);
        struct hlist_head *hash_heads;
        struct neigh_hash_table *ret;
        int i;
@@ -542,18 +504,11 @@ static struct neigh_hash_table *neigh_hash_alloc(unsigned int shift)
        if (!ret)
                return NULL;
 
-       buckets = kvzalloc(size, GFP_ATOMIC);
-       if (!buckets) {
-               kfree(ret);
-               return NULL;
-       }
-       hash_heads = kvzalloc(hash_heads_size, GFP_ATOMIC);
+       hash_heads = kvzalloc(size, GFP_ATOMIC);
        if (!hash_heads) {
-               kvfree(buckets);
                kfree(ret);
                return NULL;
        }
-       ret->hash_buckets = buckets;
        ret->hash_heads = hash_heads;
        ret->hash_shift = shift;
        for (i = 0; i < NEIGH_NUM_HASH_RND; i++)
@@ -567,7 +522,6 @@ static void neigh_hash_free_rcu(struct rcu_head *head)
                                                    struct neigh_hash_table,
                                                    rcu);
 
-       kvfree(nht->hash_buckets);
        kvfree(nht->hash_heads);
        kfree(nht);
 }
@@ -596,11 +550,6 @@ static struct neigh_hash_table *neigh_hash_grow(struct neigh_table *tbl,
 
                        hash >>= (32 - new_nht->hash_shift);
 
-                       rcu_assign_pointer(n->next,
-                                          rcu_dereference_protected(
-                                               new_nht->hash_buckets[hash],
-                                               lockdep_is_held(&tbl->lock)));
-                       rcu_assign_pointer(new_nht->hash_buckets[hash], n);
                        hlist_del_rcu(&n->hash);
                        hlist_add_head_rcu(&n->hash, &new_nht->hash_heads[hash]);
                }
@@ -705,10 +654,6 @@ ___neigh_create(struct neigh_table *tbl, const void *pkey,
                list_add_tail(&n->managed_list, &n->tbl->managed_list);
        if (want_ref)
                neigh_hold(n);
-       rcu_assign_pointer(n->next,
-                          rcu_dereference_protected(nht->hash_buckets[hash_val],
-                                                    lockdep_is_held(&tbl->lock)));
-       rcu_assign_pointer(nht->hash_buckets[hash_val], n);
        hlist_add_head_rcu(&n->hash, &nht->hash_heads[hash_val]);
        write_unlock_bh(&tbl->lock);
        neigh_dbg(2, "neigh %p is created\n", n);
@@ -942,7 +887,6 @@ static void neigh_periodic_work(struct work_struct *work)
 {
        struct neigh_table *tbl = container_of(work, struct neigh_table, gc_work.work);
        struct neigh_hash_table *nht;
-       struct neighbour __rcu **np;
        struct hlist_node *tmp;
        struct neighbour *n;
        unsigned int i;
@@ -970,8 +914,6 @@ static void neigh_periodic_work(struct work_struct *work)
                goto out;
 
        for (i = 0 ; i < (1 << nht->hash_shift); i++) {
-               np = &nht->hash_buckets[i];
-
                neigh_for_each_in_bucket_safe(n, tmp, &nht->hash_heads[i]) {
                        unsigned int state;
 
@@ -981,7 +923,7 @@ static void neigh_periodic_work(struct work_struct *work)
                        if ((state & (NUD_PERMANENT | NUD_IN_TIMER)) ||
                            (n->flags & NTF_EXT_LEARNED)) {
                                write_unlock(&n->lock);
-                               goto next_elt;
+                               continue;
                        }
 
                        if (time_before(n->used, n->confirmed) &&
@@ -992,9 +934,6 @@ static void neigh_periodic_work(struct work_struct *work)
                            (state == NUD_FAILED ||
                             !time_in_range_open(jiffies, n->used,
                                                 n->used + NEIGH_VAR(n->parms, GC_STALETIME)))) {
-                               rcu_assign_pointer(*np,
-                                       rcu_dereference_protected(n->next,
-                                               lockdep_is_held(&tbl->lock)));
                                hlist_del_rcu(&n->hash);
                                neigh_mark_dead(n);
                                write_unlock(&n->lock);
@@ -1002,9 +941,6 @@ static void neigh_periodic_work(struct work_struct *work)
                                continue;
                        }
                        write_unlock(&n->lock);
-
-next_elt:
-                       np = &n->next;
                }
                /*
                 * It's fine to release lock here, even if hash table
@@ -1951,7 +1887,7 @@ static int neigh_delete(struct sk_buff *skb, struct nlmsghdr *nlh,
                             NETLINK_CB(skb).portid, extack);
        write_lock_bh(&tbl->lock);
        neigh_release(neigh);
-       neigh_remove_one(neigh, tbl);
+       neigh_remove_one(neigh);
        write_unlock_bh(&tbl->lock);
 
 out:
@@ -3108,24 +3044,18 @@ void __neigh_for_each_release(struct neigh_table *tbl,
        nht = rcu_dereference_protected(tbl->nht,
                                        lockdep_is_held(&tbl->lock));
        for (chain = 0; chain < (1 << nht->hash_shift); chain++) {
-               struct neighbour __rcu **np;
                struct hlist_node *tmp;
                struct neighbour *n;
 
-               np = &nht->hash_buckets[chain];
                neigh_for_each_in_bucket_safe(n, tmp, &nht->hash_heads[chain]) {
                        int release;
 
                        write_lock(&n->lock);
                        release = cb(n);
                        if (release) {
-                               rcu_assign_pointer(*np,
-                                       rcu_dereference_protected(n->next,
-                                               lockdep_is_held(&tbl->lock)));
                                hlist_del_rcu(&n->hash);
                                neigh_mark_dead(n);
-                       } else
-                               np = &n->next;
+                       }
                        write_unlock(&n->lock);
                        if (release)
                                neigh_cleanup_and_release(n);

diff --git a/net/ipv4/arp.c b/net/ipv4/arp.c
index 11c1519b36993d9b12b261079792c360fa152d48..cb9a7ed8abd3ab17403f226ea7e31ea2bae52a9f 100644 (file)
--- a/net/ipv4/arp.c
+++ b/net/ipv4/arp.c
@@ -1215,7 +1215,7 @@ int arp_invalidate(struct net_device *dev, __be32 ip, bool force)
                                           NEIGH_UPDATE_F_ADMIN, 0);
                write_lock_bh(&tbl->lock);
                neigh_release(neigh);
-               neigh_remove_one(neigh, tbl);
+               neigh_remove_one(neigh);
                write_unlock_bh(&tbl->lock);
        }