]> err.no Git - linux-2.6/commitdiff
[PATCH] add an RCU version of list splicing
authorCorey Minyard <minyard@acm.org>
Sat, 10 Feb 2007 09:45:42 +0000 (01:45 -0800)
committerLinus Torvalds <torvalds@woody.linux-foundation.org>
Sun, 11 Feb 2007 18:51:31 +0000 (10:51 -0800)
This patch is in support of the IPMI driver.  I have tested this with the
IPMI driver changes coming in the next patch.

Add a list_splice_init_rcu() function to splice an RCU-protected list into
another list.  This takes the sync function as an argument, so one would do
something like:

INIT_LIST_HEAD(&list);
list_splice_init_rcu(&source, &dest, synchronize_rcu);

The idea being to keep the RCU API proliferation down to a dull roar.

[akpm@osdl.org: build fix]
Signed-off-by: Paul E. McKenney <paulmck@linux.vnet.ibm.com>
Signed-off-by: Corey Minyard <minyard@acm.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
include/linux/list.h

index 611059d633f4a9fcf2ec435309564b4b4bb0b126..cdc96559e5aed675a02b1a48df8fa9e1773c89ab 100644 (file)
@@ -359,6 +359,62 @@ static inline void list_splice_init(struct list_head *list,
        }
 }
 
+/**
+ * list_splice_init_rcu - splice an RCU-protected list into an existing list.
+ * @list:      the RCU-protected list to splice
+ * @head:      the place in the list to splice the first list into
+ * @sync:      function to sync: synchronize_rcu(), synchronize_sched(), ...
+ *
+ * @head can be RCU-read traversed concurrently with this function.
+ *
+ * Note that this function blocks.
+ *
+ * Important note: the caller must take whatever action is necessary to
+ *     prevent any other updates to @head.  In principle, it is possible
+ *     to modify the list as soon as sync() begins execution.
+ *     If this sort of thing becomes necessary, an alternative version
+ *     based on call_rcu() could be created.  But only if -really-
+ *     needed -- there is no shortage of RCU API members.
+ */
+static inline void list_splice_init_rcu(struct list_head *list,
+                                       struct list_head *head,
+                                       void (*sync)(void))
+{
+       struct list_head *first = list->next;
+       struct list_head *last = list->prev;
+       struct list_head *at = head->next;
+
+       if (list_empty(head))
+               return;
+
+       /* "first" and "last" tracking list, so initialize it. */
+
+       INIT_LIST_HEAD(list);
+
+       /*
+        * At this point, the list body still points to the source list.
+        * Wait for any readers to finish using the list before splicing
+        * the list body into the new list.  Any new readers will see
+        * an empty list.
+        */
+
+       sync();
+
+       /*
+        * Readers are finished with the source list, so perform splice.
+        * The order is important if the new list is global and accessible
+        * to concurrent RCU readers.  Note that RCU readers are not
+        * permitted to traverse the prev pointers without excluding
+        * this function.
+        */
+
+       last->next = at;
+       smp_wmb();
+       head->next = first;
+       first->prev = head;
+       at->prev = last;
+}
+
 /**
  * list_entry - get the struct for this entry
  * @ptr:       the &struct list_head pointer.