rculist: add list_splice_rcu() for private lists
Subsystems (4)
Pablo Neira Ayuso
maintainerPATCH v2 1/3 rculist: add list_splice_rcu() for private lists
This patch adds a helper function, list_splice_rcu(), to safely splice a private (non-RCU-protected) list into an RCU-protected list.
The function ensures that only the pointer visible to RCU readers (prev->next) is updated using rcu_assign_pointer(), while the rest of the list manipulations are performed with regular assignments, as the source list is private and not visible to concurrent RCU readers.
This is useful for moving elements from a private list into a global RCU-protected list, ensuring safe publication for RCU readers. Subsystems with some sort of batching mechanism from userspace can benefit from this new function.
The function __list_splice_rcu() has been added for clarity and to follow the same pattern as in the existing list_splice*() interfaces, where there is a check to ensure that that the list to splice is not empty. Note that __list_splice_rcu() has no documentation for this reason.
---
v2: including comments by Paul McKenney.
Except, I have deliberately keep back the suggestion to squash __list_splice_rcu() into list_splice_rcu(), I instead removed the documentation for __list_splice_rcu(). I am looking at other existing list_splice*() function in list.h and rculist.h to get this aligned with __list_splice(), which also has no users in the tree and no documentation. I find it easier to read with __list_splice(), but if this explaination is not sound so...
@Paul: I can post v3 squashing __list_splice_rcu(), just let me
know.
Thanks!
include/linux/rculist.h | 29 +++++++++++++++++++++++++++++ 1 file changed, 29 insertions(+)
include/linux/rculist.h +29 -0
@@ -261,6 +261,35 @@ static inline void list_replace_rcu(struct list_head *old, old->prev =LIST_POISON2 ; } +static inline void __list_splice_rcu (struct list_head *list, +struct list_head *prev, +struct list_head *next) +{ +struct list_head *first = list->next; +struct list_head *last = list->prev; + + last->next = next; + first->prev = prev; + next->prev = last; +rcu_assign_pointer (list_next_rcu (prev), first); +} + +/** +* list_splice_rcu - splice a non-RCU list into an RCU-protected list, +* designed for stacks. +* @list: the non RCU-protected list to splice +* @head: the place in the existing RCU-protected list to splice +* +* The list pointed to by @head can be RCU-read traversed concurrently with +* this function. +*/ +static inline void list_splice_rcu (struct list_head *list, +struct list_head *head) +{ +if (!list_empty (list)) +__list_splice_rcu (list, head, head->next); +} +/** * __list_splice_init_rcu - join an RCU-protected list into an existing list. * @list: the RCU-protected list to splice
Signature · 1 line
2.47.3
Quoted 31 lines · Pablo Neira Ayuso
This patch adds a helper function,
list_splice_rcu(), to safely splice a private (non-RCU-protected) list into an RCU-protected list.The function ensures that only the pointer visible to RCU readers (
prev->next) is updated usingrcu_assign_pointer(), while the rest of the list manipulations are performed with regular assignments, as the source list is private and not visible to concurrent RCU readers.This is useful for moving elements from a private list into a global RCU-protected list, ensuring safe publication for RCU readers. Subsystems with some sort of batching mechanism from userspace can benefit from this new function.
The function
__list_splice_rcu()has been added for clarity and to follow the same pattern as in the existing list_splice*() interfaces, where there is a check to ensure that that the list to splice is not empty. Note that__list_splice_rcu()has no documentation for this reason.Signed-off-by Pablo Neira Ayuso <[email protected]>---
v2: including comments by Paul McKenney.Except, I have deliberately keep back the suggestion to squash
__list_splice_rcu()intolist_splice_rcu(), I instead removed the documentation for__list_splice_rcu(). I am looking at other existing list_splice*() function inlist.handrculist.hto get this aligned with__list_splice(), which also has no users in the tree and no documentation. I find it easier to read with__list_splice(), but if this explaination is not sound so...
Quoted 2 lines
@Paul: I can post v3 squashing
__list_splice_rcu(), just let me
know.
Removing the comment addresses most of my concerns. I do have a slight but not overwhelming preference for the squashed version, but either way:
Or if you want this to go in via RCU, please let us know. My guess is that it would be easier for you to take it in with the code using it.
Thanx, Paul
Quoted 49 lines
Thanks!
include/linux/rculist.h | 29 +++++++++++++++++++++++++++++ 1 file changed, 29 insertions(+)include/linux/rculist.h +29
-0@@ -261,6 +261,35 @@ static inline void list_replace_rcu(struct list_head *old, old->prev =LIST_POISON2 ; } +static inline void __list_splice_rcu (struct list_head *list, +struct list_head *prev, +struct list_head *next) +{ +struct list_head *first = list->next; +struct list_head *last = list->prev; + + last->next = next; + first->prev = prev; + next->prev = last; +rcu_assign_pointer (list_next_rcu (prev), first); +} + +/** +* list_splice_rcu - splice a non-RCU list into an RCU-protected list, +* designed for stacks. +* @list: the non RCU-protected list to splice +* @head: the place in the existing RCU-protected list to splice +* +* The list pointed to by @head can be RCU-read traversed concurrently with +* this function. +*/ +static inline void list_splice_rcu (struct list_head *list, +struct list_head *head) +{ +if (!list_empty (list)) +__list_splice_rcu (list, head, head->next); +} +/** * __list_splice_init_rcu - join an RCU-protected list into an existing list. * @list: the RCU-protected list to splice Signature · 1 line
2.47.3
Pablo Neira Ayuso
maintainerQuoted 35 lines · Paul E. McKenney
Quoted 31 lines · Pablo Neira Ayuso
This patch adds a helper function,
list_splice_rcu(), to safely splice a private (non-RCU-protected) list into an RCU-protected list.The function ensures that only the pointer visible to RCU readers (
prev->next) is updated usingrcu_assign_pointer(), while the rest of the list manipulations are performed with regular assignments, as the source list is private and not visible to concurrent RCU readers.This is useful for moving elements from a private list into a global RCU-protected list, ensuring safe publication for RCU readers. Subsystems with some sort of batching mechanism from userspace can benefit from this new function.
The function
__list_splice_rcu()has been added for clarity and to follow the same pattern as in the existing list_splice*() interfaces, where there is a check to ensure that that the list to splice is not empty. Note that__list_splice_rcu()has no documentation for this reason.Signed-off-by Pablo Neira Ayuso <[email protected]>---
v2: including comments by Paul McKenney.Except, I have deliberately keep back the suggestion to squash
__list_splice_rcu()intolist_splice_rcu(), I instead removed the documentation for__list_splice_rcu(). I am looking at other existing list_splice*() function inlist.handrculist.hto get this aligned with__list_splice(), which also has no users in the tree and no documentation. I find it easier to read with__list_splice(), but if this explaination is not sound so...Quoted 2 lines
@Paul: I can post v3 squashing
__list_splice_rcu(), just let me
know.
Quoted 7 lines
Removing the comment addresses most of my concerns. I do have a slight but not overwhelming preference for the squashed version, but either way:
Reviewed-by Paul E. McKenney <[email protected]>Or if you want this to go in via RCU, please let us know. My guess is that it would be easier for you to take it in with the code using it.
I'd prefer to take it through nf.git, I need this as a fix for an invalid use of list_splice() on a RCU-protected list.
Thanks for your quick review Paul!