rculfqueue: LGPL-ize

[urcu.git] / urcu / rculfqueue.h

diff --git a/urcu/rculfqueue.h b/urcu/rculfqueue.h
index 09e5d41ea0db7b7f40032419b070ed55daecdfdd..f229cc77ca8d8a741a516dc4f3bbcae2cd67a90e 100644 (file)
--- a/urcu/rculfqueue.h
+++ b/urcu/rculfqueue.h
@@ -1,3 +1,6 @@
+#ifndef _URCU_RCULFQUEUE_H
+#define _URCU_RCULFQUEUE_H
+
 /*
  * rculfqueue.h
  *
@@ -23,8 +26,8 @@
 #include <urcu/urcu_ref.h>
 #include <assert.h>
 
-#if (!defined(_GNU_SOURCE) && !defined(_LGPL_SOURCE))
-#error "Dynamic loader LGPL wrappers not implemented yet"
+#ifdef __cplusplus
+extern "C" {
 #endif
 
 /*
@@ -37,8 +40,6 @@
  * which point their reference count will be decremented.
  */
 
-#define URCU_LFQ_PERMANENT_REF         128
-
 struct rcu_lfq_node {
        struct rcu_lfq_node *next;
        struct urcu_ref ref;
@@ -49,91 +50,38 @@ struct rcu_lfq_queue {
        struct rcu_lfq_node init;       /* Dummy initialization node */
 };
 
-void rcu_lfq_node_init(struct rcu_lfq_node *node)
-{
-       node->next = NULL;
-       urcu_ref_init(&node->ref);
-}
+#ifdef _LGPL_SOURCE
 
-void rcu_lfq_init(struct rcu_lfq_queue *q)
-{
-       rcu_lfq_node_init(&q->init);
-       /* Make sure the initial node is never freed. */
-       urcu_ref_set(&q->init.ref, URCU_LFQ_PERMANENT_REF);
-       q->head = q->tail = &q->init;
-}
+#include <urcu/rculfqueue-static.h>
 
-void rcu_lfq_enqueue(struct rcu_lfq_queue *q, struct rcu_lfq_node *node)
-{
-       urcu_ref_get(&node->ref);
+#define rcu_lfq_node_init      _rcu_lfq_node_init
+#define rcu_lfq_init           _rcu_lfq_init
+#define rcu_lfq_enqueue                _rcu_lfq_enqueue
+#define rcu_lfq_dequeue                _rcu_lfq_dequeue
 
-       /*
-        * uatomic_cmpxchg() implicit memory barrier orders earlier stores to
-        * node before publication.
-        */
+#else /* !_LGPL_SOURCE */
 
-       for (;;) {
-               struct rcu_lfq_node *tail, *next;
-
-               rcu_read_lock();
-               tail = rcu_dereference(q->tail);
-               /*
-                * Typically expect tail->next to be NULL.
-                */
-               next = uatomic_cmpxchg(&tail->next, NULL, node);
-               if (next == NULL) {
-                       /*
-                        * Tail was at the end of queue, we successfully
-                        * appended to it.
-                        * Now move tail (another enqueue might beat
-                        * us to it, that's fine).
-                        */
-                       uatomic_cmpxchg(&q->tail, tail, node);
-                       rcu_read_unlock();
-                       return;
-               } else {
-                       /*
-                        * Failure to append to current tail. Help moving tail
-                        * further and retry.
-                        */
-                       uatomic_cmpxchg(&q->tail, tail, next);
-                       rcu_read_unlock();
-                       continue;
-               }
-       }
-}
+extern void rcu_lfq_node_init(struct rcu_lfq_node *node);
+extern void rcu_lfq_init(struct rcu_lfq_queue *q);
+extern void rcu_lfq_enqueue(struct rcu_lfq_queue *q, struct rcu_lfq_node *node);
 
 /*
  * The entry returned by dequeue must be taken care of by doing a urcu_ref_put,
  * which calls the release primitive when the reference count drops to zero. A
- * grace period must be waited before performing the actual memory reclamation
- * in the release primitive.
- * The entry lfq node returned by dequeue must not be re-used before the
- * reference count reaches zero.
+ * grace period must be waited after execution of the release callback before
+ * performing the actual memory reclamation or modifying the rcu_lfq_node
+ * structure.
+ * In other words, the entry lfq node returned by dequeue must not be
+ * modified/re-used/freed until the reference count reaches zero and a grace
+ * period has elapsed (after the refcount reached 0).
  */
-struct rcu_lfq_node *
-rcu_lfq_dequeue(struct rcu_lfq_queue *q, void (*release)(struct urcu_ref *))
-{
-       for (;;) {
-               struct rcu_lfq_node *head, *next;
+extern struct rcu_lfq_node *
+rcu_lfq_dequeue(struct rcu_lfq_queue *q, void (*release)(struct urcu_ref *));
+
+#endif /* !_LGPL_SOURCE */
 
-               rcu_read_lock();
-               head = rcu_dereference(q->head);
-               next = rcu_dereference(head->next);
-               if (next) {
-                       if (uatomic_cmpxchg(&q->head, head, next) == head) {
-                               rcu_read_unlock();
-                               urcu_ref_put(&head->ref, release);
-                               return next;
-                       } else {
-                               /* Concurrently pushed, retry */
-                               rcu_read_unlock();
-                               continue;
-                       }
-               } else {
-                       /* Empty */
-                       rcu_read_unlock();
-                       return NULL;
-               }
-       }
+#ifdef __cplusplus
 }
+#endif
+
+#endif /* _URCU_RCULFQUEUE_H */