This is the third and last patch of the namespace refactoring.
The prefix cds_ stands for Concurrent Data Structure and is
use for queue, list, hlist and stack.
For RCU protected data strucutre, the prefix is also added but
the suffix _rcu is appended. This suffix indicate and RCU protection.
Signed-off-by: David Goulet <david.goulet@polymtl.ca>
Signed-off-by: Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
* library wrappers to be used by non-LGPL compatible source code.
*/
-void rcu_lfq_node_init(struct rcu_lfq_node *node)
+void cds_lfq_node_init_rcu(struct cds_lfq_node_rcu *node)
{
- _rcu_lfq_node_init(node);
+ _cds_lfq_node_init_rcu(node);
}
-void rcu_lfq_init(struct rcu_lfq_queue *q)
+void cds_lfq_init_rcu(struct cds_lfq_queue_rcu *q)
{
- _rcu_lfq_init(q);
+ _cds_lfq_init_rcu(q);
}
-void rcu_lfq_enqueue(struct rcu_lfq_queue *q, struct rcu_lfq_node *node)
+void cds_lfq_enqueue_rcu(struct cds_lfq_queue_rcu *q, struct cds_lfq_node_rcu *node)
{
- _rcu_lfq_enqueue(q, node);
+ _cds_lfq_enqueue_rcu(q, node);
}
-struct rcu_lfq_node *
-rcu_lfq_dequeue(struct rcu_lfq_queue *q, void (*release)(struct urcu_ref *))
+struct cds_lfq_node_rcu *
+cds_lfq_dequeue_rcu(struct cds_lfq_queue_rcu *q, void (*release)(struct urcu_ref *))
{
- return _rcu_lfq_dequeue(q, release);
+ return _cds_lfq_dequeue_rcu(q, release);
}
*/
-void rcu_lfs_node_init(struct rcu_lfs_node *node)
+void cds_lfs_node_init_rcu(struct cds_lfs_node_rcu *node)
{
- _rcu_lfs_node_init(node);
+ _cds_lfs_node_init_rcu(node);
}
-void rcu_lfs_init(struct rcu_lfs_stack *s)
+void cds_lfs_init_rcu(struct cds_lfs_stack_rcu *s)
{
- _rcu_lfs_init(s);
+ _cds_lfs_init_rcu(s);
}
-void rcu_lfs_push(struct rcu_lfs_stack *s, struct rcu_lfs_node *node)
+void cds_lfs_push_rcu(struct cds_lfs_stack_rcu *s, struct cds_lfs_node_rcu *node)
{
- _rcu_lfs_push(s, node);
+ _cds_lfs_push_rcu(s, node);
}
-struct rcu_lfs_node *rcu_lfs_pop(struct rcu_lfs_stack *s)
+struct cds_lfs_node_rcu *cds_lfs_pop_rcu(struct cds_lfs_stack_rcu *s)
{
- return _rcu_lfs_pop(s);
+ return _cds_lfs_pop_rcu(s);
}
* using the generic single-entry routines.
*/
-struct list_head {
- struct list_head *next, *prev;
+struct cds_list_head {
+ struct cds_list_head *next, *prev;
};
-#define LIST_HEAD_INIT(name) { &(name), &(name) }
+#define CDS_LIST_HEAD_INIT(name) { &(name), &(name) }
-#define LIST_HEAD(name) \
- struct list_head name = LIST_HEAD_INIT(name)
+#define CDS_LIST_HEAD(name) \
+ struct cds_list_head name = CDS_LIST_HEAD_INIT(name)
-static inline void INIT_LIST_HEAD(struct list_head *list)
+static inline void CDS_INIT_LIST_HEAD(struct cds_list_head *list)
{
list->next = list;
list->prev = list;
* the prev/next entries already!
*/
#ifndef CONFIG_DEBUG_LIST
-static inline void __list_add(struct list_head *new,
- struct list_head *prev,
- struct list_head *next)
+static inline void __cds_list_add(struct cds_list_head *new,
+ struct cds_list_head *prev,
+ struct cds_list_head *next)
{
next->prev = new;
new->next = next;
prev->next = new;
}
#else
-extern void __list_add(struct list_head *new,
- struct list_head *prev,
- struct list_head *next);
+extern void __cds_list_add(struct cds_list_head *new,
+ struct cds_list_head *prev,
+ struct cds_list_head *next);
#endif
/**
- * list_add - add a new entry
+ * cds_list_add - add a new entry
* @new: new entry to be added
* @head: list head to add it after
*
* Insert a new entry after the specified head.
* This is good for implementing stacks.
*/
-static inline void list_add(struct list_head *new, struct list_head *head)
+static inline void cds_list_add(struct cds_list_head *new, struct cds_list_head *head)
{
- __list_add(new, head, head->next);
+ __cds_list_add(new, head, head->next);
}
/**
- * list_add_tail - add a new entry
+ * cds_list_add_tail - add a new entry
* @new: new entry to be added
* @head: list head to add it before
*
* Insert a new entry before the specified head.
* This is useful for implementing queues.
*/
-static inline void list_add_tail(struct list_head *new, struct list_head *head)
+static inline void cds_list_add_tail(struct cds_list_head *new, struct cds_list_head *head)
{
- __list_add(new, head->prev, head);
+ __cds_list_add(new, head->prev, head);
}
/*
* This is only for internal list manipulation where we know
* the prev/next entries already!
*/
-static inline void __list_del(struct list_head * prev, struct list_head * next)
+static inline void __cds_list_del(struct cds_list_head * prev, struct cds_list_head * next)
{
next->prev = prev;
prev->next = next;
}
/**
- * list_del - deletes entry from list.
+ * cds_list_del - deletes entry from list.
* @entry: the element to delete from the list.
- * Note: list_empty() on entry does not return true after this, the entry is
+ * Note: cds_list_empty() on entry does not return true after this, the entry is
* in an undefined state.
*/
#ifndef CONFIG_DEBUG_LIST
-static inline void list_del(struct list_head *entry)
+static inline void cds_list_del(struct cds_list_head *entry)
{
- __list_del(entry->prev, entry->next);
+ __cds_list_del(entry->prev, entry->next);
entry->next = LIST_POISON1;
entry->prev = LIST_POISON2;
}
#else
-extern void list_del(struct list_head *entry);
+extern void cds_list_del(struct cds_list_head *entry);
#endif
/**
- * list_replace - replace old entry by new one
+ * cds_list_replace - replace old entry by new one
* @old : the element to be replaced
* @new : the new element to insert
*
* If @old was empty, it will be overwritten.
*/
-static inline void list_replace(struct list_head *old,
- struct list_head *new)
+static inline void cds_list_replace(struct cds_list_head *old,
+ struct cds_list_head *new)
{
new->next = old->next;
new->next->prev = new;
new->prev->next = new;
}
-static inline void list_replace_init(struct list_head *old,
- struct list_head *new)
+static inline void cds_list_replace_init(struct cds_list_head *old,
+ struct cds_list_head *new)
{
- list_replace(old, new);
- INIT_LIST_HEAD(old);
+ cds_list_replace(old, new);
+ CDS_INIT_LIST_HEAD(old);
}
/**
- * list_del_init - deletes entry from list and reinitialize it.
+ * cds_list_del_init - deletes entry from list and reinitialize it.
* @entry: the element to delete from the list.
*/
-static inline void list_del_init(struct list_head *entry)
+static inline void cds_list_del_init(struct cds_list_head *entry)
{
- __list_del(entry->prev, entry->next);
- INIT_LIST_HEAD(entry);
+ __cds_list_del(entry->prev, entry->next);
+ CDS_INIT_LIST_HEAD(entry);
}
/**
- * list_move - delete from one list and add as another's head
+ * cds_list_move - delete from one list and add as another's head
* @list: the entry to move
* @head: the head that will precede our entry
*/
-static inline void list_move(struct list_head *list, struct list_head *head)
+static inline void cds_list_move(struct cds_list_head *list, struct cds_list_head *head)
{
- __list_del(list->prev, list->next);
- list_add(list, head);
+ __cds_list_del(list->prev, list->next);
+ cds_list_add(list, head);
}
/**
- * list_move_tail - delete from one list and add as another's tail
+ * cds_list_move_tail - delete from one list and add as another's tail
* @list: the entry to move
* @head: the head that will follow our entry
*/
-static inline void list_move_tail(struct list_head *list,
- struct list_head *head)
+static inline void cds_list_move_tail(struct cds_list_head *list,
+ struct cds_list_head *head)
{
- __list_del(list->prev, list->next);
- list_add_tail(list, head);
+ __cds_list_del(list->prev, list->next);
+ cds_list_add_tail(list, head);
}
/**
* @list: the entry to test
* @head: the head of the list
*/
-static inline int list_is_last(const struct list_head *list,
- const struct list_head *head)
+static inline int list_is_last(const struct cds_list_head *list,
+ const struct cds_list_head *head)
{
return list->next == head;
}
/**
- * list_empty - tests whether a list is empty
+ * cds_list_empty - tests whether a list is empty
* @head: the list to test.
*/
-static inline int list_empty(const struct list_head *head)
+static inline int cds_list_empty(const struct cds_list_head *head)
{
return head->next == head;
}
/**
- * list_empty_careful - tests whether a list is empty and not being modified
+ * cds_list_empty_careful - tests whether a list is empty and not being modified
* @head: the list to test
*
* Description:
* tests whether a list is empty _and_ checks that no other CPU might be
* in the process of modifying either member (next or prev)
*
- * NOTE: using list_empty_careful() without synchronization
+ * NOTE: using cds_list_empty_careful() without synchronization
* can only be safe if the only activity that can happen
- * to the list entry is list_del_init(). Eg. it cannot be used
+ * to the list entry is cds_list_del_init(). Eg. it cannot be used
* if another CPU could re-list_add() it.
*/
-static inline int list_empty_careful(const struct list_head *head)
+static inline int cds_list_empty_careful(const struct cds_list_head *head)
{
- struct list_head *next = head->next;
+ struct cds_list_head *next = head->next;
return (next == head) && (next == head->prev);
}
* list_is_singular - tests whether a list has just one entry.
* @head: the list to test.
*/
-static inline int list_is_singular(const struct list_head *head)
+static inline int list_is_singular(const struct cds_list_head *head)
{
return !list_empty(head) && (head->next == head->prev);
}
-static inline void __list_cut_position(struct list_head *list,
- struct list_head *head, struct list_head *entry)
+static inline void __list_cut_position(struct cds_list_head *list,
+ struct cds_list_head *head, struct cds_list_head *entry)
{
- struct list_head *new_first = entry->next;
+ struct cds_list_head *new_first = entry->next;
list->next = head->next;
list->next->prev = list;
list->prev = entry;
* losing its data.
*
*/
-static inline void list_cut_position(struct list_head *list,
- struct list_head *head, struct list_head *entry)
+static inline void list_cut_position(struct cds_list_head *list,
+ struct cds_list_head *head, struct cds_list_head *entry)
{
- if (list_empty(head))
+ if (cds_list_empty(head))
return;
if (list_is_singular(head) &&
(head->next != entry && head != entry))
return;
if (entry == head)
- INIT_LIST_HEAD(list);
+ CDS_INIT_LIST_HEAD(list);
else
__list_cut_position(list, head, entry);
}
-static inline void __list_splice(const struct list_head *list,
- struct list_head *prev,
- struct list_head *next)
+static inline void __cds_list_splice(const struct cds_list_head *list,
+ struct cds_list_head *prev,
+ struct cds_list_head *next)
{
- struct list_head *first = list->next;
- struct list_head *last = list->prev;
+ struct cds_list_head *first = list->next;
+ struct cds_list_head *last = list->prev;
first->prev = prev;
prev->next = first;
}
/**
- * list_splice - join two lists, this is designed for stacks
+ * cds_list_splice - join two lists, this is designed for stacks
* @list: the new list to add.
* @head: the place to add it in the first list.
*/
-static inline void list_splice(const struct list_head *list,
- struct list_head *head)
+static inline void cds_list_splice(const struct cds_list_head *list,
+ struct cds_list_head *head)
{
- if (!list_empty(list))
- __list_splice(list, head, head->next);
+ if (!cds_list_empty(list))
+ __cds_list_splice(list, head, head->next);
}
/**
- * list_splice_tail - join two lists, each list being a queue
+ * cds_list_splice_tail - join two lists, each list being a queue
* @list: the new list to add.
* @head: the place to add it in the first list.
*/
-static inline void list_splice_tail(struct list_head *list,
- struct list_head *head)
+static inline void cds_list_splice_tail(struct cds_list_head *list,
+ struct cds_list_head *head)
{
- if (!list_empty(list))
- __list_splice(list, head->prev, head);
+ if (!cds_list_empty(list))
+ __cds_list_splice(list, head->prev, head);
}
/**
- * list_splice_init - join two lists and reinitialise the emptied list.
+ * cds_list_splice_init - join two lists and reinitialise the emptied list.
* @list: the new list to add.
* @head: the place to add it in the first list.
*
* The list at @list is reinitialised
*/
-static inline void list_splice_init(struct list_head *list,
- struct list_head *head)
+static inline void cds_list_splice_init(struct cds_list_head *list,
+ struct cds_list_head *head)
{
- if (!list_empty(list)) {
- __list_splice(list, head, head->next);
- INIT_LIST_HEAD(list);
+ if (!cds_list_empty(list)) {
+ __cds_list_splice(list, head, head->next);
+ CDS_INIT_LIST_HEAD(list);
}
}
/**
- * list_splice_tail_init - join two lists and reinitialise the emptied list
+ * cds_list_splice_tail_init - join two lists and reinitialise the emptied list
* @list: the new list to add.
* @head: the place to add it in the first list.
*
* Each of the lists is a queue.
* The list at @list is reinitialised
*/
-static inline void list_splice_tail_init(struct list_head *list,
- struct list_head *head)
+static inline void cds_list_splice_tail_init(struct cds_list_head *list,
+ struct cds_list_head *head)
{
- if (!list_empty(list)) {
- __list_splice(list, head->prev, head);
- INIT_LIST_HEAD(list);
+ if (!cds_list_empty(list)) {
+ __cds_list_splice(list, head->prev, head);
+ CDS_INIT_LIST_HEAD(list);
}
}
/**
- * list_entry - get the struct for this entry
- * @ptr: the &struct list_head pointer.
+ * cds_list_entry - get the struct for this entry
+ * @ptr: the &struct cds_list_head pointer.
* @type: the type of the struct this is embedded in.
* @member: the name of the list_struct within the struct.
*/
-#define list_entry(ptr, type, member) \
+#define cds_list_entry(ptr, type, member) \
caa_container_of(ptr, type, member)
/**
* Note, that list is expected to be not empty.
*/
#define list_first_entry(ptr, type, member) \
- list_entry((ptr)->next, type, member)
+ cds_list_entry((ptr)->next, type, member)
/**
- * list_for_each - iterate over a list
- * @pos: the &struct list_head to use as a loop cursor.
+ * cds_list_for_each - iterate over a list
+ * @pos: the &struct cds_list_head to use as a loop cursor.
* @head: the head for your list.
*/
-#define list_for_each(pos, head) \
+#define cds_list_for_each(pos, head) \
for (pos = (head)->next; prefetch(pos->next), pos != (head); \
pos = pos->next)
/**
- * __list_for_each - iterate over a list
- * @pos: the &struct list_head to use as a loop cursor.
+ * __cds_list_for_each - iterate over a list
+ * @pos: the &struct cds_list_head to use as a loop cursor.
* @head: the head for your list.
*
- * This variant differs from list_for_each() in that it's the
+ * This variant differs from cds_list_for_each() in that it's the
* simplest possible list iteration code, no prefetching is done.
* Use this for code that knows the list to be very short (empty
* or 1 entry) most of the time.
*/
-#define __list_for_each(pos, head) \
+#define __cds_list_for_each(pos, head) \
for (pos = (head)->next; pos != (head); pos = pos->next)
/**
- * list_for_each_prev - iterate over a list backwards
- * @pos: the &struct list_head to use as a loop cursor.
+ * cds_list_for_each_prev - iterate over a list backwards
+ * @pos: the &struct cds_list_head to use as a loop cursor.
* @head: the head for your list.
*/
-#define list_for_each_prev(pos, head) \
+#define cds_list_for_each_prev(pos, head) \
for (pos = (head)->prev; prefetch(pos->prev), pos != (head); \
pos = pos->prev)
/**
- * list_for_each_safe - iterate over a list safe against removal of list entry
- * @pos: the &struct list_head to use as a loop cursor.
- * @n: another &struct list_head to use as temporary storage
+ * cds_list_for_each_safe - iterate over a list safe against removal of list entry
+ * @pos: the &struct cds_list_head to use as a loop cursor.
+ * @n: another &struct cds_list_head to use as temporary storage
* @head: the head for your list.
*/
-#define list_for_each_safe(pos, n, head) \
+#define cds_list_for_each_safe(pos, n, head) \
for (pos = (head)->next, n = pos->next; pos != (head); \
pos = n, n = pos->next)
/**
- * list_for_each_prev_safe - iterate over a list backwards safe against removal of list entry
- * @pos: the &struct list_head to use as a loop cursor.
- * @n: another &struct list_head to use as temporary storage
+ * cds_list_for_each_prev_safe - iterate over a list backwards safe against removal of list entry
+ * @pos: the &struct cds_list_head to use as a loop cursor.
+ * @n: another &struct cds_list_head to use as temporary storage
* @head: the head for your list.
*/
-#define list_for_each_prev_safe(pos, n, head) \
+#define cds_list_for_each_prev_safe(pos, n, head) \
for (pos = (head)->prev, n = pos->prev; \
prefetch(pos->prev), pos != (head); \
pos = n, n = pos->prev)
/**
- * list_for_each_entry - iterate over list of given type
+ * cds_list_for_each_entry - iterate over list of given type
* @pos: the type * to use as a loop cursor.
* @head: the head for your list.
* @member: the name of the list_struct within the struct.
*/
-#define list_for_each_entry(pos, head, member) \
- for (pos = list_entry((head)->next, typeof(*pos), member); \
+#define cds_list_for_each_entry(pos, head, member) \
+ for (pos = cds_list_entry((head)->next, typeof(*pos), member); \
prefetch(pos->member.next), &pos->member != (head); \
- pos = list_entry(pos->member.next, typeof(*pos), member))
+ pos = cds_list_entry(pos->member.next, typeof(*pos), member))
/**
- * list_for_each_entry_reverse - iterate backwards over list of given type.
+ * cds_list_for_each_entry_reverse - iterate backwards over list of given type.
* @pos: the type * to use as a loop cursor.
* @head: the head for your list.
* @member: the name of the list_struct within the struct.
*/
-#define list_for_each_entry_reverse(pos, head, member) \
- for (pos = list_entry((head)->prev, typeof(*pos), member); \
+#define cds_list_for_each_entry_reverse(pos, head, member) \
+ for (pos = cds_list_entry((head)->prev, typeof(*pos), member); \
prefetch(pos->member.prev), &pos->member != (head); \
- pos = list_entry(pos->member.prev, typeof(*pos), member))
+ pos = cds_list_entry(pos->member.prev, typeof(*pos), member))
/**
- * list_prepare_entry - prepare a pos entry for use in list_for_each_entry_continue()
+ * list_prepare_entry - prepare a pos entry for use in cds_list_for_each_entry_continue()
* @pos: the type * to use as a start point
* @head: the head of the list
* @member: the name of the list_struct within the struct.
*
- * Prepares a pos entry for use as a start point in list_for_each_entry_continue().
+ * Prepares a pos entry for use as a start point in cds_list_for_each_entry_continue().
*/
#define list_prepare_entry(pos, head, member) \
- ((pos) ? : list_entry(head, typeof(*pos), member))
+ ((pos) ? : cds_list_entry(head, typeof(*pos), member))
/**
- * list_for_each_entry_continue - continue iteration over list of given type
+ * cds_list_for_each_entry_continue - continue iteration over list of given type
* @pos: the type * to use as a loop cursor.
* @head: the head for your list.
* @member: the name of the list_struct within the struct.
* Continue to iterate over list of given type, continuing after
* the current position.
*/
-#define list_for_each_entry_continue(pos, head, member) \
- for (pos = list_entry(pos->member.next, typeof(*pos), member); \
+#define cds_list_for_each_entry_continue(pos, head, member) \
+ for (pos = cds_list_entry(pos->member.next, typeof(*pos), member); \
prefetch(pos->member.next), &pos->member != (head); \
- pos = list_entry(pos->member.next, typeof(*pos), member))
+ pos = cds_list_entry(pos->member.next, typeof(*pos), member))
/**
- * list_for_each_entry_continue_reverse - iterate backwards from the given point
+ * cds_list_for_each_entry_continue_reverse - iterate backwards from the given point
* @pos: the type * to use as a loop cursor.
* @head: the head for your list.
* @member: the name of the list_struct within the struct.
* Start to iterate over list of given type backwards, continuing after
* the current position.
*/
-#define list_for_each_entry_continue_reverse(pos, head, member) \
- for (pos = list_entry(pos->member.prev, typeof(*pos), member); \
+#define cds_list_for_each_entry_continue_reverse(pos, head, member) \
+ for (pos = cds_list_entry(pos->member.prev, typeof(*pos), member); \
prefetch(pos->member.prev), &pos->member != (head); \
- pos = list_entry(pos->member.prev, typeof(*pos), member))
+ pos = cds_list_entry(pos->member.prev, typeof(*pos), member))
/**
- * list_for_each_entry_from - iterate over list of given type from the current point
+ * cds_list_for_each_entry_from - iterate over list of given type from the current point
* @pos: the type * to use as a loop cursor.
* @head: the head for your list.
* @member: the name of the list_struct within the struct.
*
* Iterate over list of given type, continuing from current position.
*/
-#define list_for_each_entry_from(pos, head, member) \
+#define cds_list_for_each_entry_from(pos, head, member) \
for (; prefetch(pos->member.next), &pos->member != (head); \
- pos = list_entry(pos->member.next, typeof(*pos), member))
+ pos = cds_list_entry(pos->member.next, typeof(*pos), member))
/**
- * list_for_each_entry_safe - iterate over list of given type safe against removal of list entry
+ * cds_list_for_each_entry_safe - iterate over list of given type safe against removal of list entry
* @pos: the type * to use as a loop cursor.
* @n: another type * to use as temporary storage
* @head: the head for your list.
* @member: the name of the list_struct within the struct.
*/
-#define list_for_each_entry_safe(pos, n, head, member) \
- for (pos = list_entry((head)->next, typeof(*pos), member), \
- n = list_entry(pos->member.next, typeof(*pos), member); \
+#define cds_list_for_each_entry_safe(pos, n, head, member) \
+ for (pos = cds_list_entry((head)->next, typeof(*pos), member), \
+ n = cds_list_entry(pos->member.next, typeof(*pos), member); \
&pos->member != (head); \
- pos = n, n = list_entry(n->member.next, typeof(*n), member))
+ pos = n, n = cds_list_entry(n->member.next, typeof(*n), member))
/**
- * list_for_each_entry_safe_continue
+ * cds_list_for_each_entry_safe_continue
* @pos: the type * to use as a loop cursor.
* @n: another type * to use as temporary storage
* @head: the head for your list.
* Iterate over list of given type, continuing after current point,
* safe against removal of list entry.
*/
-#define list_for_each_entry_safe_continue(pos, n, head, member) \
- for (pos = list_entry(pos->member.next, typeof(*pos), member), \
- n = list_entry(pos->member.next, typeof(*pos), member); \
+#define cds_list_for_each_entry_safe_continue(pos, n, head, member) \
+ for (pos = cds_list_entry(pos->member.next, typeof(*pos), member), \
+ n = cds_list_entry(pos->member.next, typeof(*pos), member); \
&pos->member != (head); \
- pos = n, n = list_entry(n->member.next, typeof(*n), member))
+ pos = n, n = cds_list_entry(n->member.next, typeof(*n), member))
/**
- * list_for_each_entry_safe_from
+ * cds_list_for_each_entry_safe_from
* @pos: the type * to use as a loop cursor.
* @n: another type * to use as temporary storage
* @head: the head for your list.
* Iterate over list of given type from current point, safe against
* removal of list entry.
*/
-#define list_for_each_entry_safe_from(pos, n, head, member) \
- for (n = list_entry(pos->member.next, typeof(*pos), member); \
+#define cds_list_for_each_entry_safe_from(pos, n, head, member) \
+ for (n = cds_list_entry(pos->member.next, typeof(*pos), member); \
&pos->member != (head); \
- pos = n, n = list_entry(n->member.next, typeof(*n), member))
+ pos = n, n = cds_list_entry(n->member.next, typeof(*n), member))
/**
- * list_for_each_entry_safe_reverse
+ * cds_list_for_each_entry_safe_reverse
* @pos: the type * to use as a loop cursor.
* @n: another type * to use as temporary storage
* @head: the head for your list.
* Iterate backwards over list of given type, safe against removal
* of list entry.
*/
-#define list_for_each_entry_safe_reverse(pos, n, head, member) \
- for (pos = list_entry((head)->prev, typeof(*pos), member), \
- n = list_entry(pos->member.prev, typeof(*pos), member); \
+#define cds_list_for_each_entry_safe_reverse(pos, n, head, member) \
+ for (pos = cds_list_entry((head)->prev, typeof(*pos), member), \
+ n = cds_list_entry(pos->member.prev, typeof(*pos), member); \
&pos->member != (head); \
- pos = n, n = list_entry(n->member.prev, typeof(*n), member))
+ pos = n, n = cds_list_entry(n->member.prev, typeof(*n), member))
#endif //0
* You lose the ability to access the tail in O(1).
*/
-struct hlist_head {
- struct hlist_node *first;
+struct cds_hlist_head {
+ struct cds_hlist_node *first;
};
-struct hlist_node {
- struct hlist_node *next, **pprev;
+struct cds_hlist_node {
+ struct cds_hlist_node *next, **pprev;
};
#define HLIST_HEAD_INIT { .first = NULL }
-#define HLIST_HEAD(name) struct hlist_head name = { .first = NULL }
-#define INIT_HLIST_HEAD(ptr) ((ptr)->first = NULL)
-static inline void INIT_HLIST_NODE(struct hlist_node *h)
+#define HLIST_HEAD(name) struct cds_hlist_head name = { .first = NULL }
+#define CDS_INIT_HLIST_HEAD(ptr) ((ptr)->first = NULL)
+static inline void INIT_HLIST_NODE(struct cds_hlist_node *h)
{
h->next = NULL;
h->pprev = NULL;
}
-static inline int hlist_unhashed(const struct hlist_node *h)
+static inline int hlist_unhashed(const struct cds_hlist_node *h)
{
return !h->pprev;
}
-static inline int hlist_empty(const struct hlist_head *h)
+static inline int hlist_empty(const struct cds_hlist_head *h)
{
return !h->first;
}
-static inline void __hlist_del(struct hlist_node *n)
+static inline void __cds_hlist_del(struct cds_hlist_node *n)
{
- struct hlist_node *next = n->next;
- struct hlist_node **pprev = n->pprev;
+ struct cds_hlist_node *next = n->next;
+ struct cds_hlist_node **pprev = n->pprev;
*pprev = next;
if (next)
next->pprev = pprev;
}
-static inline void hlist_del(struct hlist_node *n)
+static inline void cds_hlist_del(struct cds_hlist_node *n)
{
- __hlist_del(n);
+ __cds_hlist_del(n);
n->next = LIST_POISON1;
n->pprev = LIST_POISON2;
}
-static inline void hlist_del_init(struct hlist_node *n)
+static inline void cds_hlist_del_init(struct cds_hlist_node *n)
{
if (!hlist_unhashed(n)) {
- __hlist_del(n);
+ __cds_hlist_del(n);
INIT_HLIST_NODE(n);
}
}
-static inline void hlist_add_head(struct hlist_node *n, struct hlist_head *h)
+static inline void cds_hlist_add_head(struct cds_hlist_node *n, struct cds_hlist_head *h)
{
- struct hlist_node *first = h->first;
+ struct cds_hlist_node *first = h->first;
n->next = first;
if (first)
first->pprev = &n->next;
}
/* next must be != NULL */
-static inline void hlist_add_before(struct hlist_node *n,
- struct hlist_node *next)
+static inline void hlist_add_before(struct cds_hlist_node *n,
+ struct cds_hlist_node *next)
{
n->pprev = next->pprev;
n->next = next;
*(n->pprev) = n;
}
-static inline void hlist_add_after(struct hlist_node *n,
- struct hlist_node *next)
+static inline void hlist_add_after(struct cds_hlist_node *n,
+ struct cds_hlist_node *next)
{
next->next = n->next;
n->next = next;
* Move a list from one list head to another. Fixup the pprev
* reference of the first entry if it exists.
*/
-static inline void hlist_move_list(struct hlist_head *old,
- struct hlist_head *new)
+static inline void hlist_move_list(struct cds_hlist_head *old,
+ struct cds_hlist_head *new)
{
new->first = old->first;
if (new->first)
old->first = NULL;
}
-#define hlist_entry(ptr, type, member) caa_container_of(ptr,type,member)
+#define cds_hlist_entry(ptr, type, member) caa_container_of(ptr,type,member)
-#define hlist_for_each(pos, head) \
+#define cds_hlist_for_each(pos, head) \
for (pos = (head)->first; pos && ({ prefetch(pos->next); 1; }); \
pos = pos->next)
-#define hlist_for_each_safe(pos, n, head) \
+#define cds_hlist_for_each_safe(pos, n, head) \
for (pos = (head)->first; pos && ({ n = pos->next; 1; }); \
pos = n)
/**
- * hlist_for_each_entry - iterate over list of given type
+ * cds_hlist_for_each_entry - iterate over list of given type
* @tpos: the type * to use as a loop cursor.
- * @pos: the &struct hlist_node to use as a loop cursor.
+ * @pos: the &struct cds_hlist_node to use as a loop cursor.
* @head: the head for your list.
- * @member: the name of the hlist_node within the struct.
+ * @member: the name of the cds_hlist_node within the struct.
*/
-#define hlist_for_each_entry(tpos, pos, head, member) \
+#define cds_hlist_for_each_entry(tpos, pos, head, member) \
for (pos = (head)->first; \
pos && ({ prefetch(pos->next); 1;}) && \
- ({ tpos = hlist_entry(pos, typeof(*tpos), member); 1;}); \
+ ({ tpos = cds_hlist_entry(pos, typeof(*tpos), member); 1;}); \
pos = pos->next)
/**
- * hlist_for_each_entry_continue - iterate over a hlist continuing after current point
+ * cds_hlist_for_each_entry_continue - iterate over a hlist continuing after current point
* @tpos: the type * to use as a loop cursor.
- * @pos: the &struct hlist_node to use as a loop cursor.
- * @member: the name of the hlist_node within the struct.
+ * @pos: the &struct cds_hlist_node to use as a loop cursor.
+ * @member: the name of the cds_hlist_node within the struct.
*/
-#define hlist_for_each_entry_continue(tpos, pos, member) \
+#define cds_hlist_for_each_entry_continue(tpos, pos, member) \
for (pos = (pos)->next; \
pos && ({ prefetch(pos->next); 1;}) && \
- ({ tpos = hlist_entry(pos, typeof(*tpos), member); 1;}); \
+ ({ tpos = cds_hlist_entry(pos, typeof(*tpos), member); 1;}); \
pos = pos->next)
/**
- * hlist_for_each_entry_from - iterate over a hlist continuing from current point
+ * cds_hlist_for_each_entry_from - iterate over a hlist continuing from current point
* @tpos: the type * to use as a loop cursor.
- * @pos: the &struct hlist_node to use as a loop cursor.
- * @member: the name of the hlist_node within the struct.
+ * @pos: the &struct cds_hlist_node to use as a loop cursor.
+ * @member: the name of the cds_hlist_node within the struct.
*/
-#define hlist_for_each_entry_from(tpos, pos, member) \
+#define cds_hlist_for_each_entry_from(tpos, pos, member) \
for (; pos && ({ prefetch(pos->next); 1;}) && \
- ({ tpos = hlist_entry(pos, typeof(*tpos), member); 1;}); \
+ ({ tpos = cds_hlist_entry(pos, typeof(*tpos), member); 1;}); \
pos = pos->next)
/**
- * hlist_for_each_entry_safe - iterate over list of given type safe against removal of list entry
+ * cds_hlist_for_each_entry_safe - iterate over list of given type safe against removal of list entry
* @tpos: the type * to use as a loop cursor.
- * @pos: the &struct hlist_node to use as a loop cursor.
- * @n: another &struct hlist_node to use as temporary storage
+ * @pos: the &struct cds_hlist_node to use as a loop cursor.
+ * @n: another &struct cds_hlist_node to use as temporary storage
* @head: the head for your list.
- * @member: the name of the hlist_node within the struct.
+ * @member: the name of the cds_hlist_node within the struct.
*/
-#define hlist_for_each_entry_safe(tpos, pos, n, head, member) \
+#define cds_hlist_for_each_entry_safe(tpos, pos, n, head, member) \
for (pos = (head)->first; \
pos && ({ n = pos->next; 1; }) && \
- ({ tpos = hlist_entry(pos, typeof(*tpos), member); 1;}); \
+ ({ tpos = cds_hlist_entry(pos, typeof(*tpos), member); 1;}); \
pos = n)
#endif
* using the generic single-entry routines.
*/
-struct list_head {
- struct list_head *next, *prev;
+struct cds_list_head {
+ struct cds_list_head *next, *prev;
};
-#define LIST_HEAD_INIT(name) { &(name), &(name) }
+#define CDS_LIST_HEAD_INIT(name) { &(name), &(name) }
-#define LIST_HEAD(name) \
- struct list_head name = LIST_HEAD_INIT(name)
+#define CDS_LIST_HEAD(name) \
+ struct cds_list_head name = CDS_LIST_HEAD_INIT(name)
-static inline void INIT_LIST_HEAD(struct list_head *list)
+static inline void CDS_INIT_LIST_HEAD(struct cds_list_head *list)
{
list->next = list;
list->prev = list;
* the prev/next entries already!
*/
#ifndef CONFIG_DEBUG_LIST
-static inline void __list_add(struct list_head *new,
- struct list_head *prev,
- struct list_head *next)
+static inline void __cds_list_add(struct cds_list_head *new,
+ struct cds_list_head *prev,
+ struct cds_list_head *next)
{
next->prev = new;
new->next = next;
prev->next = new;
}
#else
-extern void __list_add(struct list_head *new,
- struct list_head *prev,
- struct list_head *next);
+extern void __cds_list_add(struct cds_list_head *new,
+ struct cds_list_head *prev,
+ struct cds_list_head *next);
#endif
/**
- * list_add - add a new entry
+ * cds_list_add - add a new entry
* @new: new entry to be added
* @head: list head to add it after
*
* Insert a new entry after the specified head.
* This is good for implementing stacks.
*/
-static inline void list_add(struct list_head *new, struct list_head *head)
+static inline void cds_list_add(struct cds_list_head *new, struct cds_list_head *head)
{
- __list_add(new, head, head->next);
+ __cds_list_add(new, head, head->next);
}
/**
- * list_add_tail - add a new entry
+ * cds_list_add_tail - add a new entry
* @new: new entry to be added
* @head: list head to add it before
*
* Insert a new entry before the specified head.
* This is useful for implementing queues.
*/
-static inline void list_add_tail(struct list_head *new, struct list_head *head)
+static inline void cds_list_add_tail(struct cds_list_head *new, struct cds_list_head *head)
{
- __list_add(new, head->prev, head);
+ __cds_list_add(new, head->prev, head);
}
/*
* This is only for internal list manipulation where we know
* the prev/next entries already!
*/
-static inline void __list_del(struct list_head * prev, struct list_head * next)
+static inline void __cds_list_del(struct cds_list_head * prev, struct cds_list_head * next)
{
next->prev = prev;
prev->next = next;
}
/**
- * list_del - deletes entry from list.
+ * cds_list_del - deletes entry from list.
* @entry: the element to delete from the list.
- * Note: list_empty() on entry does not return true after this, the entry is
+ * Note: cds_list_empty() on entry does not return true after this, the entry is
* in an undefined state.
*/
#ifndef CONFIG_DEBUG_LIST
-static inline void list_del(struct list_head *entry)
+static inline void cds_list_del(struct cds_list_head *entry)
{
- __list_del(entry->prev, entry->next);
+ __cds_list_del(entry->prev, entry->next);
entry->next = LIST_POISON1;
entry->prev = LIST_POISON2;
}
#else
-extern void list_del(struct list_head *entry);
+extern void cds_list_del(struct cds_list_head *entry);
#endif
/**
- * list_replace - replace old entry by new one
+ * cds_list_replace - replace old entry by new one
* @old : the element to be replaced
* @new : the new element to insert
*
* If @old was empty, it will be overwritten.
*/
-static inline void list_replace(struct list_head *old,
- struct list_head *new)
+static inline void cds_list_replace(struct cds_list_head *old,
+ struct cds_list_head *new)
{
new->next = old->next;
new->next->prev = new;
new->prev->next = new;
}
-static inline void list_replace_init(struct list_head *old,
- struct list_head *new)
+static inline void cds_list_replace_init(struct cds_list_head *old,
+ struct cds_list_head *new)
{
- list_replace(old, new);
- INIT_LIST_HEAD(old);
+ cds_list_replace(old, new);
+ CDS_INIT_LIST_HEAD(old);
}
/**
- * list_del_init - deletes entry from list and reinitialize it.
+ * cds_list_del_init - deletes entry from list and reinitialize it.
* @entry: the element to delete from the list.
*/
-static inline void list_del_init(struct list_head *entry)
+static inline void cds_list_del_init(struct cds_list_head *entry)
{
- __list_del(entry->prev, entry->next);
- INIT_LIST_HEAD(entry);
+ __cds_list_del(entry->prev, entry->next);
+ CDS_INIT_LIST_HEAD(entry);
}
/**
- * list_move - delete from one list and add as another's head
+ * cds_list_move - delete from one list and add as another's head
* @list: the entry to move
* @head: the head that will precede our entry
*/
-static inline void list_move(struct list_head *list, struct list_head *head)
+static inline void cds_list_move(struct cds_list_head *list, struct cds_list_head *head)
{
- __list_del(list->prev, list->next);
- list_add(list, head);
+ __cds_list_del(list->prev, list->next);
+ cds_list_add(list, head);
}
/**
- * list_move_tail - delete from one list and add as another's tail
+ * cds_list_move_tail - delete from one list and add as another's tail
* @list: the entry to move
* @head: the head that will follow our entry
*/
-static inline void list_move_tail(struct list_head *list,
- struct list_head *head)
+static inline void cds_list_move_tail(struct cds_list_head *list,
+ struct cds_list_head *head)
{
- __list_del(list->prev, list->next);
- list_add_tail(list, head);
+ __cds_list_del(list->prev, list->next);
+ cds_list_add_tail(list, head);
}
/**
* @list: the entry to test
* @head: the head of the list
*/
-static inline int list_is_last(const struct list_head *list,
- const struct list_head *head)
+static inline int list_is_last(const struct cds_list_head *list,
+ const struct cds_list_head *head)
{
return list->next == head;
}
/**
- * list_empty - tests whether a list is empty
+ * cds_list_empty - tests whether a list is empty
* @head: the list to test.
*/
-static inline int list_empty(const struct list_head *head)
+static inline int cds_list_empty(const struct cds_list_head *head)
{
return head->next == head;
}
/**
- * list_empty_careful - tests whether a list is empty and not being modified
+ * cds_list_empty_careful - tests whether a list is empty and not being modified
* @head: the list to test
*
* Description:
* tests whether a list is empty _and_ checks that no other CPU might be
* in the process of modifying either member (next or prev)
*
- * NOTE: using list_empty_careful() without synchronization
+ * NOTE: using cds_list_empty_careful() without synchronization
* can only be safe if the only activity that can happen
- * to the list entry is list_del_init(). Eg. it cannot be used
+ * to the list entry is cds_list_del_init(). Eg. it cannot be used
* if another CPU could re-list_add() it.
*/
-static inline int list_empty_careful(const struct list_head *head)
+static inline int cds_list_empty_careful(const struct cds_list_head *head)
{
- struct list_head *next = head->next;
+ struct cds_list_head *next = head->next;
return (next == head) && (next == head->prev);
}
* list_is_singular - tests whether a list has just one entry.
* @head: the list to test.
*/
-static inline int list_is_singular(const struct list_head *head)
+static inline int list_is_singular(const struct cds_list_head *head)
{
return !list_empty(head) && (head->next == head->prev);
}
-static inline void __list_cut_position(struct list_head *list,
- struct list_head *head, struct list_head *entry)
+static inline void __list_cut_position(struct cds_list_head *list,
+ struct cds_list_head *head, struct cds_list_head *entry)
{
- struct list_head *new_first = entry->next;
+ struct cds_list_head *new_first = entry->next;
list->next = head->next;
list->next->prev = list;
list->prev = entry;
* losing its data.
*
*/
-static inline void list_cut_position(struct list_head *list,
- struct list_head *head, struct list_head *entry)
+static inline void list_cut_position(struct cds_list_head *list,
+ struct cds_list_head *head, struct cds_list_head *entry)
{
- if (list_empty(head))
+ if (cds_list_empty(head))
return;
if (list_is_singular(head) &&
(head->next != entry && head != entry))
return;
if (entry == head)
- INIT_LIST_HEAD(list);
+ CDS_INIT_LIST_HEAD(list);
else
__list_cut_position(list, head, entry);
}
-static inline void __list_splice(const struct list_head *list,
- struct list_head *prev,
- struct list_head *next)
+static inline void __cds_list_splice(const struct cds_list_head *list,
+ struct cds_list_head *prev,
+ struct cds_list_head *next)
{
- struct list_head *first = list->next;
- struct list_head *last = list->prev;
+ struct cds_list_head *first = list->next;
+ struct cds_list_head *last = list->prev;
first->prev = prev;
prev->next = first;
}
/**
- * list_splice - join two lists, this is designed for stacks
+ * cds_list_splice - join two lists, this is designed for stacks
* @list: the new list to add.
* @head: the place to add it in the first list.
*/
-static inline void list_splice(const struct list_head *list,
- struct list_head *head)
+static inline void cds_list_splice(const struct cds_list_head *list,
+ struct cds_list_head *head)
{
- if (!list_empty(list))
- __list_splice(list, head, head->next);
+ if (!cds_list_empty(list))
+ __cds_list_splice(list, head, head->next);
}
/**
- * list_splice_tail - join two lists, each list being a queue
+ * cds_list_splice_tail - join two lists, each list being a queue
* @list: the new list to add.
* @head: the place to add it in the first list.
*/
-static inline void list_splice_tail(struct list_head *list,
- struct list_head *head)
+static inline void cds_list_splice_tail(struct cds_list_head *list,
+ struct cds_list_head *head)
{
- if (!list_empty(list))
- __list_splice(list, head->prev, head);
+ if (!cds_list_empty(list))
+ __cds_list_splice(list, head->prev, head);
}
/**
- * list_splice_init - join two lists and reinitialise the emptied list.
+ * cds_list_splice_init - join two lists and reinitialise the emptied list.
* @list: the new list to add.
* @head: the place to add it in the first list.
*
* The list at @list is reinitialised
*/
-static inline void list_splice_init(struct list_head *list,
- struct list_head *head)
+static inline void cds_list_splice_init(struct cds_list_head *list,
+ struct cds_list_head *head)
{
- if (!list_empty(list)) {
- __list_splice(list, head, head->next);
- INIT_LIST_HEAD(list);
+ if (!cds_list_empty(list)) {
+ __cds_list_splice(list, head, head->next);
+ CDS_INIT_LIST_HEAD(list);
}
}
/**
- * list_splice_tail_init - join two lists and reinitialise the emptied list
+ * cds_list_splice_tail_init - join two lists and reinitialise the emptied list
* @list: the new list to add.
* @head: the place to add it in the first list.
*
* Each of the lists is a queue.
* The list at @list is reinitialised
*/
-static inline void list_splice_tail_init(struct list_head *list,
- struct list_head *head)
+static inline void cds_list_splice_tail_init(struct cds_list_head *list,
+ struct cds_list_head *head)
{
- if (!list_empty(list)) {
- __list_splice(list, head->prev, head);
- INIT_LIST_HEAD(list);
+ if (!cds_list_empty(list)) {
+ __cds_list_splice(list, head->prev, head);
+ CDS_INIT_LIST_HEAD(list);
}
}
/**
- * list_entry - get the struct for this entry
- * @ptr: the &struct list_head pointer.
+ * cds_list_entry - get the struct for this entry
+ * @ptr: the &struct cds_list_head pointer.
* @type: the type of the struct this is embedded in.
* @member: the name of the list_struct within the struct.
*/
-#define list_entry(ptr, type, member) \
+#define cds_list_entry(ptr, type, member) \
caa_container_of(ptr, type, member)
/**
* Note, that list is expected to be not empty.
*/
#define list_first_entry(ptr, type, member) \
- list_entry((ptr)->next, type, member)
+ cds_list_entry((ptr)->next, type, member)
/**
- * list_for_each - iterate over a list
- * @pos: the &struct list_head to use as a loop cursor.
+ * cds_list_for_each - iterate over a list
+ * @pos: the &struct cds_list_head to use as a loop cursor.
* @head: the head for your list.
*/
-#define list_for_each(pos, head) \
+#define cds_list_for_each(pos, head) \
for (pos = (head)->next; prefetch(pos->next), pos != (head); \
pos = pos->next)
/**
- * __list_for_each - iterate over a list
- * @pos: the &struct list_head to use as a loop cursor.
+ * __cds_list_for_each - iterate over a list
+ * @pos: the &struct cds_list_head to use as a loop cursor.
* @head: the head for your list.
*
- * This variant differs from list_for_each() in that it's the
+ * This variant differs from cds_list_for_each() in that it's the
* simplest possible list iteration code, no prefetching is done.
* Use this for code that knows the list to be very short (empty
* or 1 entry) most of the time.
*/
-#define __list_for_each(pos, head) \
+#define __cds_list_for_each(pos, head) \
for (pos = (head)->next; pos != (head); pos = pos->next)
/**
- * list_for_each_prev - iterate over a list backwards
- * @pos: the &struct list_head to use as a loop cursor.
+ * cds_list_for_each_prev - iterate over a list backwards
+ * @pos: the &struct cds_list_head to use as a loop cursor.
* @head: the head for your list.
*/
-#define list_for_each_prev(pos, head) \
+#define cds_list_for_each_prev(pos, head) \
for (pos = (head)->prev; prefetch(pos->prev), pos != (head); \
pos = pos->prev)
/**
- * list_for_each_safe - iterate over a list safe against removal of list entry
- * @pos: the &struct list_head to use as a loop cursor.
- * @n: another &struct list_head to use as temporary storage
+ * cds_list_for_each_safe - iterate over a list safe against removal of list entry
+ * @pos: the &struct cds_list_head to use as a loop cursor.
+ * @n: another &struct cds_list_head to use as temporary storage
* @head: the head for your list.
*/
-#define list_for_each_safe(pos, n, head) \
+#define cds_list_for_each_safe(pos, n, head) \
for (pos = (head)->next, n = pos->next; pos != (head); \
pos = n, n = pos->next)
/**
- * list_for_each_prev_safe - iterate over a list backwards safe against removal of list entry
- * @pos: the &struct list_head to use as a loop cursor.
- * @n: another &struct list_head to use as temporary storage
+ * cds_list_for_each_prev_safe - iterate over a list backwards safe against removal of list entry
+ * @pos: the &struct cds_list_head to use as a loop cursor.
+ * @n: another &struct cds_list_head to use as temporary storage
* @head: the head for your list.
*/
-#define list_for_each_prev_safe(pos, n, head) \
+#define cds_list_for_each_prev_safe(pos, n, head) \
for (pos = (head)->prev, n = pos->prev; \
prefetch(pos->prev), pos != (head); \
pos = n, n = pos->prev)
/**
- * list_for_each_entry - iterate over list of given type
+ * cds_list_for_each_entry - iterate over list of given type
* @pos: the type * to use as a loop cursor.
* @head: the head for your list.
* @member: the name of the list_struct within the struct.
*/
-#define list_for_each_entry(pos, head, member) \
- for (pos = list_entry((head)->next, typeof(*pos), member); \
+#define cds_list_for_each_entry(pos, head, member) \
+ for (pos = cds_list_entry((head)->next, typeof(*pos), member); \
prefetch(pos->member.next), &pos->member != (head); \
- pos = list_entry(pos->member.next, typeof(*pos), member))
+ pos = cds_list_entry(pos->member.next, typeof(*pos), member))
/**
- * list_for_each_entry_reverse - iterate backwards over list of given type.
+ * cds_list_for_each_entry_reverse - iterate backwards over list of given type.
* @pos: the type * to use as a loop cursor.
* @head: the head for your list.
* @member: the name of the list_struct within the struct.
*/
-#define list_for_each_entry_reverse(pos, head, member) \
- for (pos = list_entry((head)->prev, typeof(*pos), member); \
+#define cds_list_for_each_entry_reverse(pos, head, member) \
+ for (pos = cds_list_entry((head)->prev, typeof(*pos), member); \
prefetch(pos->member.prev), &pos->member != (head); \
- pos = list_entry(pos->member.prev, typeof(*pos), member))
+ pos = cds_list_entry(pos->member.prev, typeof(*pos), member))
/**
- * list_prepare_entry - prepare a pos entry for use in list_for_each_entry_continue()
+ * list_prepare_entry - prepare a pos entry for use in cds_list_for_each_entry_continue()
* @pos: the type * to use as a start point
* @head: the head of the list
* @member: the name of the list_struct within the struct.
*
- * Prepares a pos entry for use as a start point in list_for_each_entry_continue().
+ * Prepares a pos entry for use as a start point in cds_list_for_each_entry_continue().
*/
#define list_prepare_entry(pos, head, member) \
- ((pos) ? : list_entry(head, typeof(*pos), member))
+ ((pos) ? : cds_list_entry(head, typeof(*pos), member))
/**
- * list_for_each_entry_continue - continue iteration over list of given type
+ * cds_list_for_each_entry_continue - continue iteration over list of given type
* @pos: the type * to use as a loop cursor.
* @head: the head for your list.
* @member: the name of the list_struct within the struct.
* Continue to iterate over list of given type, continuing after
* the current position.
*/
-#define list_for_each_entry_continue(pos, head, member) \
- for (pos = list_entry(pos->member.next, typeof(*pos), member); \
+#define cds_list_for_each_entry_continue(pos, head, member) \
+ for (pos = cds_list_entry(pos->member.next, typeof(*pos), member); \
prefetch(pos->member.next), &pos->member != (head); \
- pos = list_entry(pos->member.next, typeof(*pos), member))
+ pos = cds_list_entry(pos->member.next, typeof(*pos), member))
/**
- * list_for_each_entry_continue_reverse - iterate backwards from the given point
+ * cds_list_for_each_entry_continue_reverse - iterate backwards from the given point
* @pos: the type * to use as a loop cursor.
* @head: the head for your list.
* @member: the name of the list_struct within the struct.
* Start to iterate over list of given type backwards, continuing after
* the current position.
*/
-#define list_for_each_entry_continue_reverse(pos, head, member) \
- for (pos = list_entry(pos->member.prev, typeof(*pos), member); \
+#define cds_list_for_each_entry_continue_reverse(pos, head, member) \
+ for (pos = cds_list_entry(pos->member.prev, typeof(*pos), member); \
prefetch(pos->member.prev), &pos->member != (head); \
- pos = list_entry(pos->member.prev, typeof(*pos), member))
+ pos = cds_list_entry(pos->member.prev, typeof(*pos), member))
/**
- * list_for_each_entry_from - iterate over list of given type from the current point
+ * cds_list_for_each_entry_from - iterate over list of given type from the current point
* @pos: the type * to use as a loop cursor.
* @head: the head for your list.
* @member: the name of the list_struct within the struct.
*
* Iterate over list of given type, continuing from current position.
*/
-#define list_for_each_entry_from(pos, head, member) \
+#define cds_list_for_each_entry_from(pos, head, member) \
for (; prefetch(pos->member.next), &pos->member != (head); \
- pos = list_entry(pos->member.next, typeof(*pos), member))
+ pos = cds_list_entry(pos->member.next, typeof(*pos), member))
/**
- * list_for_each_entry_safe - iterate over list of given type safe against removal of list entry
+ * cds_list_for_each_entry_safe - iterate over list of given type safe against removal of list entry
* @pos: the type * to use as a loop cursor.
* @n: another type * to use as temporary storage
* @head: the head for your list.
* @member: the name of the list_struct within the struct.
*/
-#define list_for_each_entry_safe(pos, n, head, member) \
- for (pos = list_entry((head)->next, typeof(*pos), member), \
- n = list_entry(pos->member.next, typeof(*pos), member); \
+#define cds_list_for_each_entry_safe(pos, n, head, member) \
+ for (pos = cds_list_entry((head)->next, typeof(*pos), member), \
+ n = cds_list_entry(pos->member.next, typeof(*pos), member); \
&pos->member != (head); \
- pos = n, n = list_entry(n->member.next, typeof(*n), member))
+ pos = n, n = cds_list_entry(n->member.next, typeof(*n), member))
/**
- * list_for_each_entry_safe_continue
+ * cds_list_for_each_entry_safe_continue
* @pos: the type * to use as a loop cursor.
* @n: another type * to use as temporary storage
* @head: the head for your list.
* Iterate over list of given type, continuing after current point,
* safe against removal of list entry.
*/
-#define list_for_each_entry_safe_continue(pos, n, head, member) \
- for (pos = list_entry(pos->member.next, typeof(*pos), member), \
- n = list_entry(pos->member.next, typeof(*pos), member); \
+#define cds_list_for_each_entry_safe_continue(pos, n, head, member) \
+ for (pos = cds_list_entry(pos->member.next, typeof(*pos), member), \
+ n = cds_list_entry(pos->member.next, typeof(*pos), member); \
&pos->member != (head); \
- pos = n, n = list_entry(n->member.next, typeof(*n), member))
+ pos = n, n = cds_list_entry(n->member.next, typeof(*n), member))
/**
- * list_for_each_entry_safe_from
+ * cds_list_for_each_entry_safe_from
* @pos: the type * to use as a loop cursor.
* @n: another type * to use as temporary storage
* @head: the head for your list.
* Iterate over list of given type from current point, safe against
* removal of list entry.
*/
-#define list_for_each_entry_safe_from(pos, n, head, member) \
- for (n = list_entry(pos->member.next, typeof(*pos), member); \
+#define cds_list_for_each_entry_safe_from(pos, n, head, member) \
+ for (n = cds_list_entry(pos->member.next, typeof(*pos), member); \
&pos->member != (head); \
- pos = n, n = list_entry(n->member.next, typeof(*n), member))
+ pos = n, n = cds_list_entry(n->member.next, typeof(*n), member))
/**
- * list_for_each_entry_safe_reverse
+ * cds_list_for_each_entry_safe_reverse
* @pos: the type * to use as a loop cursor.
* @n: another type * to use as temporary storage
* @head: the head for your list.
* Iterate backwards over list of given type, safe against removal
* of list entry.
*/
-#define list_for_each_entry_safe_reverse(pos, n, head, member) \
- for (pos = list_entry((head)->prev, typeof(*pos), member), \
- n = list_entry(pos->member.prev, typeof(*pos), member); \
+#define cds_list_for_each_entry_safe_reverse(pos, n, head, member) \
+ for (pos = cds_list_entry((head)->prev, typeof(*pos), member), \
+ n = cds_list_entry(pos->member.prev, typeof(*pos), member); \
&pos->member != (head); \
- pos = n, n = list_entry(n->member.prev, typeof(*n), member))
+ pos = n, n = cds_list_entry(n->member.prev, typeof(*n), member))
#endif //0
* You lose the ability to access the tail in O(1).
*/
-struct hlist_head {
- struct hlist_node *first;
+struct cds_hlist_head {
+ struct cds_hlist_node *first;
};
-struct hlist_node {
- struct hlist_node *next, **pprev;
+struct cds_hlist_node {
+ struct cds_hlist_node *next, **pprev;
};
#define HLIST_HEAD_INIT { .first = NULL }
-#define HLIST_HEAD(name) struct hlist_head name = { .first = NULL }
-#define INIT_HLIST_HEAD(ptr) ((ptr)->first = NULL)
-static inline void INIT_HLIST_NODE(struct hlist_node *h)
+#define HLIST_HEAD(name) struct cds_hlist_head name = { .first = NULL }
+#define CDS_INIT_HLIST_HEAD(ptr) ((ptr)->first = NULL)
+static inline void INIT_HLIST_NODE(struct cds_hlist_node *h)
{
h->next = NULL;
h->pprev = NULL;
}
-static inline int hlist_unhashed(const struct hlist_node *h)
+static inline int hlist_unhashed(const struct cds_hlist_node *h)
{
return !h->pprev;
}
-static inline int hlist_empty(const struct hlist_head *h)
+static inline int hlist_empty(const struct cds_hlist_head *h)
{
return !h->first;
}
-static inline void __hlist_del(struct hlist_node *n)
+static inline void __cds_hlist_del(struct cds_hlist_node *n)
{
- struct hlist_node *next = n->next;
- struct hlist_node **pprev = n->pprev;
+ struct cds_hlist_node *next = n->next;
+ struct cds_hlist_node **pprev = n->pprev;
*pprev = next;
if (next)
next->pprev = pprev;
}
-static inline void hlist_del(struct hlist_node *n)
+static inline void cds_hlist_del(struct cds_hlist_node *n)
{
- __hlist_del(n);
+ __cds_hlist_del(n);
n->next = LIST_POISON1;
n->pprev = LIST_POISON2;
}
-static inline void hlist_del_init(struct hlist_node *n)
+static inline void cds_hlist_del_init(struct cds_hlist_node *n)
{
if (!hlist_unhashed(n)) {
- __hlist_del(n);
+ __cds_hlist_del(n);
INIT_HLIST_NODE(n);
}
}
-static inline void hlist_add_head(struct hlist_node *n, struct hlist_head *h)
+static inline void cds_hlist_add_head(struct cds_hlist_node *n, struct cds_hlist_head *h)
{
- struct hlist_node *first = h->first;
+ struct cds_hlist_node *first = h->first;
n->next = first;
if (first)
first->pprev = &n->next;
}
/* next must be != NULL */
-static inline void hlist_add_before(struct hlist_node *n,
- struct hlist_node *next)
+static inline void hlist_add_before(struct cds_hlist_node *n,
+ struct cds_hlist_node *next)
{
n->pprev = next->pprev;
n->next = next;
*(n->pprev) = n;
}
-static inline void hlist_add_after(struct hlist_node *n,
- struct hlist_node *next)
+static inline void hlist_add_after(struct cds_hlist_node *n,
+ struct cds_hlist_node *next)
{
next->next = n->next;
n->next = next;
* Move a list from one list head to another. Fixup the pprev
* reference of the first entry if it exists.
*/
-static inline void hlist_move_list(struct hlist_head *old,
- struct hlist_head *new)
+static inline void hlist_move_list(struct cds_hlist_head *old,
+ struct cds_hlist_head *new)
{
new->first = old->first;
if (new->first)
old->first = NULL;
}
-#define hlist_entry(ptr, type, member) caa_container_of(ptr,type,member)
+#define cds_hlist_entry(ptr, type, member) caa_container_of(ptr,type,member)
-#define hlist_for_each(pos, head) \
+#define cds_hlist_for_each(pos, head) \
for (pos = (head)->first; pos && ({ prefetch(pos->next); 1; }); \
pos = pos->next)
-#define hlist_for_each_safe(pos, n, head) \
+#define cds_hlist_for_each_safe(pos, n, head) \
for (pos = (head)->first; pos && ({ n = pos->next; 1; }); \
pos = n)
/**
- * hlist_for_each_entry - iterate over list of given type
+ * cds_hlist_for_each_entry - iterate over list of given type
* @tpos: the type * to use as a loop cursor.
- * @pos: the &struct hlist_node to use as a loop cursor.
+ * @pos: the &struct cds_hlist_node to use as a loop cursor.
* @head: the head for your list.
- * @member: the name of the hlist_node within the struct.
+ * @member: the name of the cds_hlist_node within the struct.
*/
-#define hlist_for_each_entry(tpos, pos, head, member) \
+#define cds_hlist_for_each_entry(tpos, pos, head, member) \
for (pos = (head)->first; \
pos && ({ prefetch(pos->next); 1;}) && \
- ({ tpos = hlist_entry(pos, typeof(*tpos), member); 1;}); \
+ ({ tpos = cds_hlist_entry(pos, typeof(*tpos), member); 1;}); \
pos = pos->next)
/**
- * hlist_for_each_entry_continue - iterate over a hlist continuing after current point
+ * cds_hlist_for_each_entry_continue - iterate over a hlist continuing after current point
* @tpos: the type * to use as a loop cursor.
- * @pos: the &struct hlist_node to use as a loop cursor.
- * @member: the name of the hlist_node within the struct.
+ * @pos: the &struct cds_hlist_node to use as a loop cursor.
+ * @member: the name of the cds_hlist_node within the struct.
*/
-#define hlist_for_each_entry_continue(tpos, pos, member) \
+#define cds_hlist_for_each_entry_continue(tpos, pos, member) \
for (pos = (pos)->next; \
pos && ({ prefetch(pos->next); 1;}) && \
- ({ tpos = hlist_entry(pos, typeof(*tpos), member); 1;}); \
+ ({ tpos = cds_hlist_entry(pos, typeof(*tpos), member); 1;}); \
pos = pos->next)
/**
- * hlist_for_each_entry_from - iterate over a hlist continuing from current point
+ * cds_hlist_for_each_entry_from - iterate over a hlist continuing from current point
* @tpos: the type * to use as a loop cursor.
- * @pos: the &struct hlist_node to use as a loop cursor.
- * @member: the name of the hlist_node within the struct.
+ * @pos: the &struct cds_hlist_node to use as a loop cursor.
+ * @member: the name of the cds_hlist_node within the struct.
*/
-#define hlist_for_each_entry_from(tpos, pos, member) \
+#define cds_hlist_for_each_entry_from(tpos, pos, member) \
for (; pos && ({ prefetch(pos->next); 1;}) && \
- ({ tpos = hlist_entry(pos, typeof(*tpos), member); 1;}); \
+ ({ tpos = cds_hlist_entry(pos, typeof(*tpos), member); 1;}); \
pos = pos->next)
/**
- * hlist_for_each_entry_safe - iterate over list of given type safe against removal of list entry
+ * cds_hlist_for_each_entry_safe - iterate over list of given type safe against removal of list entry
* @tpos: the type * to use as a loop cursor.
- * @pos: the &struct hlist_node to use as a loop cursor.
- * @n: another &struct hlist_node to use as temporary storage
+ * @pos: the &struct cds_hlist_node to use as a loop cursor.
+ * @n: another &struct cds_hlist_node to use as temporary storage
* @head: the head for your list.
- * @member: the name of the hlist_node within the struct.
+ * @member: the name of the cds_hlist_node within the struct.
*/
-#define hlist_for_each_entry_safe(tpos, pos, n, head, member) \
+#define cds_hlist_for_each_entry_safe(tpos, pos, n, head, member) \
for (pos = (head)->first; \
pos && ({ n = pos->next; 1; }) && \
- ({ tpos = hlist_entry(pos, typeof(*tpos), member); 1;}); \
+ ({ tpos = cds_hlist_entry(pos, typeof(*tpos), member); 1;}); \
pos = n)
#endif
* using the generic single-entry routines.
*/
-struct list_head {
- struct list_head *next, *prev;
+struct cds_list_head {
+ struct cds_list_head *next, *prev;
};
-#define LIST_HEAD_INIT(name) { &(name), &(name) }
+#define CDS_LIST_HEAD_INIT(name) { &(name), &(name) }
-#define LIST_HEAD(name) \
- struct list_head name = LIST_HEAD_INIT(name)
+#define CDS_LIST_HEAD(name) \
+ struct cds_list_head name = CDS_LIST_HEAD_INIT(name)
-static inline void INIT_LIST_HEAD(struct list_head *list)
+static inline void CDS_INIT_LIST_HEAD(struct cds_list_head *list)
{
list->next = list;
list->prev = list;
* the prev/next entries already!
*/
#ifndef CONFIG_DEBUG_LIST
-static inline void __list_add(struct list_head *new,
- struct list_head *prev,
- struct list_head *next)
+static inline void __cds_list_add(struct cds_list_head *new,
+ struct cds_list_head *prev,
+ struct cds_list_head *next)
{
next->prev = new;
new->next = next;
prev->next = new;
}
#else
-extern void __list_add(struct list_head *new,
- struct list_head *prev,
- struct list_head *next);
+extern void __cds_list_add(struct cds_list_head *new,
+ struct cds_list_head *prev,
+ struct cds_list_head *next);
#endif
/**
- * list_add - add a new entry
+ * cds_list_add - add a new entry
* @new: new entry to be added
* @head: list head to add it after
*
* Insert a new entry after the specified head.
* This is good for implementing stacks.
*/
-static inline void list_add(struct list_head *new, struct list_head *head)
+static inline void cds_list_add(struct cds_list_head *new, struct cds_list_head *head)
{
- __list_add(new, head, head->next);
+ __cds_list_add(new, head, head->next);
}
/**
- * list_add_tail - add a new entry
+ * cds_list_add_tail - add a new entry
* @new: new entry to be added
* @head: list head to add it before
*
* Insert a new entry before the specified head.
* This is useful for implementing queues.
*/
-static inline void list_add_tail(struct list_head *new, struct list_head *head)
+static inline void cds_list_add_tail(struct cds_list_head *new, struct cds_list_head *head)
{
- __list_add(new, head->prev, head);
+ __cds_list_add(new, head->prev, head);
}
/*
* This is only for internal list manipulation where we know
* the prev/next entries already!
*/
-static inline void __list_del(struct list_head * prev, struct list_head * next)
+static inline void __cds_list_del(struct cds_list_head * prev, struct cds_list_head * next)
{
next->prev = prev;
prev->next = next;
}
/**
- * list_del - deletes entry from list.
+ * cds_list_del - deletes entry from list.
* @entry: the element to delete from the list.
- * Note: list_empty() on entry does not return true after this, the entry is
+ * Note: cds_list_empty() on entry does not return true after this, the entry is
* in an undefined state.
*/
#ifndef CONFIG_DEBUG_LIST
-static inline void list_del(struct list_head *entry)
+static inline void cds_list_del(struct cds_list_head *entry)
{
- __list_del(entry->prev, entry->next);
+ __cds_list_del(entry->prev, entry->next);
entry->next = LIST_POISON1;
entry->prev = LIST_POISON2;
}
#else
-extern void list_del(struct list_head *entry);
+extern void cds_list_del(struct cds_list_head *entry);
#endif
/**
- * list_replace - replace old entry by new one
+ * cds_list_replace - replace old entry by new one
* @old : the element to be replaced
* @new : the new element to insert
*
* If @old was empty, it will be overwritten.
*/
-static inline void list_replace(struct list_head *old,
- struct list_head *new)
+static inline void cds_list_replace(struct cds_list_head *old,
+ struct cds_list_head *new)
{
new->next = old->next;
new->next->prev = new;
new->prev->next = new;
}
-static inline void list_replace_init(struct list_head *old,
- struct list_head *new)
+static inline void cds_list_replace_init(struct cds_list_head *old,
+ struct cds_list_head *new)
{
- list_replace(old, new);
- INIT_LIST_HEAD(old);
+ cds_list_replace(old, new);
+ CDS_INIT_LIST_HEAD(old);
}
/**
- * list_del_init - deletes entry from list and reinitialize it.
+ * cds_list_del_init - deletes entry from list and reinitialize it.
* @entry: the element to delete from the list.
*/
-static inline void list_del_init(struct list_head *entry)
+static inline void cds_list_del_init(struct cds_list_head *entry)
{
- __list_del(entry->prev, entry->next);
- INIT_LIST_HEAD(entry);
+ __cds_list_del(entry->prev, entry->next);
+ CDS_INIT_LIST_HEAD(entry);
}
/**
- * list_move - delete from one list and add as another's head
+ * cds_list_move - delete from one list and add as another's head
* @list: the entry to move
* @head: the head that will precede our entry
*/
-static inline void list_move(struct list_head *list, struct list_head *head)
+static inline void cds_list_move(struct cds_list_head *list, struct cds_list_head *head)
{
- __list_del(list->prev, list->next);
- list_add(list, head);
+ __cds_list_del(list->prev, list->next);
+ cds_list_add(list, head);
}
/**
- * list_move_tail - delete from one list and add as another's tail
+ * cds_list_move_tail - delete from one list and add as another's tail
* @list: the entry to move
* @head: the head that will follow our entry
*/
-static inline void list_move_tail(struct list_head *list,
- struct list_head *head)
+static inline void cds_list_move_tail(struct cds_list_head *list,
+ struct cds_list_head *head)
{
- __list_del(list->prev, list->next);
- list_add_tail(list, head);
+ __cds_list_del(list->prev, list->next);
+ cds_list_add_tail(list, head);
}
/**
* @list: the entry to test
* @head: the head of the list
*/
-static inline int list_is_last(const struct list_head *list,
- const struct list_head *head)
+static inline int list_is_last(const struct cds_list_head *list,
+ const struct cds_list_head *head)
{
return list->next == head;
}
/**
- * list_empty - tests whether a list is empty
+ * cds_list_empty - tests whether a list is empty
* @head: the list to test.
*/
-static inline int list_empty(const struct list_head *head)
+static inline int cds_list_empty(const struct cds_list_head *head)
{
return head->next == head;
}
/**
- * list_empty_careful - tests whether a list is empty and not being modified
+ * cds_list_empty_careful - tests whether a list is empty and not being modified
* @head: the list to test
*
* Description:
* tests whether a list is empty _and_ checks that no other CPU might be
* in the process of modifying either member (next or prev)
*
- * NOTE: using list_empty_careful() without synchronization
+ * NOTE: using cds_list_empty_careful() without synchronization
* can only be safe if the only activity that can happen
- * to the list entry is list_del_init(). Eg. it cannot be used
+ * to the list entry is cds_list_del_init(). Eg. it cannot be used
* if another CPU could re-list_add() it.
*/
-static inline int list_empty_careful(const struct list_head *head)
+static inline int cds_list_empty_careful(const struct cds_list_head *head)
{
- struct list_head *next = head->next;
+ struct cds_list_head *next = head->next;
return (next == head) && (next == head->prev);
}
* list_is_singular - tests whether a list has just one entry.
* @head: the list to test.
*/
-static inline int list_is_singular(const struct list_head *head)
+static inline int list_is_singular(const struct cds_list_head *head)
{
return !list_empty(head) && (head->next == head->prev);
}
-static inline void __list_cut_position(struct list_head *list,
- struct list_head *head, struct list_head *entry)
+static inline void __list_cut_position(struct cds_list_head *list,
+ struct cds_list_head *head, struct cds_list_head *entry)
{
- struct list_head *new_first = entry->next;
+ struct cds_list_head *new_first = entry->next;
list->next = head->next;
list->next->prev = list;
list->prev = entry;
* losing its data.
*
*/
-static inline void list_cut_position(struct list_head *list,
- struct list_head *head, struct list_head *entry)
+static inline void list_cut_position(struct cds_list_head *list,
+ struct cds_list_head *head, struct cds_list_head *entry)
{
- if (list_empty(head))
+ if (cds_list_empty(head))
return;
if (list_is_singular(head) &&
(head->next != entry && head != entry))
return;
if (entry == head)
- INIT_LIST_HEAD(list);
+ CDS_INIT_LIST_HEAD(list);
else
__list_cut_position(list, head, entry);
}
-static inline void __list_splice(const struct list_head *list,
- struct list_head *prev,
- struct list_head *next)
+static inline void __cds_list_splice(const struct cds_list_head *list,
+ struct cds_list_head *prev,
+ struct cds_list_head *next)
{
- struct list_head *first = list->next;
- struct list_head *last = list->prev;
+ struct cds_list_head *first = list->next;
+ struct cds_list_head *last = list->prev;
first->prev = prev;
prev->next = first;
}
/**
- * list_splice - join two lists, this is designed for stacks
+ * cds_list_splice - join two lists, this is designed for stacks
* @list: the new list to add.
* @head: the place to add it in the first list.
*/
-static inline void list_splice(const struct list_head *list,
- struct list_head *head)
+static inline void cds_list_splice(const struct cds_list_head *list,
+ struct cds_list_head *head)
{
- if (!list_empty(list))
- __list_splice(list, head, head->next);
+ if (!cds_list_empty(list))
+ __cds_list_splice(list, head, head->next);
}
/**
- * list_splice_tail - join two lists, each list being a queue
+ * cds_list_splice_tail - join two lists, each list being a queue
* @list: the new list to add.
* @head: the place to add it in the first list.
*/
-static inline void list_splice_tail(struct list_head *list,
- struct list_head *head)
+static inline void cds_list_splice_tail(struct cds_list_head *list,
+ struct cds_list_head *head)
{
- if (!list_empty(list))
- __list_splice(list, head->prev, head);
+ if (!cds_list_empty(list))
+ __cds_list_splice(list, head->prev, head);
}
/**
- * list_splice_init - join two lists and reinitialise the emptied list.
+ * cds_list_splice_init - join two lists and reinitialise the emptied list.
* @list: the new list to add.
* @head: the place to add it in the first list.
*
* The list at @list is reinitialised
*/
-static inline void list_splice_init(struct list_head *list,
- struct list_head *head)
+static inline void cds_list_splice_init(struct cds_list_head *list,
+ struct cds_list_head *head)
{
- if (!list_empty(list)) {
- __list_splice(list, head, head->next);
- INIT_LIST_HEAD(list);
+ if (!cds_list_empty(list)) {
+ __cds_list_splice(list, head, head->next);
+ CDS_INIT_LIST_HEAD(list);
}
}
/**
- * list_splice_tail_init - join two lists and reinitialise the emptied list
+ * cds_list_splice_tail_init - join two lists and reinitialise the emptied list
* @list: the new list to add.
* @head: the place to add it in the first list.
*
* Each of the lists is a queue.
* The list at @list is reinitialised
*/
-static inline void list_splice_tail_init(struct list_head *list,
- struct list_head *head)
+static inline void cds_list_splice_tail_init(struct cds_list_head *list,
+ struct cds_list_head *head)
{
- if (!list_empty(list)) {
- __list_splice(list, head->prev, head);
- INIT_LIST_HEAD(list);
+ if (!cds_list_empty(list)) {
+ __cds_list_splice(list, head->prev, head);
+ CDS_INIT_LIST_HEAD(list);
}
}
/**
- * list_entry - get the struct for this entry
- * @ptr: the &struct list_head pointer.
+ * cds_list_entry - get the struct for this entry
+ * @ptr: the &struct cds_list_head pointer.
* @type: the type of the struct this is embedded in.
* @member: the name of the list_struct within the struct.
*/
-#define list_entry(ptr, type, member) \
+#define cds_list_entry(ptr, type, member) \
caa_container_of(ptr, type, member)
/**
* Note, that list is expected to be not empty.
*/
#define list_first_entry(ptr, type, member) \
- list_entry((ptr)->next, type, member)
+ cds_list_entry((ptr)->next, type, member)
/**
- * list_for_each - iterate over a list
- * @pos: the &struct list_head to use as a loop cursor.
+ * cds_list_for_each - iterate over a list
+ * @pos: the &struct cds_list_head to use as a loop cursor.
* @head: the head for your list.
*/
-#define list_for_each(pos, head) \
+#define cds_list_for_each(pos, head) \
for (pos = (head)->next; prefetch(pos->next), pos != (head); \
pos = pos->next)
/**
- * __list_for_each - iterate over a list
- * @pos: the &struct list_head to use as a loop cursor.
+ * __cds_list_for_each - iterate over a list
+ * @pos: the &struct cds_list_head to use as a loop cursor.
* @head: the head for your list.
*
- * This variant differs from list_for_each() in that it's the
+ * This variant differs from cds_list_for_each() in that it's the
* simplest possible list iteration code, no prefetching is done.
* Use this for code that knows the list to be very short (empty
* or 1 entry) most of the time.
*/
-#define __list_for_each(pos, head) \
+#define __cds_list_for_each(pos, head) \
for (pos = (head)->next; pos != (head); pos = pos->next)
/**
- * list_for_each_prev - iterate over a list backwards
- * @pos: the &struct list_head to use as a loop cursor.
+ * cds_list_for_each_prev - iterate over a list backwards
+ * @pos: the &struct cds_list_head to use as a loop cursor.
* @head: the head for your list.
*/
-#define list_for_each_prev(pos, head) \
+#define cds_list_for_each_prev(pos, head) \
for (pos = (head)->prev; prefetch(pos->prev), pos != (head); \
pos = pos->prev)
/**
- * list_for_each_safe - iterate over a list safe against removal of list entry
- * @pos: the &struct list_head to use as a loop cursor.
- * @n: another &struct list_head to use as temporary storage
+ * cds_list_for_each_safe - iterate over a list safe against removal of list entry
+ * @pos: the &struct cds_list_head to use as a loop cursor.
+ * @n: another &struct cds_list_head to use as temporary storage
* @head: the head for your list.
*/
-#define list_for_each_safe(pos, n, head) \
+#define cds_list_for_each_safe(pos, n, head) \
for (pos = (head)->next, n = pos->next; pos != (head); \
pos = n, n = pos->next)
/**
- * list_for_each_prev_safe - iterate over a list backwards safe against removal of list entry
- * @pos: the &struct list_head to use as a loop cursor.
- * @n: another &struct list_head to use as temporary storage
+ * cds_list_for_each_prev_safe - iterate over a list backwards safe against removal of list entry
+ * @pos: the &struct cds_list_head to use as a loop cursor.
+ * @n: another &struct cds_list_head to use as temporary storage
* @head: the head for your list.
*/
-#define list_for_each_prev_safe(pos, n, head) \
+#define cds_list_for_each_prev_safe(pos, n, head) \
for (pos = (head)->prev, n = pos->prev; \
prefetch(pos->prev), pos != (head); \
pos = n, n = pos->prev)
/**
- * list_for_each_entry - iterate over list of given type
+ * cds_list_for_each_entry - iterate over list of given type
* @pos: the type * to use as a loop cursor.
* @head: the head for your list.
* @member: the name of the list_struct within the struct.
*/
-#define list_for_each_entry(pos, head, member) \
- for (pos = list_entry((head)->next, typeof(*pos), member); \
+#define cds_list_for_each_entry(pos, head, member) \
+ for (pos = cds_list_entry((head)->next, typeof(*pos), member); \
prefetch(pos->member.next), &pos->member != (head); \
- pos = list_entry(pos->member.next, typeof(*pos), member))
+ pos = cds_list_entry(pos->member.next, typeof(*pos), member))
/**
- * list_for_each_entry_reverse - iterate backwards over list of given type.
+ * cds_list_for_each_entry_reverse - iterate backwards over list of given type.
* @pos: the type * to use as a loop cursor.
* @head: the head for your list.
* @member: the name of the list_struct within the struct.
*/
-#define list_for_each_entry_reverse(pos, head, member) \
- for (pos = list_entry((head)->prev, typeof(*pos), member); \
+#define cds_list_for_each_entry_reverse(pos, head, member) \
+ for (pos = cds_list_entry((head)->prev, typeof(*pos), member); \
prefetch(pos->member.prev), &pos->member != (head); \
- pos = list_entry(pos->member.prev, typeof(*pos), member))
+ pos = cds_list_entry(pos->member.prev, typeof(*pos), member))
/**
- * list_prepare_entry - prepare a pos entry for use in list_for_each_entry_continue()
+ * list_prepare_entry - prepare a pos entry for use in cds_list_for_each_entry_continue()
* @pos: the type * to use as a start point
* @head: the head of the list
* @member: the name of the list_struct within the struct.
*
- * Prepares a pos entry for use as a start point in list_for_each_entry_continue().
+ * Prepares a pos entry for use as a start point in cds_list_for_each_entry_continue().
*/
#define list_prepare_entry(pos, head, member) \
- ((pos) ? : list_entry(head, typeof(*pos), member))
+ ((pos) ? : cds_list_entry(head, typeof(*pos), member))
/**
- * list_for_each_entry_continue - continue iteration over list of given type
+ * cds_list_for_each_entry_continue - continue iteration over list of given type
* @pos: the type * to use as a loop cursor.
* @head: the head for your list.
* @member: the name of the list_struct within the struct.
* Continue to iterate over list of given type, continuing after
* the current position.
*/
-#define list_for_each_entry_continue(pos, head, member) \
- for (pos = list_entry(pos->member.next, typeof(*pos), member); \
+#define cds_list_for_each_entry_continue(pos, head, member) \
+ for (pos = cds_list_entry(pos->member.next, typeof(*pos), member); \
prefetch(pos->member.next), &pos->member != (head); \
- pos = list_entry(pos->member.next, typeof(*pos), member))
+ pos = cds_list_entry(pos->member.next, typeof(*pos), member))
/**
- * list_for_each_entry_continue_reverse - iterate backwards from the given point
+ * cds_list_for_each_entry_continue_reverse - iterate backwards from the given point
* @pos: the type * to use as a loop cursor.
* @head: the head for your list.
* @member: the name of the list_struct within the struct.
* Start to iterate over list of given type backwards, continuing after
* the current position.
*/
-#define list_for_each_entry_continue_reverse(pos, head, member) \
- for (pos = list_entry(pos->member.prev, typeof(*pos), member); \
+#define cds_list_for_each_entry_continue_reverse(pos, head, member) \
+ for (pos = cds_list_entry(pos->member.prev, typeof(*pos), member); \
prefetch(pos->member.prev), &pos->member != (head); \
- pos = list_entry(pos->member.prev, typeof(*pos), member))
+ pos = cds_list_entry(pos->member.prev, typeof(*pos), member))
/**
- * list_for_each_entry_from - iterate over list of given type from the current point
+ * cds_list_for_each_entry_from - iterate over list of given type from the current point
* @pos: the type * to use as a loop cursor.
* @head: the head for your list.
* @member: the name of the list_struct within the struct.
*
* Iterate over list of given type, continuing from current position.
*/
-#define list_for_each_entry_from(pos, head, member) \
+#define cds_list_for_each_entry_from(pos, head, member) \
for (; prefetch(pos->member.next), &pos->member != (head); \
- pos = list_entry(pos->member.next, typeof(*pos), member))
+ pos = cds_list_entry(pos->member.next, typeof(*pos), member))
/**
- * list_for_each_entry_safe - iterate over list of given type safe against removal of list entry
+ * cds_list_for_each_entry_safe - iterate over list of given type safe against removal of list entry
* @pos: the type * to use as a loop cursor.
* @n: another type * to use as temporary storage
* @head: the head for your list.
* @member: the name of the list_struct within the struct.
*/
-#define list_for_each_entry_safe(pos, n, head, member) \
- for (pos = list_entry((head)->next, typeof(*pos), member), \
- n = list_entry(pos->member.next, typeof(*pos), member); \
+#define cds_list_for_each_entry_safe(pos, n, head, member) \
+ for (pos = cds_list_entry((head)->next, typeof(*pos), member), \
+ n = cds_list_entry(pos->member.next, typeof(*pos), member); \
&pos->member != (head); \
- pos = n, n = list_entry(n->member.next, typeof(*n), member))
+ pos = n, n = cds_list_entry(n->member.next, typeof(*n), member))
/**
- * list_for_each_entry_safe_continue
+ * cds_list_for_each_entry_safe_continue
* @pos: the type * to use as a loop cursor.
* @n: another type * to use as temporary storage
* @head: the head for your list.
* Iterate over list of given type, continuing after current point,
* safe against removal of list entry.
*/
-#define list_for_each_entry_safe_continue(pos, n, head, member) \
- for (pos = list_entry(pos->member.next, typeof(*pos), member), \
- n = list_entry(pos->member.next, typeof(*pos), member); \
+#define cds_list_for_each_entry_safe_continue(pos, n, head, member) \
+ for (pos = cds_list_entry(pos->member.next, typeof(*pos), member), \
+ n = cds_list_entry(pos->member.next, typeof(*pos), member); \
&pos->member != (head); \
- pos = n, n = list_entry(n->member.next, typeof(*n), member))
+ pos = n, n = cds_list_entry(n->member.next, typeof(*n), member))
/**
- * list_for_each_entry_safe_from
+ * cds_list_for_each_entry_safe_from
* @pos: the type * to use as a loop cursor.
* @n: another type * to use as temporary storage
* @head: the head for your list.
* Iterate over list of given type from current point, safe against
* removal of list entry.
*/
-#define list_for_each_entry_safe_from(pos, n, head, member) \
- for (n = list_entry(pos->member.next, typeof(*pos), member); \
+#define cds_list_for_each_entry_safe_from(pos, n, head, member) \
+ for (n = cds_list_entry(pos->member.next, typeof(*pos), member); \
&pos->member != (head); \
- pos = n, n = list_entry(n->member.next, typeof(*n), member))
+ pos = n, n = cds_list_entry(n->member.next, typeof(*n), member))
/**
- * list_for_each_entry_safe_reverse
+ * cds_list_for_each_entry_safe_reverse
* @pos: the type * to use as a loop cursor.
* @n: another type * to use as temporary storage
* @head: the head for your list.
* Iterate backwards over list of given type, safe against removal
* of list entry.
*/
-#define list_for_each_entry_safe_reverse(pos, n, head, member) \
- for (pos = list_entry((head)->prev, typeof(*pos), member), \
- n = list_entry(pos->member.prev, typeof(*pos), member); \
+#define cds_list_for_each_entry_safe_reverse(pos, n, head, member) \
+ for (pos = cds_list_entry((head)->prev, typeof(*pos), member), \
+ n = cds_list_entry(pos->member.prev, typeof(*pos), member); \
&pos->member != (head); \
- pos = n, n = list_entry(n->member.prev, typeof(*n), member))
+ pos = n, n = cds_list_entry(n->member.prev, typeof(*n), member))
#endif //0
* You lose the ability to access the tail in O(1).
*/
-struct hlist_head {
- struct hlist_node *first;
+struct cds_hlist_head {
+ struct cds_hlist_node *first;
};
-struct hlist_node {
- struct hlist_node *next, **pprev;
+struct cds_hlist_node {
+ struct cds_hlist_node *next, **pprev;
};
#define HLIST_HEAD_INIT { .first = NULL }
-#define HLIST_HEAD(name) struct hlist_head name = { .first = NULL }
-#define INIT_HLIST_HEAD(ptr) ((ptr)->first = NULL)
-static inline void INIT_HLIST_NODE(struct hlist_node *h)
+#define HLIST_HEAD(name) struct cds_hlist_head name = { .first = NULL }
+#define CDS_INIT_HLIST_HEAD(ptr) ((ptr)->first = NULL)
+static inline void INIT_HLIST_NODE(struct cds_hlist_node *h)
{
h->next = NULL;
h->pprev = NULL;
}
-static inline int hlist_unhashed(const struct hlist_node *h)
+static inline int hlist_unhashed(const struct cds_hlist_node *h)
{
return !h->pprev;
}
-static inline int hlist_empty(const struct hlist_head *h)
+static inline int hlist_empty(const struct cds_hlist_head *h)
{
return !h->first;
}
-static inline void __hlist_del(struct hlist_node *n)
+static inline void __cds_hlist_del(struct cds_hlist_node *n)
{
- struct hlist_node *next = n->next;
- struct hlist_node **pprev = n->pprev;
+ struct cds_hlist_node *next = n->next;
+ struct cds_hlist_node **pprev = n->pprev;
*pprev = next;
if (next)
next->pprev = pprev;
}
-static inline void hlist_del(struct hlist_node *n)
+static inline void cds_hlist_del(struct cds_hlist_node *n)
{
- __hlist_del(n);
+ __cds_hlist_del(n);
n->next = LIST_POISON1;
n->pprev = LIST_POISON2;
}
-static inline void hlist_del_init(struct hlist_node *n)
+static inline void cds_hlist_del_init(struct cds_hlist_node *n)
{
if (!hlist_unhashed(n)) {
- __hlist_del(n);
+ __cds_hlist_del(n);
INIT_HLIST_NODE(n);
}
}
-static inline void hlist_add_head(struct hlist_node *n, struct hlist_head *h)
+static inline void cds_hlist_add_head(struct cds_hlist_node *n, struct cds_hlist_head *h)
{
- struct hlist_node *first = h->first;
+ struct cds_hlist_node *first = h->first;
n->next = first;
if (first)
first->pprev = &n->next;
}
/* next must be != NULL */
-static inline void hlist_add_before(struct hlist_node *n,
- struct hlist_node *next)
+static inline void hlist_add_before(struct cds_hlist_node *n,
+ struct cds_hlist_node *next)
{
n->pprev = next->pprev;
n->next = next;
*(n->pprev) = n;
}
-static inline void hlist_add_after(struct hlist_node *n,
- struct hlist_node *next)
+static inline void hlist_add_after(struct cds_hlist_node *n,
+ struct cds_hlist_node *next)
{
next->next = n->next;
n->next = next;
* Move a list from one list head to another. Fixup the pprev
* reference of the first entry if it exists.
*/
-static inline void hlist_move_list(struct hlist_head *old,
- struct hlist_head *new)
+static inline void hlist_move_list(struct cds_hlist_head *old,
+ struct cds_hlist_head *new)
{
new->first = old->first;
if (new->first)
old->first = NULL;
}
-#define hlist_entry(ptr, type, member) caa_container_of(ptr,type,member)
+#define cds_hlist_entry(ptr, type, member) caa_container_of(ptr,type,member)
-#define hlist_for_each(pos, head) \
+#define cds_hlist_for_each(pos, head) \
for (pos = (head)->first; pos && ({ prefetch(pos->next); 1; }); \
pos = pos->next)
-#define hlist_for_each_safe(pos, n, head) \
+#define cds_hlist_for_each_safe(pos, n, head) \
for (pos = (head)->first; pos && ({ n = pos->next; 1; }); \
pos = n)
/**
- * hlist_for_each_entry - iterate over list of given type
+ * cds_hlist_for_each_entry - iterate over list of given type
* @tpos: the type * to use as a loop cursor.
- * @pos: the &struct hlist_node to use as a loop cursor.
+ * @pos: the &struct cds_hlist_node to use as a loop cursor.
* @head: the head for your list.
- * @member: the name of the hlist_node within the struct.
+ * @member: the name of the cds_hlist_node within the struct.
*/
-#define hlist_for_each_entry(tpos, pos, head, member) \
+#define cds_hlist_for_each_entry(tpos, pos, head, member) \
for (pos = (head)->first; \
pos && ({ prefetch(pos->next); 1;}) && \
- ({ tpos = hlist_entry(pos, typeof(*tpos), member); 1;}); \
+ ({ tpos = cds_hlist_entry(pos, typeof(*tpos), member); 1;}); \
pos = pos->next)
/**
- * hlist_for_each_entry_continue - iterate over a hlist continuing after current point
+ * cds_hlist_for_each_entry_continue - iterate over a hlist continuing after current point
* @tpos: the type * to use as a loop cursor.
- * @pos: the &struct hlist_node to use as a loop cursor.
- * @member: the name of the hlist_node within the struct.
+ * @pos: the &struct cds_hlist_node to use as a loop cursor.
+ * @member: the name of the cds_hlist_node within the struct.
*/
-#define hlist_for_each_entry_continue(tpos, pos, member) \
+#define cds_hlist_for_each_entry_continue(tpos, pos, member) \
for (pos = (pos)->next; \
pos && ({ prefetch(pos->next); 1;}) && \
- ({ tpos = hlist_entry(pos, typeof(*tpos), member); 1;}); \
+ ({ tpos = cds_hlist_entry(pos, typeof(*tpos), member); 1;}); \
pos = pos->next)
/**
- * hlist_for_each_entry_from - iterate over a hlist continuing from current point
+ * cds_hlist_for_each_entry_from - iterate over a hlist continuing from current point
* @tpos: the type * to use as a loop cursor.
- * @pos: the &struct hlist_node to use as a loop cursor.
- * @member: the name of the hlist_node within the struct.
+ * @pos: the &struct cds_hlist_node to use as a loop cursor.
+ * @member: the name of the cds_hlist_node within the struct.
*/
-#define hlist_for_each_entry_from(tpos, pos, member) \
+#define cds_hlist_for_each_entry_from(tpos, pos, member) \
for (; pos && ({ prefetch(pos->next); 1;}) && \
- ({ tpos = hlist_entry(pos, typeof(*tpos), member); 1;}); \
+ ({ tpos = cds_hlist_entry(pos, typeof(*tpos), member); 1;}); \
pos = pos->next)
/**
- * hlist_for_each_entry_safe - iterate over list of given type safe against removal of list entry
+ * cds_hlist_for_each_entry_safe - iterate over list of given type safe against removal of list entry
* @tpos: the type * to use as a loop cursor.
- * @pos: the &struct hlist_node to use as a loop cursor.
- * @n: another &struct hlist_node to use as temporary storage
+ * @pos: the &struct cds_hlist_node to use as a loop cursor.
+ * @n: another &struct cds_hlist_node to use as temporary storage
* @head: the head for your list.
- * @member: the name of the hlist_node within the struct.
+ * @member: the name of the cds_hlist_node within the struct.
*/
-#define hlist_for_each_entry_safe(tpos, pos, n, head, member) \
+#define cds_hlist_for_each_entry_safe(tpos, pos, n, head, member) \
for (pos = (head)->first; \
pos && ({ n = pos->next; 1; }) && \
- ({ tpos = hlist_entry(pos, typeof(*tpos), member); 1;}); \
+ ({ tpos = cds_hlist_entry(pos, typeof(*tpos), member); 1;}); \
pos = n)
#endif
static unsigned int nr_enqueuers;
static unsigned int nr_dequeuers;
-static struct rcu_lfq_queue q;
+static struct cds_lfq_queue_rcu q;
void *thr_enqueuer(void *_count)
{
cmm_smp_mb();
for (;;) {
- struct rcu_lfq_node *node = malloc(sizeof(*node));
+ struct cds_lfq_node_rcu *node = malloc(sizeof(*node));
if (!node)
goto fail;
- rcu_lfq_node_init(node);
- rcu_lfq_enqueue(&q, node);
+ cds_lfq_node_init_rcu(node);
+ cds_lfq_enqueue_rcu(&q, node);
nr_successful_enqueues++;
if (unlikely(wdelay))
static void rcu_release_node(struct urcu_ref *ref)
{
- struct rcu_lfq_node *node = caa_container_of(ref, struct rcu_lfq_node, ref);
+ struct cds_lfq_node_rcu *node = caa_container_of(ref, struct cds_lfq_node_rcu, ref);
defer_rcu(free, node);
//synchronize_rcu();
//free(node);
cmm_smp_mb();
for (;;) {
- struct rcu_lfq_node *node = rcu_lfq_dequeue(&q,
+ struct cds_lfq_node_rcu *node = cds_lfq_dequeue_rcu(&q,
rcu_release_node);
if (node) {
static void release_node(struct urcu_ref *ref)
{
- struct rcu_lfq_node *node = caa_container_of(ref, struct rcu_lfq_node, ref);
+ struct cds_lfq_node_rcu *node = caa_container_of(ref, struct cds_lfq_node_rcu, ref);
free(node);
}
-void test_end(struct rcu_lfq_queue *q, unsigned long long *nr_dequeues)
+void test_end(struct cds_lfq_queue_rcu *q, unsigned long long *nr_dequeues)
{
- struct rcu_lfq_node *node;
+ struct cds_lfq_node_rcu *node;
do {
- node = rcu_lfq_dequeue(q, release_node);
+ node = cds_lfq_dequeue_rcu(q, release_node);
if (node) {
urcu_ref_put(&node->ref, release_node);
(*nr_dequeues)++;
tid_dequeuer = malloc(sizeof(*tid_dequeuer) * nr_dequeuers);
count_enqueuer = malloc(2 * sizeof(*count_enqueuer) * nr_enqueuers);
count_dequeuer = malloc(2 * sizeof(*count_dequeuer) * nr_dequeuers);
- rcu_lfq_init(&q);
+ cds_lfq_init_rcu(&q);
next_aff = 0;
static unsigned int nr_enqueuers;
static unsigned int nr_dequeuers;
-static struct rcu_lfs_stack s;
+static struct cds_lfs_stack_rcu s;
void *thr_enqueuer(void *_count)
{
cmm_smp_mb();
for (;;) {
- struct rcu_lfs_node *node = malloc(sizeof(*node));
+ struct cds_lfs_node_rcu *node = malloc(sizeof(*node));
if (!node)
goto fail;
- rcu_lfs_node_init(node);
- rcu_lfs_push(&s, node);
+ cds_lfs_node_init_rcu(node);
+ cds_lfs_push_rcu(&s, node);
nr_successful_enqueues++;
if (unlikely(wdelay))
cmm_smp_mb();
for (;;) {
- struct rcu_lfs_node *node = rcu_lfs_pop(&s);
+ struct cds_lfs_node_rcu *node = cds_lfs_pop_rcu(&s);
if (node) {
defer_rcu(free, node);
return ((void*)2);
}
-void test_end(struct rcu_lfs_stack *s, unsigned long long *nr_dequeues)
+void test_end(struct cds_lfs_stack_rcu *s, unsigned long long *nr_dequeues)
{
- struct rcu_lfs_node *node;
+ struct cds_lfs_node_rcu *node;
do {
- node = rcu_lfs_pop(s);
+ node = cds_lfs_pop_rcu(s);
if (node) {
free(node);
(*nr_dequeues)++;
tid_dequeuer = malloc(sizeof(*tid_dequeuer) * nr_dequeuers);
count_enqueuer = malloc(2 * sizeof(*count_enqueuer) * nr_enqueuers);
count_dequeuer = malloc(2 * sizeof(*count_dequeuer) * nr_dequeuers);
- rcu_lfs_init(&s);
+ cds_lfs_init_rcu(&s);
next_aff = 0;
static unsigned int nr_enqueuers;
static unsigned int nr_dequeuers;
-static struct wfq_queue q;
+static struct cds_wfq_queue q;
void *thr_enqueuer(void *_count)
{
cmm_smp_mb();
for (;;) {
- struct wfq_node *node = malloc(sizeof(*node));
+ struct cds_wfq_node *node = malloc(sizeof(*node));
if (!node)
goto fail;
- wfq_node_init(node);
- wfq_enqueue(&q, node);
+ cds_wfq_node_init(node);
+ cds_wfq_enqueue(&q, node);
nr_successful_enqueues++;
if (unlikely(wdelay))
cmm_smp_mb();
for (;;) {
- struct wfq_node *node = wfq_dequeue_blocking(&q);
+ struct cds_wfq_node *node = cds_wfq_dequeue_blocking(&q);
if (node) {
free(node);
return ((void*)2);
}
-void test_end(struct wfq_queue *q, unsigned long long *nr_dequeues)
+void test_end(struct cds_wfq_queue *q, unsigned long long *nr_dequeues)
{
- struct wfq_node *node;
+ struct cds_wfq_node *node;
do {
- node = wfq_dequeue_blocking(q);
+ node = cds_wfq_dequeue_blocking(q);
if (node) {
free(node);
(*nr_dequeues)++;
tid_dequeuer = malloc(sizeof(*tid_dequeuer) * nr_dequeuers);
count_enqueuer = malloc(2 * sizeof(*count_enqueuer) * nr_enqueuers);
count_dequeuer = malloc(2 * sizeof(*count_dequeuer) * nr_dequeuers);
- wfq_init(&q);
+ cds_wfq_init(&q);
next_aff = 0;
static unsigned int nr_enqueuers;
static unsigned int nr_dequeuers;
-static struct wfs_stack s;
+static struct cds_wfs_stack s;
void *thr_enqueuer(void *_count)
{
cmm_smp_mb();
for (;;) {
- struct wfs_node *node = malloc(sizeof(*node));
+ struct cds_wfs_node *node = malloc(sizeof(*node));
if (!node)
goto fail;
- wfs_node_init(node);
- wfs_push(&s, node);
+ cds_wfs_node_init(node);
+ cds_wfs_push(&s, node);
nr_successful_enqueues++;
if (unlikely(wdelay))
cmm_smp_mb();
for (;;) {
- struct wfs_node *node = wfs_pop_blocking(&s);
+ struct cds_wfs_node *node = cds_wfs_pop_blocking(&s);
if (node) {
free(node);
return ((void*)2);
}
-void test_end(struct wfs_stack *s, unsigned long long *nr_dequeues)
+void test_end(struct cds_wfs_stack *s, unsigned long long *nr_dequeues)
{
- struct wfs_node *node;
+ struct cds_wfs_node *node;
do {
- node = wfs_pop_blocking(s);
+ node = cds_wfs_pop_blocking(s);
if (node) {
free(node);
(*nr_dequeues)++;
tid_dequeuer = malloc(sizeof(*tid_dequeuer) * nr_dequeuers);
count_enqueuer = malloc(2 * sizeof(*count_enqueuer) * nr_enqueuers);
count_dequeuer = malloc(2 * sizeof(*count_dequeuer) * nr_dequeuers);
- wfs_init(&s);
+ cds_wfs_init(&s);
next_aff = 0;
/* Data used by both reader and synchronize_rcu() */
long ctr;
/* Data used for registry */
- struct list_head node __attribute__((aligned(CAA_CACHE_LINE_SIZE)));
+ struct cds_list_head node __attribute__((aligned(CAA_CACHE_LINE_SIZE)));
pthread_t tid;
int alloc; /* registry entry allocated */
};
*/
struct rcu_reader __thread *rcu_reader;
-static LIST_HEAD(registry);
+static CDS_LIST_HEAD(registry);
struct registry_arena {
void *p;
void update_counter_and_wait(void)
{
- LIST_HEAD(qsreaders);
+ CDS_LIST_HEAD(qsreaders);
int wait_loops = 0;
struct rcu_reader *index, *tmp;
*/
for (;;) {
wait_loops++;
- list_for_each_entry_safe(index, tmp, ®istry, node) {
+ cds_list_for_each_entry_safe(index, tmp, ®istry, node) {
if (!rcu_old_gp_ongoing(&index->ctr))
- list_move(&index->node, &qsreaders);
+ cds_list_move(&index->node, &qsreaders);
}
- if (list_empty(®istry)) {
+ if (cds_list_empty(®istry)) {
break;
} else {
if (wait_loops == RCU_QS_ACTIVE_ATTEMPTS)
}
}
/* put back the reader list in the registry */
- list_splice(&qsreaders, ®istry);
+ cds_list_splice(&qsreaders, ®istry);
}
void synchronize_rcu(void)
mutex_lock(&rcu_gp_lock);
- if (list_empty(®istry))
+ if (cds_list_empty(®istry))
goto out;
/* All threads should read qparity before accessing data structure
/* Add to registry */
rcu_reader_reg->tid = pthread_self();
assert(rcu_reader_reg->ctr == 0);
- list_add(&rcu_reader_reg->node, ®istry);
+ cds_list_add(&rcu_reader_reg->node, ®istry);
rcu_reader = rcu_reader_reg;
}
ret = pthread_kill(tid, 0);
assert(ret != EINVAL);
if (ret == ESRCH) {
- list_del(&rcu_reader_reg->node);
+ cds_list_del(&rcu_reader_reg->node);
rcu_reader_reg->ctr = 0;
rcu_reader_reg->alloc = 0;
registry_arena.used -= sizeof(struct rcu_reader);
void **q;
/* registry information */
unsigned long last_head;
- struct list_head list; /* list of thread queues */
+ struct cds_list_head list; /* list of thread queues */
};
#ifdef __cplusplus
* the reclamation tread.
*/
static struct defer_queue __thread defer_queue;
-static LIST_HEAD(registry);
+static CDS_LIST_HEAD(registry);
static pthread_t tid_defer;
static void mutex_lock(pthread_mutex_t *mutex)
struct defer_queue *index;
mutex_lock(&rcu_defer_mutex);
- list_for_each_entry(index, ®istry, list) {
+ cds_list_for_each_entry(index, ®istry, list) {
head = CAA_LOAD_SHARED(index->head);
num_items += head - index->tail;
}
struct defer_queue *index;
unsigned long num_items = 0;
- if (list_empty(®istry))
+ if (cds_list_empty(®istry))
return;
mutex_lock(&rcu_defer_mutex);
- list_for_each_entry(index, ®istry, list) {
+ cds_list_for_each_entry(index, ®istry, list) {
index->last_head = CAA_LOAD_SHARED(index->head);
num_items += index->last_head - index->tail;
}
goto end;
}
synchronize_rcu();
- list_for_each_entry(index, ®istry, list)
+ cds_list_for_each_entry(index, ®istry, list)
rcu_defer_barrier_queue(index, index->last_head);
end:
mutex_unlock(&rcu_defer_mutex);
mutex_lock(&defer_thread_mutex);
mutex_lock(&rcu_defer_mutex);
- was_empty = list_empty(®istry);
- list_add(&defer_queue.list, ®istry);
+ was_empty = cds_list_empty(®istry);
+ cds_list_add(&defer_queue.list, ®istry);
mutex_unlock(&rcu_defer_mutex);
if (was_empty)
mutex_lock(&defer_thread_mutex);
mutex_lock(&rcu_defer_mutex);
- list_del(&defer_queue.list);
+ cds_list_del(&defer_queue.list);
_rcu_defer_barrier_thread();
free(defer_queue.q);
defer_queue.q = NULL;
- is_empty = list_empty(®istry);
+ is_empty = cds_list_empty(®istry);
mutex_unlock(&rcu_defer_mutex);
if (is_empty)
void rcu_defer_exit(void)
{
- assert(list_empty(®istry));
+ assert(cds_list_empty(®istry));
}
/* Data used by both reader and synchronize_rcu() */
unsigned long ctr;
/* Data used for registry */
- struct list_head node __attribute__((aligned(CAA_CACHE_LINE_SIZE)));
+ struct cds_list_head node __attribute__((aligned(CAA_CACHE_LINE_SIZE)));
pthread_t tid;
};
unsigned int __thread rand_yield;
#endif
-static LIST_HEAD(registry);
+static CDS_LIST_HEAD(registry);
static void mutex_lock(pthread_mutex_t *mutex)
{
static void update_counter_and_wait(void)
{
- LIST_HEAD(qsreaders);
+ CDS_LIST_HEAD(qsreaders);
int wait_loops = 0;
struct rcu_reader *index, *tmp;
cmm_smp_mb();
}
- list_for_each_entry_safe(index, tmp, ®istry, node) {
+ cds_list_for_each_entry_safe(index, tmp, ®istry, node) {
if (!rcu_gp_ongoing(&index->ctr))
- list_move(&index->node, &qsreaders);
+ cds_list_move(&index->node, &qsreaders);
}
- if (list_empty(®istry)) {
+ if (cds_list_empty(®istry)) {
if (wait_loops == RCU_QS_ACTIVE_ATTEMPTS) {
/* Read reader_gp before write futex */
cmm_smp_mb();
}
}
/* put back the reader list in the registry */
- list_splice(&qsreaders, ®istry);
+ cds_list_splice(&qsreaders, ®istry);
}
/*
mutex_lock(&rcu_gp_lock);
- if (list_empty(®istry))
+ if (cds_list_empty(®istry))
goto out;
/*
CAA_STORE_SHARED(rcu_reader.ctr, 0);
mutex_lock(&rcu_gp_lock);
- if (list_empty(®istry))
+ if (cds_list_empty(®istry))
goto out;
update_counter_and_wait();
out:
assert(rcu_reader.ctr == 0);
mutex_lock(&rcu_gp_lock);
- list_add(&rcu_reader.node, ®istry);
+ cds_list_add(&rcu_reader.node, ®istry);
mutex_unlock(&rcu_gp_lock);
_rcu_thread_online();
}
*/
_rcu_thread_offline();
mutex_lock(&rcu_gp_lock);
- list_del(&rcu_reader.node);
+ cds_list_del(&rcu_reader.node);
mutex_unlock(&rcu_gp_lock);
}
void rcu_exit(void)
{
- assert(list_empty(®istry));
+ assert(cds_list_empty(®istry));
}
unsigned long ctr;
char need_mb;
/* Data used for registry */
- struct list_head node __attribute__((aligned(CAA_CACHE_LINE_SIZE)));
+ struct cds_list_head node __attribute__((aligned(CAA_CACHE_LINE_SIZE)));
pthread_t tid;
};
unsigned int __thread rand_yield;
#endif
-static LIST_HEAD(registry);
+static CDS_LIST_HEAD(registry);
static void mutex_lock(pthread_mutex_t *mutex)
{
* Ask for each threads to execute a cmm_smp_mb() so we can consider the
* compiler barriers around rcu read lock as real memory barriers.
*/
- if (list_empty(®istry))
+ if (cds_list_empty(®istry))
return;
/*
* pthread_kill has a cmm_smp_mb(). But beware, we assume it performs
* safe and don't assume anything : we use cmm_smp_mc() to make sure the
* cache flush is enforced.
*/
- list_for_each_entry(index, ®istry, node) {
+ cds_list_for_each_entry(index, ®istry, node) {
CAA_STORE_SHARED(index->need_mb, 1);
pthread_kill(index->tid, SIGRCU);
}
* relevant bug report. For Linux kernels, we recommend getting
* the Linux Test Project (LTP).
*/
- list_for_each_entry(index, ®istry, node) {
+ cds_list_for_each_entry(index, ®istry, node) {
while (CAA_LOAD_SHARED(index->need_mb)) {
pthread_kill(index->tid, SIGRCU);
poll(NULL, 0, 1);
void update_counter_and_wait(void)
{
- LIST_HEAD(qsreaders);
+ CDS_LIST_HEAD(qsreaders);
int wait_loops = 0;
struct rcu_reader *index, *tmp;
smp_mb_master(RCU_MB_GROUP);
}
- list_for_each_entry_safe(index, tmp, ®istry, node) {
+ cds_list_for_each_entry_safe(index, tmp, ®istry, node) {
if (!rcu_gp_ongoing(&index->ctr))
- list_move(&index->node, &qsreaders);
+ cds_list_move(&index->node, &qsreaders);
}
#ifndef HAS_INCOHERENT_CACHES
- if (list_empty(®istry)) {
+ if (cds_list_empty(®istry)) {
if (wait_loops == RCU_QS_ACTIVE_ATTEMPTS) {
/* Read reader_gp before write futex */
smp_mb_master(RCU_MB_GROUP);
* BUSY-LOOP. Force the reader thread to commit its
* rcu_reader.ctr update to memory if we wait for too long.
*/
- if (list_empty(®istry)) {
+ if (cds_list_empty(®istry)) {
if (wait_loops == RCU_QS_ACTIVE_ATTEMPTS) {
/* Read reader_gp before write futex */
smp_mb_master(RCU_MB_GROUP);
#endif /* #else #ifndef HAS_INCOHERENT_CACHES */
}
/* put back the reader list in the registry */
- list_splice(&qsreaders, ®istry);
+ cds_list_splice(&qsreaders, ®istry);
}
void synchronize_rcu(void)
{
mutex_lock(&rcu_gp_lock);
- if (list_empty(®istry))
+ if (cds_list_empty(®istry))
goto out;
/* All threads should read qparity before accessing data structure
mutex_lock(&rcu_gp_lock);
rcu_init(); /* In case gcc does not support constructor attribute */
- list_add(&rcu_reader.node, ®istry);
+ cds_list_add(&rcu_reader.node, ®istry);
mutex_unlock(&rcu_gp_lock);
}
void rcu_unregister_thread(void)
{
mutex_lock(&rcu_gp_lock);
- list_del(&rcu_reader.node);
+ cds_list_del(&rcu_reader.node);
mutex_unlock(&rcu_gp_lock);
}
exit(-1);
}
assert(act.sa_sigaction == sigrcu_handler);
- assert(list_empty(®istry));
+ assert(cds_list_empty(®istry));
}
#endif /* #ifdef RCU_SIGNAL */
* published by the Free Software Foundation.
*/
-struct hlist_head
+struct cds_hlist_head
{
- struct hlist_node *next;
+ struct cds_hlist_node *next;
};
-struct hlist_node
+struct cds_hlist_node
{
- struct hlist_node *next;
- struct hlist_node *prev;
+ struct cds_hlist_node *next;
+ struct cds_hlist_node *prev;
};
/* Initialize a new list head. */
-static inline void INIT_HLIST_HEAD(struct hlist_head *ptr)
+static inline void CDS_INIT_HLIST_HEAD(struct cds_hlist_head *ptr)
{
ptr->next = NULL;
}
/* Get typed element from list at a given position. */
-#define hlist_entry(ptr, type, member) \
+#define cds_hlist_entry(ptr, type, member) \
((type *) ((char *) (ptr) - (unsigned long) (&((type *) 0)->member)))
/* Add new element at the head of the list. */
-static inline void hlist_add_head (struct hlist_node *newp,
- struct hlist_head *head)
+static inline void cds_hlist_add_head (struct cds_hlist_node *newp,
+ struct cds_hlist_head *head)
{
if (head->next)
head->next->prev = newp;
newp->next = head->next;
- newp->prev = (struct hlist_node *)head;
+ newp->prev = (struct cds_hlist_node *)head;
head->next = newp;
}
/* Remove element from list. */
-static inline void hlist_del (struct hlist_node *elem)
+static inline void cds_hlist_del (struct cds_hlist_node *elem)
{
if (elem->next)
elem->next->prev = elem->prev;
elem->prev->next = elem->next;
}
-#define hlist_for_each_entry(entry, pos, head, member) \
+#define cds_hlist_for_each_entry(entry, pos, head, member) \
for (pos = (head)->next, \
- entry = hlist_entry(pos, typeof(*entry), member); \
+ entry = cds_hlist_entry(pos, typeof(*entry), member); \
pos != NULL; \
pos = pos->next, \
- entry = hlist_entry(pos, typeof(*entry), member))
+ entry = cds_hlist_entry(pos, typeof(*entry), member))
-#define hlist_for_each_entry_safe(entry, pos, p, head, member) \
+#define cds_hlist_for_each_entry_safe(entry, pos, p, head, member) \
for (pos = (head)->next, \
- entry = hlist_entry(pos, typeof(*entry), member); \
+ entry = cds_hlist_entry(pos, typeof(*entry), member); \
(pos != NULL) && ({ p = pos->next; 1;}); \
pos = p, \
- entry = hlist_entry(pos, typeof(*entry), member))
+ entry = cds_hlist_entry(pos, typeof(*entry), member))
#endif /* _KCOMPAT_HLIST_H */
/* Basic type for the double-link list. */
-typedef struct list_head
+typedef struct cds_list_head
{
- struct list_head *next;
- struct list_head *prev;
+ struct cds_list_head *next;
+ struct cds_list_head *prev;
} list_t;
/* Define a variable with the head and tail of the list. */
-#define LIST_HEAD(name) \
+#define CDS_LIST_HEAD(name) \
list_t name = { &(name), &(name) }
/* Initialize a new list head. */
-#define INIT_LIST_HEAD(ptr) \
+#define CDS_INIT_LIST_HEAD(ptr) \
(ptr)->next = (ptr)->prev = (ptr)
-#define LIST_HEAD_INIT(name) { .prev = &(name), .next = &(name) }
+#define CDS_LIST_HEAD_INIT(name) { .prev = &(name), .next = &(name) }
/* Add new element at the head of the list. */
static inline void
-list_add (list_t *newp, list_t *head)
+cds_list_add (list_t *newp, list_t *head)
{
head->next->prev = newp;
newp->next = head->next;
/* Add new element at the tail of the list. */
static inline void
-list_add_tail (list_t *newp, list_t *head)
+cds_list_add_tail (list_t *newp, list_t *head)
{
head->prev->next = newp;
newp->next = head;
/* Remove element from list. */
static inline void
-__list_del (list_t *prev, list_t *next)
+__cds_list_del (list_t *prev, list_t *next)
{
next->prev = prev;
prev->next = next;
/* Remove element from list. */
static inline void
-list_del (list_t *elem)
+cds_list_del (list_t *elem)
{
- __list_del (elem->prev, elem->next);
+ __cds_list_del (elem->prev, elem->next);
}
/* delete from list, add to another list as head */
static inline void
-list_move (list_t *elem, list_t *head)
+cds_list_move (list_t *elem, list_t *head)
{
- __list_del (elem->prev, elem->next);
- list_add (elem, head);
+ __cds_list_del (elem->prev, elem->next);
+ cds_list_add (elem, head);
}
/* replace an old entry.
*/
static inline void
-list_replace(list_t *old, list_t *_new)
+cds_list_replace(list_t *old, list_t *_new)
{
_new->next = old->next;
_new->prev = old->prev;
/* Join two lists. */
static inline void
-list_splice (list_t *add, list_t *head)
+cds_list_splice (list_t *add, list_t *head)
{
/* Do nothing if the list which gets added is empty. */
if (add != add->next)
/* Get typed element from list at a given position. */
-#define list_entry(ptr, type, member) \
+#define cds_list_entry(ptr, type, member) \
((type *) ((char *) (ptr) - (unsigned long) (&((type *) 0)->member)))
/* Iterate forward over the elements of the list. */
-#define list_for_each(pos, head) \
+#define cds_list_for_each(pos, head) \
for (pos = (head)->next; pos != (head); pos = pos->next)
/* Iterate forward over the elements of the list. */
-#define list_for_each_prev(pos, head) \
+#define cds_list_for_each_prev(pos, head) \
for (pos = (head)->prev; pos != (head); pos = pos->prev)
/* Iterate backwards over the elements list. The list elements can be
removed from the list while doing this. */
-#define list_for_each_prev_safe(pos, p, head) \
+#define cds_list_for_each_prev_safe(pos, p, head) \
for (pos = (head)->prev, p = pos->prev; \
pos != (head); \
pos = p, p = pos->prev)
-#define list_for_each_entry(pos, head, member) \
- for (pos = list_entry((head)->next, typeof(*pos), member); \
+#define cds_list_for_each_entry(pos, head, member) \
+ for (pos = cds_list_entry((head)->next, typeof(*pos), member); \
&pos->member != (head); \
- pos = list_entry(pos->member.next, typeof(*pos), member))
+ pos = cds_list_entry(pos->member.next, typeof(*pos), member))
-#define list_for_each_entry_reverse(pos, head, member) \
- for (pos = list_entry((head)->prev, typeof(*pos), member); \
+#define cds_list_for_each_entry_reverse(pos, head, member) \
+ for (pos = cds_list_entry((head)->prev, typeof(*pos), member); \
&pos->member != (head); \
- pos = list_entry(pos->member.prev, typeof(*pos), member))
+ pos = cds_list_entry(pos->member.prev, typeof(*pos), member))
-#define list_for_each_entry_safe(pos, p, head, member) \
- for (pos = list_entry((head)->next, typeof(*pos), member), \
- p = list_entry(pos->member.next,typeof(*pos), member); \
+#define cds_list_for_each_entry_safe(pos, p, head, member) \
+ for (pos = cds_list_entry((head)->next, typeof(*pos), member), \
+ p = cds_list_entry(pos->member.next,typeof(*pos), member); \
&pos->member != (head); \
- pos = p, p = list_entry(pos->member.next, typeof(*pos), member))
+ pos = p, p = cds_list_entry(pos->member.next, typeof(*pos), member))
-static inline int list_empty(list_t *head)
+static inline int cds_list_empty(list_t *head)
{
return head == head->next;
}
-static inline void list_replace_init(list_t *old,
+static inline void cds_list_replace_init(list_t *old,
list_t *_new)
{
list_t *head = old->next;
- list_del(old);
- list_add_tail(_new, head);
- INIT_LIST_HEAD(old);
+ cds_list_del(old);
+ cds_list_add_tail(_new, head);
+ CDS_INIT_LIST_HEAD(old);
}
#endif /* list.h */
/* Add new element at the head of the list.
*/
-static inline void hlist_add_head_rcu(struct hlist_node *newp,
- struct hlist_head *head)
+static inline void cds_hlist_add_head_rcu(struct cds_hlist_node *newp,
+ struct cds_hlist_head *head)
{
newp->next = head->next;
- newp->prev = (struct hlist_node *)head;
+ newp->prev = (struct cds_hlist_node *)head;
cmm_smp_wmb();
if (head->next)
head->next->prev = newp;
}
/* Remove element from list. */
-static inline void hlist_del_rcu(struct hlist_node *elem)
+static inline void cds_hlist_del_rcu(struct cds_hlist_node *elem)
{
if (elem->next)
elem->next->prev = elem->prev;
* This must be done while rcu_read_lock() is held.
*/
-#define hlist_for_each_entry_rcu(entry, pos, head, member) \
+#define cds_hlist_for_each_entry_rcu(entry, pos, head, member) \
for (pos = rcu_dereference((head)->next), \
- entry = hlist_entry(pos, typeof(*entry), member); \
+ entry = cds_hlist_entry(pos, typeof(*entry), member); \
pos != NULL; \
pos = rcu_dereference(pos->next), \
- entry = hlist_entry(pos, typeof(*entry), member))
+ entry = cds_hlist_entry(pos, typeof(*entry), member))
#endif /* _URCU_RCUHLIST_H */
#define URCU_LFQ_PERMANENT_REF 128
-void _rcu_lfq_node_init(struct rcu_lfq_node *node)
+void _cds_lfq_node_init_rcu(struct cds_lfq_node_rcu *node)
{
node->next = NULL;
urcu_ref_init(&node->ref);
}
-void _rcu_lfq_init(struct rcu_lfq_queue *q)
+void _cds_lfq_init_rcu(struct cds_lfq_queue_rcu *q)
{
- _rcu_lfq_node_init(&q->init);
+ _cds_lfq_node_init_rcu(&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;
}
-void _rcu_lfq_enqueue(struct rcu_lfq_queue *q, struct rcu_lfq_node *node)
+void _cds_lfq_enqueue_rcu(struct cds_lfq_queue_rcu *q, struct cds_lfq_node_rcu *node)
{
urcu_ref_get(&node->ref);
*/
for (;;) {
- struct rcu_lfq_node *tail, *next;
+ struct cds_lfq_node_rcu *tail, *next;
rcu_read_lock();
tail = rcu_dereference(q->tail);
* 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 after execution of the release callback before
- * performing the actual memory reclamation or modifying the rcu_lfq_node
+ * performing the actual memory reclamation or modifying the cds_lfq_node_rcu
* 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 *))
+struct cds_lfq_node_rcu *
+_cds_lfq_dequeue_rcu(struct cds_lfq_queue_rcu *q, void (*release)(struct urcu_ref *))
{
for (;;) {
- struct rcu_lfq_node *head, *next;
+ struct cds_lfq_node_rcu *head, *next;
rcu_read_lock();
head = rcu_dereference(q->head);
* which point their reference count will be decremented.
*/
-struct rcu_lfq_node {
- struct rcu_lfq_node *next;
+struct cds_lfq_node_rcu {
+ struct cds_lfq_node_rcu *next;
struct urcu_ref ref;
};
-struct rcu_lfq_queue {
- struct rcu_lfq_node *head, *tail;
- struct rcu_lfq_node init; /* Dummy initialization node */
+struct cds_lfq_queue_rcu {
+ struct cds_lfq_node_rcu *head, *tail;
+ struct cds_lfq_node_rcu init; /* Dummy initialization node */
};
#ifdef _LGPL_SOURCE
#include <urcu/rculfqueue-static.h>
-#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
+#define cds_lfq_node_init_rcu _cds_lfq_node_init_rcu
+#define cds_lfq_init_rcu _cds_lfq_init_rcu
+#define cds_lfq_enqueue_rcu _cds_lfq_enqueue_rcu
+#define cds_lfq_dequeue_rcu _cds_lfq_dequeue_rcu
#else /* !_LGPL_SOURCE */
-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);
+extern void cds_lfq_node_init_rcu(struct cds_lfq_node_rcu *node);
+extern void cds_lfq_init_rcu(struct cds_lfq_queue_rcu *q);
+extern void cds_lfq_enqueue_rcu(struct cds_lfq_queue_rcu *q, struct cds_lfq_node_rcu *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 after execution of the release callback before
- * performing the actual memory reclamation or modifying the rcu_lfq_node
+ * performing the actual memory reclamation or modifying the cds_lfq_node_rcu
* 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).
*/
-extern struct rcu_lfq_node *
-rcu_lfq_dequeue(struct rcu_lfq_queue *q, void (*release)(struct urcu_ref *));
+extern struct cds_lfq_node_rcu *
+cds_lfq_dequeue_rcu(struct cds_lfq_queue_rcu *q, void (*release)(struct urcu_ref *));
#endif /* !_LGPL_SOURCE */
extern "C" {
#endif
-void _rcu_lfs_node_init(struct rcu_lfs_node *node)
+void _cds_lfs_node_init_rcu(struct cds_lfs_node_rcu *node)
{
}
-void _rcu_lfs_init(struct rcu_lfs_stack *s)
+void _cds_lfs_init_rcu(struct cds_lfs_stack_rcu *s)
{
s->head = NULL;
}
-void _rcu_lfs_push(struct rcu_lfs_stack *s, struct rcu_lfs_node *node)
+void _cds_lfs_push_rcu(struct cds_lfs_stack_rcu *s, struct cds_lfs_node_rcu *node)
{
- struct rcu_lfs_node *head = NULL;
+ struct cds_lfs_node_rcu *head = NULL;
for (;;) {
- struct rcu_lfs_node *old_head = head;
+ struct cds_lfs_node_rcu *old_head = head;
node->next = head;
/*
/*
* The caller must wait for a grace period to pass before freeing the returned
- * node or modifying the rcu_lfs_node structure.
+ * node or modifying the cds_lfs_node_rcu structure.
* Returns NULL if stack is empty.
*/
-struct rcu_lfs_node *
-_rcu_lfs_pop(struct rcu_lfs_stack *s)
+struct cds_lfs_node_rcu *
+_cds_lfs_pop_rcu(struct cds_lfs_stack_rcu *s)
{
for (;;) {
- struct rcu_lfs_node *head;
+ struct cds_lfs_node_rcu *head;
rcu_read_lock();
head = rcu_dereference(s->head);
if (head) {
- struct rcu_lfs_node *next = rcu_dereference(head->next);
+ struct cds_lfs_node_rcu *next = rcu_dereference(head->next);
if (uatomic_cmpxchg(&s->head, head, next) == head) {
rcu_read_unlock();
extern "C" {
#endif
-struct rcu_lfs_node {
- struct rcu_lfs_node *next;
+struct cds_lfs_node_rcu {
+ struct cds_lfs_node_rcu *next;
};
-struct rcu_lfs_stack {
- struct rcu_lfs_node *head;
+struct cds_lfs_stack_rcu {
+ struct cds_lfs_node_rcu *head;
};
#ifdef _LGPL_SOURCE
#include <urcu/rculfstack-static.h>
-#define rcu_lfs_node_init _rcu_lfs_node_init
-#define rcu_lfs_init _rcu_lfs_init
-#define rcu_lfs_push _rcu_lfs_push
-#define rcu_lfs_pop _rcu_lfs_pop
+#define cds_lfs_node_init_rcu _cds_lfs_node_init_rcu
+#define cds_lfs_init_rcu _cds_lfs_init_rcu
+#define cds_lfs_push_rcu _cds_lfs_push_rcu
+#define cds_lfs_pop_rcu _cds_lfs_pop_rcu
#else /* !_LGPL_SOURCE */
-extern void rcu_lfs_node_init(struct rcu_lfs_node *node);
-extern void rcu_lfs_init(struct rcu_lfs_stack *s);
-extern void rcu_lfs_push(struct rcu_lfs_stack *s, struct rcu_lfs_node *node);
+extern void cds_lfs_node_init_rcu(struct cds_lfs_node_rcu *node);
+extern void cds_lfs_init_rcu(struct cds_lfs_stack_rcu *s);
+extern void cds_lfs_push_rcu(struct cds_lfs_stack_rcu *s, struct cds_lfs_node_rcu *node);
/*
* The caller must wait for a grace period to pass before freeing the returned
- * node or modifying the rcu_lfs_node structure.
+ * node or modifying the cds_lfs_node_rcu structure.
* Returns NULL if stack is empty.
*/
-extern struct rcu_lfs_node *rcu_lfs_pop(struct rcu_lfs_stack *s);
+extern struct cds_lfs_node_rcu *cds_lfs_pop_rcu(struct cds_lfs_stack_rcu *s);
#endif /* !_LGPL_SOURCE */
/* Add new element at the head of the list.
*/
-static inline void list_add_rcu(list_t *newp, list_t *head)
+static inline void cds_list_add_rcu(list_t *newp, list_t *head)
{
newp->next = head->next;
newp->prev = head;
/* replace an old entry atomically.
*/
-static inline void list_replace_rcu(list_t *old, list_t *_new)
+static inline void cds_list_replace_rcu(list_t *old, list_t *_new)
{
_new->next = old->next;
_new->prev = old->prev;
}
/* Remove element from list. */
-static inline void list_del_rcu(list_t *elem)
+static inline void cds_list_del_rcu(list_t *elem)
{
elem->next->prev = elem->prev;
elem->prev->next = elem->next;
*/
/* Iterate forward over the elements of the list. */
-#define list_for_each_rcu(pos, head) \
+#define cds_list_for_each_rcu(pos, head) \
for (pos = rcu_dereference((head)->next); pos != (head); \
pos = rcu_dereference(pos->next))
/* Iterate through elements of the list.
*/
-#define list_for_each_entry_rcu(pos, head, member) \
- for (pos = list_entry(rcu_dereference((head)->next), typeof(*pos), member); \
+#define cds_list_for_each_entry_rcu(pos, head, member) \
+ for (pos = cds_list_entry(rcu_dereference((head)->next), typeof(*pos), member); \
&pos->member != (head); \
- pos = list_entry(rcu_dereference(pos->member.next), typeof(*pos), member))
+ pos = cds_list_entry(rcu_dereference(pos->member.next), typeof(*pos), member))
#endif /* _URCU_RCULIST_H */
#define WFQ_ADAPT_ATTEMPTS 10 /* Retry if being set */
#define WFQ_WAIT 10 /* Wait 10 ms if being set */
-void _wfq_node_init(struct wfq_node *node)
+void _cds_wfq_node_init(struct cds_wfq_node *node)
{
node->next = NULL;
}
-void _wfq_init(struct wfq_queue *q)
+void _cds_wfq_init(struct cds_wfq_queue *q)
{
int ret;
- _wfq_node_init(&q->dummy);
+ _cds_wfq_node_init(&q->dummy);
/* Set queue head and tail */
q->head = &q->dummy;
q->tail = &q->dummy.next;
assert(!ret);
}
-void _wfq_enqueue(struct wfq_queue *q, struct wfq_node *node)
+void _cds_wfq_enqueue(struct cds_wfq_queue *q, struct cds_wfq_node *node)
{
- struct wfq_node **old_tail;
+ struct cds_wfq_node **old_tail;
/*
* uatomic_xchg() implicit memory barrier orders earlier stores to data
* thread to be scheduled. The queue appears empty until tail->next is set by
* enqueue.
*/
-struct wfq_node *
-___wfq_dequeue_blocking(struct wfq_queue *q)
+struct cds_wfq_node *
+___cds_wfq_dequeue_blocking(struct cds_wfq_queue *q)
{
- struct wfq_node *node, *next;
+ struct cds_wfq_node *node, *next;
int attempt = 0;
/*
* Requeue dummy node if we just dequeued it.
*/
if (node == &q->dummy) {
- _wfq_node_init(node);
- _wfq_enqueue(q, node);
- return ___wfq_dequeue_blocking(q);
+ _cds_wfq_node_init(node);
+ _cds_wfq_enqueue(q, node);
+ return ___cds_wfq_dequeue_blocking(q);
}
return node;
}
-struct wfq_node *
-_wfq_dequeue_blocking(struct wfq_queue *q)
+struct cds_wfq_node *
+_cds_wfq_dequeue_blocking(struct cds_wfq_queue *q)
{
- struct wfq_node *retnode;
+ struct cds_wfq_node *retnode;
int ret;
ret = pthread_mutex_lock(&q->lock);
assert(!ret);
- retnode = ___wfq_dequeue_blocking(q);
+ retnode = ___cds_wfq_dequeue_blocking(q);
ret = pthread_mutex_unlock(&q->lock);
assert(!ret);
return retnode;
* Paul E. McKenney.
*/
-struct wfq_node {
- struct wfq_node *next;
+struct cds_wfq_node {
+ struct cds_wfq_node *next;
};
-struct wfq_queue {
- struct wfq_node *head, **tail;
- struct wfq_node dummy; /* Dummy node */
+struct cds_wfq_queue {
+ struct cds_wfq_node *head, **tail;
+ struct cds_wfq_node dummy; /* Dummy node */
pthread_mutex_t lock;
};
#include <urcu/wfqueue-static.h>
-#define wfq_node_init _wfq_node_init
-#define wfq_init _wfq_init
-#define wfq_enqueue _wfq_enqueue
-#define __wfq_dequeue_blocking ___wfq_dequeue_blocking
-#define wfq_dequeue_blocking _wfq_dequeue_blocking
+#define cds_wfq_node_init _cds_wfq_node_init
+#define cds_wfq_init _cds_wfq_init
+#define cds_wfq_enqueue _cds_wfq_enqueue
+#define __cds_wfq_dequeue_blocking ___cds_wfq_dequeue_blocking
+#define cds_wfq_dequeue_blocking _cds_wfq_dequeue_blocking
#else /* !_LGPL_SOURCE */
-extern void wfq_node_init(struct wfq_node *node);
-extern void wfq_init(struct wfq_queue *q);
-extern void wfq_enqueue(struct wfq_queue *q, struct wfq_node *node);
-/* __wfq_dequeue_blocking: caller ensures mutual exclusion between dequeues */
-extern struct wfq_node *__wfq_dequeue_blocking(struct wfq_queue *q);
-extern struct wfq_node *wfq_dequeue_blocking(struct wfq_queue *q);
+extern void cds_wfq_node_init(struct cds_wfq_node *node);
+extern void cds_wfq_init(struct cds_wfq_queue *q);
+extern void cds_wfq_enqueue(struct cds_wfq_queue *q, struct cds_wfq_node *node);
+/* __cds_wfq_dequeue_blocking: caller ensures mutual exclusion between dequeues */
+extern struct cds_wfq_node *__cds_wfq_dequeue_blocking(struct cds_wfq_queue *q);
+extern struct cds_wfq_node *cds_wfq_dequeue_blocking(struct cds_wfq_queue *q);
#endif /* !_LGPL_SOURCE */
extern "C" {
#endif
-#define WF_STACK_END ((void *)0x1UL)
-#define WFS_ADAPT_ATTEMPTS 10 /* Retry if being set */
-#define WFS_WAIT 10 /* Wait 10 ms if being set */
+#define CDS_WF_STACK_END ((void *)0x1UL)
+#define CDS_WFS_ADAPT_ATTEMPTS 10 /* Retry if being set */
+#define CDS_WFS_WAIT 10 /* Wait 10 ms if being set */
-void _wfs_node_init(struct wfs_node *node)
+void _cds_wfs_node_init(struct cds_wfs_node *node)
{
node->next = NULL;
}
-void _wfs_init(struct wfs_stack *s)
+void _cds_wfs_init(struct cds_wfs_stack *s)
{
int ret;
- s->head = WF_STACK_END;
+ s->head = CDS_WF_STACK_END;
ret = pthread_mutex_init(&s->lock, NULL);
assert(!ret);
}
-void _wfs_push(struct wfs_stack *s, struct wfs_node *node)
+void _cds_wfs_push(struct cds_wfs_stack *s, struct cds_wfs_node *node)
{
- struct wfs_node *old_head;
+ struct cds_wfs_node *old_head;
assert(node->next == NULL);
/*
/*
* Returns NULL if stack is empty.
*/
-struct wfs_node *
-___wfs_pop_blocking(struct wfs_stack *s)
+struct cds_wfs_node *
+___cds_wfs_pop_blocking(struct cds_wfs_stack *s)
{
- struct wfs_node *head, *next;
+ struct cds_wfs_node *head, *next;
int attempt = 0;
retry:
head = CAA_LOAD_SHARED(s->head);
- if (head == WF_STACK_END)
+ if (head == CDS_WF_STACK_END)
return NULL;
/*
* Adaptative busy-looping waiting for push to complete.
*/
while ((next = CAA_LOAD_SHARED(head->next)) == NULL) {
- if (++attempt >= WFS_ADAPT_ATTEMPTS) {
- poll(NULL, 0, WFS_WAIT); /* Wait for 10ms */
+ if (++attempt >= CDS_WFS_ADAPT_ATTEMPTS) {
+ poll(NULL, 0, CDS_WFS_WAIT); /* Wait for 10ms */
attempt = 0;
} else
caa_cpu_relax();
goto retry; /* Concurrent modification. Retry. */
}
-struct wfs_node *
-_wfs_pop_blocking(struct wfs_stack *s)
+struct cds_wfs_node *
+_cds_wfs_pop_blocking(struct cds_wfs_stack *s)
{
- struct wfs_node *retnode;
+ struct cds_wfs_node *retnode;
int ret;
ret = pthread_mutex_lock(&s->lock);
assert(!ret);
- retnode = ___wfs_pop_blocking(s);
+ retnode = ___cds_wfs_pop_blocking(s);
ret = pthread_mutex_unlock(&s->lock);
assert(!ret);
return retnode;
extern "C" {
#endif
-struct wfs_node {
- struct wfs_node *next;
+struct cds_wfs_node {
+ struct cds_wfs_node *next;
};
-struct wfs_stack {
- struct wfs_node *head;
+struct cds_wfs_stack {
+ struct cds_wfs_node *head;
pthread_mutex_t lock;
};
#include <urcu/wfstack-static.h>
-#define wfs_node_init _wfs_node_init
-#define wfs_init _wfs_init
-#define wfs_push _wfs_push
-#define __wfs_pop_blocking ___wfs_pop_blocking
-#define wfs_pop_blocking _wfs_pop_blocking
+#define cds_wfs_node_init _cds_wfs_node_init
+#define cds_wfs_init _cds_wfs_init
+#define cds_wfs_push _cds_wfs_push
+#define __cds_wfs_pop_blocking ___cds_wfs_pop_blocking
+#define cds_wfs_pop_blocking _cds_wfs_pop_blocking
#else /* !_LGPL_SOURCE */
-extern void wfs_node_init(struct wfs_node *node);
-extern void wfs_init(struct wfs_stack *s);
-extern void wfs_push(struct wfs_stack *s, struct wfs_node *node);
-/* __wfs_pop_blocking: caller ensures mutual exclusion between pops */
-extern struct wfs_node *__wfs_pop_blocking(struct wfs_stack *s);
-extern struct wfs_node *wfs_pop_blocking(struct wfs_stack *s);
+extern void cds_wfs_node_init(struct cds_wfs_node *node);
+extern void cds_wfs_init(struct cds_wfs_stack *s);
+extern void cds_wfs_push(struct cds_wfs_stack *s, struct cds_wfs_node *node);
+/* __cds_wfs_pop_blocking: caller ensures mutual exclusion between pops */
+extern struct cds_wfs_node *__cds_wfs_pop_blocking(struct cds_wfs_stack *s);
+extern struct cds_wfs_node *cds_wfs_pop_blocking(struct cds_wfs_stack *s);
#endif /* !_LGPL_SOURCE */
* library wrappers to be used by non-LGPL compatible source code.
*/
-void wfq_node_init(struct wfq_node *node)
+void cds_wfq_node_init(struct cds_wfq_node *node)
{
- _wfq_node_init(node);
+ _cds_wfq_node_init(node);
}
-void wfq_init(struct wfq_queue *q)
+void cds_wfq_init(struct cds_wfq_queue *q)
{
- _wfq_init(q);
+ _cds_wfq_init(q);
}
-void wfq_enqueue(struct wfq_queue *q, struct wfq_node *node)
+void cds_wfq_enqueue(struct cds_wfq_queue *q, struct cds_wfq_node *node)
{
- _wfq_enqueue(q, node);
+ _cds_wfq_enqueue(q, node);
}
-struct wfq_node *__wfq_dequeue_blocking(struct wfq_queue *q)
+struct cds_wfq_node *__cds_wfq_dequeue_blocking(struct cds_wfq_queue *q)
{
- return ___wfq_dequeue_blocking(q);
+ return ___cds_wfq_dequeue_blocking(q);
}
-struct wfq_node *wfq_dequeue_blocking(struct wfq_queue *q)
+struct cds_wfq_node *cds_wfq_dequeue_blocking(struct cds_wfq_queue *q)
{
- return _wfq_dequeue_blocking(q);
+ return _cds_wfq_dequeue_blocking(q);
}
* library wrappers to be used by non-LGPL compatible source code.
*/
-void wfs_node_init(struct wfs_node *node)
+void cds_wfs_node_init(struct cds_wfs_node *node)
{
- _wfs_node_init(node);
+ _cds_wfs_node_init(node);
}
-void wfs_init(struct wfs_stack *s)
+void cds_wfs_init(struct cds_wfs_stack *s)
{
- _wfs_init(s);
+ _cds_wfs_init(s);
}
-void wfs_push(struct wfs_stack *s, struct wfs_node *node)
+void cds_wfs_push(struct cds_wfs_stack *s, struct cds_wfs_node *node)
{
- _wfs_push(s, node);
+ _cds_wfs_push(s, node);
}
-struct wfs_node *__wfs_pop_blocking(struct wfs_stack *s)
+struct cds_wfs_node *__cds_wfs_pop_blocking(struct cds_wfs_stack *s)
{
- return ___wfs_pop_blocking(s);
+ return ___cds_wfs_pop_blocking(s);
}
-struct wfs_node *wfs_pop_blocking(struct wfs_stack *s)
+struct cds_wfs_node *cds_wfs_pop_blocking(struct cds_wfs_stack *s)
{
- return _wfs_pop_blocking(s);
+ return _cds_wfs_pop_blocking(s);
}
projects / userspace-rcu.git / commitdiff
