kern/llsync: remove module

1 files changed, 27 insertions, 27 deletions

diff --git a/kern/slist.h b/kern/slist.h
index c0dcb08..d708f38 100644
--- a/kern/slist.h
+++ b/kern/slist.h
@@ -24,8 +24,8 @@
 #include <stdbool.h>
 #include <stddef.h>
 
-#include <kern/llsync.h>
 #include <kern/macros.h>
+#include <kern/rcu.h>
 #include <kern/slist_types.h>
 
 struct slist;
@@ -303,46 +303,46 @@ for (entry = slist_first_entry(list, typeof(*entry), member),           \
  * Return the first node of a list.
  */
 static inline struct slist_node *
-slist_llsync_first(const struct slist *list)
+slist_rcu_first(const struct slist *list)
 {
-    return llsync_load_ptr(list->first);
+    return rcu_load_ptr(list->first);
 }
 
 /*
  * Return the node next to the given node.
  */
 static inline struct slist_node *
-slist_llsync_next(const struct slist_node *node)
+slist_rcu_next(const struct slist_node *node)
 {
-    return llsync_load_ptr(node->next);
+    return rcu_load_ptr(node->next);
 }
 
 /*
  * Insert a node at the head of a list.
  */
 static inline void
-slist_llsync_insert_head(struct slist *list, struct slist_node *node)
+slist_rcu_insert_head(struct slist *list, struct slist_node *node)
 {
     if (slist_empty(list)) {
         list->last = node;
     }
 
     node->next = list->first;
-    llsync_store_ptr(list->first, node);
+    rcu_store_ptr(list->first, node);
 }
 
 /*
  * Insert a node at the tail of a list.
  */
 static inline void
-slist_llsync_insert_tail(struct slist *list, struct slist_node *node)
+slist_rcu_insert_tail(struct slist *list, struct slist_node *node)
 {
     node->next = NULL;
 
     if (slist_empty(list)) {
-        llsync_store_ptr(list->first, node);
+        rcu_store_ptr(list->first, node);
     } else {
-        llsync_store_ptr(list->last->next, node);
+        rcu_store_ptr(list->last->next, node);
     }
 
     list->last = node;
@@ -354,11 +354,11 @@ slist_llsync_insert_tail(struct slist *list, struct slist_node *node)
  * The prev node must be valid.
  */
 static inline void
-slist_llsync_insert_after(struct slist *list, struct slist_node *prev,
+slist_rcu_insert_after(struct slist *list, struct slist_node *prev,
                           struct slist_node *node)
 {
     node->next = prev->next;
-    llsync_store_ptr(prev->next, node);
+    rcu_store_ptr(prev->next, node);
 
     if (list->last == prev) {
         list->last = node;
@@ -373,20 +373,20 @@ slist_llsync_insert_after(struct slist *list, struct slist_node *prev,
  * first node is removed.
  */
 static inline void
-slist_llsync_remove(struct slist *list, struct slist_node *prev)
+slist_rcu_remove(struct slist *list, struct slist_node *prev)
 {
     struct slist_node *node;
 
     if (slist_end(prev)) {
         node = list->first;
-        llsync_store_ptr(list->first, node->next);
+        rcu_store_ptr(list->first, node->next);
 
         if (list->last == node) {
             list->last = NULL;
         }
     } else {
         node = prev->next;
-        llsync_store_ptr(prev->next, node->next);
+        rcu_store_ptr(prev->next, node->next);
 
         if (list->last == node) {
             list->last = prev;
@@ -398,28 +398,28 @@ slist_llsync_remove(struct slist *list, struct slist_node *prev)
  * Macro that evaluates to the address of the structure containing the
  * given node based on the given type and member.
  */
-#define slist_llsync_entry(node, type, member) \
-    structof(llsync_load_ptr(node), type, member)
+#define slist_rcu_entry(node, type, member) \
+    structof(rcu_load_ptr(node), type, member)
 
 /*
  * Get the first entry of a list.
  */
-#define slist_llsync_first_entry(list, type, member)                    \
+#define slist_rcu_first_entry(list, type, member)                       \
 MACRO_BEGIN                                                             \
     struct slist_node *___first;                                        \
                                                                         \
-    ___first = slist_llsync_first(list);                                \
+    ___first = slist_rcu_first(list);                                   \
     slist_end(___first) ? NULL : slist_entry(___first, type, member);   \
 MACRO_END
 
 /*
  * Get the entry next to the given entry.
  */
-#define slist_llsync_next_entry(entry, member)                          \
+#define slist_rcu_next_entry(entry, member)                             \
 MACRO_BEGIN                                                             \
     struct slist_node *___next;                                         \
                                                                         \
-    ___next = slist_llsync_next(&entry->member);                        \
+    ___next = slist_rcu_next(&entry->member);                           \
     slist_end(___next)                                                  \
         ? NULL                                                          \
         : slist_entry(___next, typeof(*entry), member);                 \
@@ -428,17 +428,17 @@ MACRO_END
 /*
  * Forge a loop to process all nodes of a list.
  */
-#define slist_llsync_for_each(list, node)   \
-for (node = slist_llsync_first(list);       \
+#define slist_rcu_for_each(list, node)      \
+for (node = slist_rcu_first(list);          \
      !slist_end(node);                      \
-     node = slist_llsync_next(node))
+     node = slist_rcu_next(node))
 
 /*
  * Forge a loop to process all entries of a list.
  */
-#define slist_llsync_for_each_entry(list, entry, member)                \
-for (entry = slist_llsync_first_entry(list, typeof(*entry), member);    \
+#define slist_rcu_for_each_entry(list, entry, member)                   \
+for (entry = slist_rcu_first_entry(list, typeof(*entry), member);       \
      entry != NULL;                                                     \
-     entry = slist_llsync_next_entry(entry, member))
+     entry = slist_rcu_next_entry(entry, member))
 
 #endif /* _KERN_SLIST_H */