在 2025/9/16 06:50, Kuniyuki Iwashima 写道:

On Mon, Sep 15, 2025 at 12:04 AM [off-list ref] wrote:

quoted

From: Xuanqiang Luo <redacted>

Add two functions to atomically replace RCU-protected hlist_nulls entries.

Signed-off-by: Xuanqiang Luo <redacted>
---
  include/linux/rculist_nulls.h | 62 +++++++++++++++++++++++++++++++++++
  1 file changed, 62 insertions(+)

diff --git a/include/linux/rculist_nulls.h b/include/linux/rculist_nulls.h
index 89186c499dd4..eaa3a0d2f206 100644
--- a/include/linux/rculist_nulls.h
+++ b/include/linux/rculist_nulls.h

@@ -152,6 +152,68 @@ static inline void hlist_nulls_add_fake(struct hlist_nulls_node *n)
         n->next = (struct hlist_nulls_node *)NULLS_MARKER(NULL);
  }

+/**
+ * __hlist_nulls_replace_rcu - replace an old entry by a new one
+ * @old: the element to be replaced
+ * @new: the new element to insert
+ *
+ * Description:
+ * Replace the old entry with the new one in a RCU-protected hlist_nulls, while
+ * permitting racing traversals.
+ *
+ * The caller must take whatever precautions are necessary (such as holding
+ * appropriate locks) to avoid racing with another list-mutation primitive, such
+ * as hlist_nulls_add_head_rcu() or hlist_nulls_del_rcu(), running on this same
+ * list.  However, it is perfectly legal to run concurrently with the _rcu
+ * list-traversal primitives, such as hlist_nulls_for_each_entry_rcu().
+ */
+static inline void __hlist_nulls_replace_rcu(struct hlist_nulls_node *old,
+                                            struct hlist_nulls_node *new)
+{
+       struct hlist_nulls_node *next = old->next;
+
+       new->next = next;
+       WRITE_ONCE(new->pprev, old->pprev);
+       rcu_assign_pointer(*(struct hlist_nulls_node __rcu **)new->pprev, new);
+       if (!is_a_nulls(next))
+               WRITE_ONCE(new->next->pprev, &new->next);
+}
+
+/**
+ * hlist_nulls_replace_init_rcu - replace an old entry by a new one and
+ * initialize the old
+ * @old: the element to be replaced
+ * @new: the new element to insert
+ *
+ * Description:
+ * Replace the old entry with the new one in a RCU-protected hlist_nulls, while
+ * permitting racing traversals, and reinitialize the old entry.
+ *
+ * Return: true if the old entry was hashed and was replaced successfully, false
+ * otherwise.
+ *
+ * Note: hlist_nulls_unhashed() on the old node returns true after this.
+ * It is useful for RCU based read lockfree traversal if the writer side must
+ * know if the list entry is still hashed or already unhashed.
+ *
+ * The caller must take whatever precautions are necessary (such as holding
+ * appropriate locks) to avoid racing with another list-mutation primitive, such
+ * as hlist_nulls_add_head_rcu() or hlist_nulls_del_rcu(), running on this same
+ * list. However, it is perfectly legal to run concurrently with the _rcu
+ * list-traversal primitives, such as hlist_nulls_for_each_entry_rcu().
+ */
+static inline bool hlist_nulls_replace_init_rcu(struct hlist_nulls_node *old,
+                                               struct hlist_nulls_node *new)
+{
+       if (!hlist_nulls_unhashed(old)) {

This is already checked by __sk_nulls_replace_node_init_rcu().

It seems to me that hlist_nulls_replace_init_rcu() checks whether the
sk_nulls_node is unhashed, while __sk_nulls_replace_node_init_rcu() checks the
sk_node's unhashed status. Perhaps these serve different purposes?
This would maintain parity with how hlist_nulls_del_init_rcu verifies
sk_nulls_node and __sk_nulls_del_node_init_rcu() checks sk_node.


Thanks
Xuanqiang

quoted

+               __hlist_nulls_replace_rcu(old, new);
+               old->pprev = NULL;
+               return true;
+       }
+
+       return false;
+}
+
  /**
   * hlist_nulls_for_each_entry_rcu - iterate over rcu list of given type
   * @tpos:      the type * to use as a loop cursor.
--
2.27.0