[Minios-devel] [UNIKRAFT PATCH 07/11] include/uk/list: prefix imported functions with uk_

[Yuri Volchkov <yuri.volchkov@xxxxxxxxx>]

Signed-off-by: Yuri Volchkov <yuri.volchkov@xxxxxxxxx>
---
 include/uk/list.h | 280 +++++++++++++++++++++++-----------------------
 1 file changed, 140 insertions(+), 140 deletions(-)

diff --git a/include/uk/list.h b/include/uk/list.h
index 2ea27da..265c371 100644
--- a/include/uk/list.h
+++ b/include/uk/list.h
@@ -35,61 +35,61 @@
 #include <stddef.h>
 
 
-#define LINUX_LIST_HEAD_INIT(name) { &(name), &(name) }
+#define UK_LIST_HEAD_INIT(name) { &(name), &(name) }
 
-#define LINUX_LIST_HEAD(name) \
-       struct list_head name = LINUX_LIST_HEAD_INIT(name)
+#define UK_LIST_HEAD(name) \
+       struct uk_list_head name = UK_LIST_HEAD_INIT(name)
 
-struct list_head {
-       struct list_head *next;
-       struct list_head *prev;
+struct uk_list_head {
+       struct uk_list_head *next;
+       struct uk_list_head *prev;
 };
 
 static inline void
-INIT_LIST_HEAD(struct list_head *list)
+UK_INIT_LIST_HEAD(struct uk_list_head *list)
 {
 
        list->next = list->prev = list;
 }
 
 static inline int
-list_empty(const struct list_head *head)
+uk_list_empty(const struct uk_list_head *head)
 {
 
        return (head->next == head);
 }
 
 static inline int
-list_empty_careful(const struct list_head *head)
+uk_list_empty_careful(const struct uk_list_head *head)
 {
-       struct list_head *next = head->next;
+       struct uk_list_head *next = head->next;
 
        return ((next == head) && (next == head->prev));
 }
 
 static inline void
-__list_del(struct list_head *prev, struct list_head *next)
+__uk_list_del(struct uk_list_head *prev, struct uk_list_head *next)
 {
        next->prev = prev;
        UK_WRITE_ONCE(prev->next, next);
 }
 
 static inline void
-__list_del_entry(struct list_head *entry)
+__uk_list_del_entry(struct uk_list_head *entry)
 {
 
-       __list_del(entry->prev, entry->next);
+       __uk_list_del(entry->prev, entry->next);
 }
 
 static inline void
-list_del(struct list_head *entry)
+uk_list_del(struct uk_list_head *entry)
 {
 
-       __list_del(entry->prev, entry->next);
+       __uk_list_del(entry->prev, entry->next);
 }
 
 static inline void
-list_replace(struct list_head *old, struct list_head *new)
+uk_list_replace(struct uk_list_head *old, struct uk_list_head *new)
 {
        new->next = old->next;
        new->next->prev = new;
@@ -98,15 +98,15 @@ list_replace(struct list_head *old, struct list_head *new)
 }
 
 static inline void
-list_replace_init(struct list_head *old, struct list_head *new)
+uk_list_replace_init(struct uk_list_head *old, struct uk_list_head *new)
 {
-       list_replace(old, new);
-       INIT_LIST_HEAD(old);
+       uk_list_replace(old, new);
+       UK_INIT_LIST_HEAD(old);
 }
 
 static inline void
-linux_list_add(struct list_head *new, struct list_head *prev,
-    struct list_head *next)
+__uk_list_add(struct uk_list_head *new, struct uk_list_head *prev,
+    struct uk_list_head *next)
 {
 
        next->prev = new;
@@ -116,114 +116,114 @@ linux_list_add(struct list_head *new, struct list_head 
*prev,
 }
 
 static inline void
-list_del_init(struct list_head *entry)
+uk_list_del_init(struct uk_list_head *entry)
 {
 
-       list_del(entry);
-       INIT_LIST_HEAD(entry);
+       uk_list_del(entry);
+       UK_INIT_LIST_HEAD(entry);
 }
 
-#define        list_entry(ptr, type, field)    __containerof(ptr, type, field)
+#define        uk_list_entry(ptr, type, field) __containerof(ptr, type, field)
 
-#define        list_first_entry(ptr, type, member) \
-       list_entry((ptr)->next, type, member)
+#define        uk_list_first_entry(ptr, type, member) \
+       uk_list_entry((ptr)->next, type, member)
 
-#define        list_last_entry(ptr, type, member)      \
-       list_entry((ptr)->prev, type, member)
+#define        uk_list_last_entry(ptr, type, member)   \
+       uk_list_entry((ptr)->prev, type, member)
 
-#define        list_first_entry_or_null(ptr, type, member) \
-       (!list_empty(ptr) ? list_first_entry(ptr, type, member) : NULL)
+#define        uk_list_first_entry_or_null(ptr, type, member) \
+       (!uk_list_empty(ptr) ? uk_list_first_entry(ptr, type, member) : NULL)
 
-#define        list_next_entry(ptr, member)                                    
\
-       list_entry(((ptr)->member.next), typeof(*(ptr)), member)
+#define        uk_list_next_entry(ptr, member)                                 
\
+       uk_list_entry(((ptr)->member.next), typeof(*(ptr)), member)
 
-#define        list_safe_reset_next(ptr, n, member) \
-       (n) = list_next_entry(ptr, member)
+#define        uk_list_safe_reset_next(ptr, n, member) \
+       (n) = uk_list_next_entry(ptr, member)
 
-#define        list_prev_entry(ptr, member)                                    
\
-       list_entry(((ptr)->member.prev), typeof(*(ptr)), member)
+#define        uk_list_prev_entry(ptr, member)                                 
\
+       uk_list_entry(((ptr)->member.prev), typeof(*(ptr)), member)
 
-#define        list_for_each(p, head)                                          
\
+#define        uk_list_for_each(p, head)                                       
        \
        for (p = (head)->next; p != (head); p = (p)->next)
 
-#define        list_for_each_safe(p, n, head)                                  
\
+#define        uk_list_for_each_safe(p, n, head)                               
        \
        for (p = (head)->next, n = (p)->next; p != (head); p = n, n = (p)->next)
 
-#define list_for_each_entry(p, h, field)                               \
-       for (p = list_entry((h)->next, typeof(*p), field); &(p)->field != (h); \
-           p = list_entry((p)->field.next, typeof(*p), field))
+#define uk_list_for_each_entry(p, h, field)                            \
+       for (p = uk_list_entry((h)->next, typeof(*p), field); &(p)->field != 
(h); \
+           p = uk_list_entry((p)->field.next, typeof(*p), field))
 
-#define list_for_each_entry_safe(p, n, h, field)                       \
-       for (p = list_entry((h)->next, typeof(*p), field),              \
-           n = list_entry((p)->field.next, typeof(*p), field); &(p)->field != 
(h);\
-           p = n, n = list_entry(n->field.next, typeof(*n), field))
+#define uk_list_for_each_entry_safe(p, n, h, field)                    \
+       for (p = uk_list_entry((h)->next, typeof(*p), field),           \
+           n = uk_list_entry((p)->field.next, typeof(*p), field); &(p)->field 
!= (h);\
+           p = n, n = uk_list_entry(n->field.next, typeof(*n), field))
 
-#define        list_for_each_entry_from(p, h, field) \
+#define        uk_list_for_each_entry_from(p, h, field) \
        for ( ; &(p)->field != (h); \
-           p = list_entry((p)->field.next, typeof(*p), field))
+           p = uk_list_entry((p)->field.next, typeof(*p), field))
 
-#define        list_for_each_entry_continue(p, h, field)                       
\
-       for (p = list_next_entry((p), field); &(p)->field != (h);       \
-           p = list_next_entry((p), field))
+#define        uk_list_for_each_entry_continue(p, h, field)                    
\
+       for (p = uk_list_next_entry((p), field); &(p)->field != (h);    \
+           p = uk_list_next_entry((p), field))
 
-#define        list_for_each_entry_safe_from(pos, n, head, member)             
        \
-       for (n = list_entry((pos)->member.next, typeof(*pos), member);          
\
+#define        uk_list_for_each_entry_safe_from(pos, n, head, member)          
        \
+       for (n = uk_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 = uk_list_entry(n->member.next, typeof(*n), member))
 
-#define        list_for_each_entry_reverse(p, h, field)                        
\
-       for (p = list_entry((h)->prev, typeof(*p), field); &(p)->field != (h); \
-           p = list_entry((p)->field.prev, typeof(*p), field))
+#define        uk_list_for_each_entry_reverse(p, h, field)                     
\
+       for (p = uk_list_entry((h)->prev, typeof(*p), field); &(p)->field != 
(h); \
+           p = uk_list_entry((p)->field.prev, typeof(*p), field))
 
-#define        list_for_each_entry_safe_reverse(p, n, h, field)                
\
-       for (p = list_entry((h)->prev, typeof(*p), field),              \
-           n = list_entry((p)->field.prev, typeof(*p), field); &(p)->field != 
(h); \
-           p = n, n = list_entry(n->field.prev, typeof(*n), field))
+#define        uk_list_for_each_entry_safe_reverse(p, n, h, field)             
\
+       for (p = uk_list_entry((h)->prev, typeof(*p), field),           \
+           n = uk_list_entry((p)->field.prev, typeof(*p), field); &(p)->field 
!= (h); \
+           p = n, n = uk_list_entry(n->field.prev, typeof(*n), field))
 
-#define        list_for_each_entry_continue_reverse(p, h, field) \
-       for (p = list_entry((p)->field.prev, typeof(*p), field); &(p)->field != 
(h); \
-           p = list_entry((p)->field.prev, typeof(*p), field))
+#define        uk_list_for_each_entry_continue_reverse(p, h, field) \
+       for (p = uk_list_entry((p)->field.prev, typeof(*p), field); &(p)->field 
!= (h); \
+           p = uk_list_entry((p)->field.prev, typeof(*p), field))
 
-#define        list_for_each_prev(p, h) for (p = (h)->prev; p != (h); p = 
(p)->prev)
+#define        uk_list_for_each_prev(p, h) for (p = (h)->prev; p != (h); p = 
(p)->prev)
 
 static inline void
-list_add(struct list_head *new, struct list_head *head)
+uk_list_add(struct uk_list_head *new, struct uk_list_head *head)
 {
 
-       linux_list_add(new, head, head->next);
+       __uk_list_add(new, head, head->next);
 }
 
 static inline void
-list_add_tail(struct list_head *new, struct list_head *head)
+uk_list_add_tail(struct uk_list_head *new, struct uk_list_head *head)
 {
 
-       linux_list_add(new, head->prev, head);
+       __uk_list_add(new, head->prev, head);
 }
 
 static inline void
-list_move(struct list_head *list, struct list_head *head)
+uk_list_move(struct uk_list_head *list, struct uk_list_head *head)
 {
 
-       list_del(list);
-       list_add(list, head);
+       uk_list_del(list);
+       uk_list_add(list, head);
 }
 
 static inline void
-list_move_tail(struct list_head *entry, struct list_head *head)
+uk_list_move_tail(struct uk_list_head *entry, struct uk_list_head *head)
 {
 
-       list_del(entry);
-       list_add_tail(entry, head);
+       uk_list_del(entry);
+       uk_list_add_tail(entry, head);
 }
 
 static inline void
-linux_list_splice(const struct list_head *list, struct list_head *prev,
-    struct list_head *next)
+__uk_list_splice(const struct uk_list_head *list, struct uk_list_head *prev,
+    struct uk_list_head *next)
 {
-       struct list_head *first;
-       struct list_head *last;
+       struct uk_list_head *first;
+       struct uk_list_head *last;
 
-       if (list_empty(list))
+       if (uk_list_empty(list))
                return;
        first = list->next;
        last = list->prev;
@@ -234,69 +234,69 @@ linux_list_splice(const struct list_head *list, struct 
list_head *prev,
 }
 
 static inline void
-list_splice(const struct list_head *list, struct list_head *head)
+uk_list_splice(const struct uk_list_head *list, struct uk_list_head *head)
 {
 
-       linux_list_splice(list, head, head->next);
+       __uk_list_splice(list, head, head->next);
 }
 
 static inline void
-list_splice_tail(struct list_head *list, struct list_head *head)
+uk_list_splice_tail(struct uk_list_head *list, struct uk_list_head *head)
 {
 
-       linux_list_splice(list, head->prev, head);
+       __uk_list_splice(list, head->prev, head);
 }
 
 static inline void
-list_splice_init(struct list_head *list, struct list_head *head)
+uk_list_splice_init(struct uk_list_head *list, struct uk_list_head *head)
 {
 
-       linux_list_splice(list, head, head->next);
-       INIT_LIST_HEAD(list);
+       __uk_list_splice(list, head, head->next);
+       UK_INIT_LIST_HEAD(list);
 }
 
 static inline void
-list_splice_tail_init(struct list_head *list, struct list_head *head)
+uk_list_splice_tail_init(struct uk_list_head *list, struct uk_list_head *head)
 {
 
-       linux_list_splice(list, head->prev, head);
-       INIT_LIST_HEAD(list);
+       __uk_list_splice(list, head->prev, head);
+       UK_INIT_LIST_HEAD(list);
 }
 
 
-struct hlist_head {
-       struct hlist_node *first;
+struct uk_hlist_head {
+       struct uk_hlist_node *first;
 };
 
-struct hlist_node {
-       struct hlist_node *next, **pprev;
+struct uk_hlist_node {
+       struct uk_hlist_node *next, **pprev;
 };
 
-#define        HLIST_HEAD_INIT { }
-#define        HLIST_HEAD(name) struct hlist_head name = HLIST_HEAD_INIT
-#define        INIT_HLIST_HEAD(head) (head)->first = NULL
-#define        INIT_HLIST_NODE(node)                                           
\
+#define        UK_HLIST_HEAD_INIT { }
+#define        UK_HLIST_HEAD(name) struct uk_hlist_head name = 
UK_HLIST_HEAD_INIT
+#define        UK_INIT_HLIST_HEAD(head) (head)->first = NULL
+#define        UK_INIT_HLIST_NODE(node)                                        
\
 do {                                                                   \
        (node)->next = NULL;                                            \
        (node)->pprev = NULL;                                           \
 } while (0)
 
 static inline int
-hlist_unhashed(const struct hlist_node *h)
+uk_hlist_unhashed(const struct uk_hlist_node *h)
 {
 
        return !h->pprev;
 }
 
 static inline int
-hlist_empty(const struct hlist_head *h)
+uk_hlist_empty(const struct uk_hlist_head *h)
 {
 
        return !UK_READ_ONCE(h->first);
 }
 
 static inline void
-hlist_del(struct hlist_node *n)
+uk_hlist_del(struct uk_hlist_node *n)
 {
 
        UK_WRITE_ONCE(*(n->pprev), n->next);
@@ -305,17 +305,17 @@ hlist_del(struct hlist_node *n)
 }
 
 static inline void
-hlist_del_init(struct hlist_node *n)
+uk_hlist_del_init(struct uk_hlist_node *n)
 {
 
-       if (hlist_unhashed(n))
+       if (uk_hlist_unhashed(n))
                return;
-       hlist_del(n);
-       INIT_HLIST_NODE(n);
+       uk_hlist_del(n);
+       UK_INIT_HLIST_NODE(n);
 }
 
 static inline void
-hlist_add_head(struct hlist_node *n, struct hlist_head *h)
+uk_hlist_add_head(struct uk_hlist_node *n, struct uk_hlist_head *h)
 {
 
        n->next = h->first;
@@ -326,7 +326,7 @@ hlist_add_head(struct hlist_node *n, struct hlist_head *h)
 }
 
 static inline void
-hlist_add_before(struct hlist_node *n, struct hlist_node *next)
+uk_hlist_add_before(struct uk_hlist_node *n, struct uk_hlist_node *next)
 {
 
        n->pprev = next->pprev;
@@ -336,7 +336,7 @@ hlist_add_before(struct hlist_node *n, struct hlist_node 
*next)
 }
 
 static inline void
-hlist_add_behind(struct hlist_node *n, struct hlist_node *prev)
+uk_hlist_add_behind(struct uk_hlist_node *n, struct uk_hlist_node *prev)
 {
 
        n->next = prev->next;
@@ -348,7 +348,7 @@ hlist_add_behind(struct hlist_node *n, struct hlist_node 
*prev)
 }
 
 static inline void
-hlist_move_list(struct hlist_head *old, struct hlist_head *new)
+uk_hlist_move_list(struct uk_hlist_head *old, struct uk_hlist_head *new)
 {
 
        new->first = old->first;
@@ -357,15 +357,15 @@ hlist_move_list(struct hlist_head *old, struct hlist_head 
*new)
        old->first = NULL;
 }
 
-static inline int list_is_singular(const struct list_head *head)
+static inline int uk_list_is_singular(const struct uk_list_head *head)
 {
-       return !list_empty(head) && (head->next == head->prev);
+       return !uk_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 __uk_list_cut_position(struct uk_list_head *list,
+               struct uk_list_head *head, struct uk_list_head *entry)
 {
-       struct list_head *new_first = entry->next;
+       struct uk_list_head *new_first = entry->next;
        list->next = head->next;
        list->next->prev = list;
        list->prev = entry;
@@ -374,58 +374,58 @@ static inline void __list_cut_position(struct list_head 
*list,
        new_first->prev = head;
 }
 
-static inline void list_cut_position(struct list_head *list,
-               struct list_head *head, struct list_head *entry)
+static inline void uk_list_cut_position(struct uk_list_head *list,
+               struct uk_list_head *head, struct uk_list_head *entry)
 {
-       if (list_empty(head))
+       if (uk_list_empty(head))
                return;
-       if (list_is_singular(head) &&
+       if (uk_list_is_singular(head) &&
                (head->next != entry && head != entry))
                return;
        if (entry == head)
-               INIT_LIST_HEAD(list);
+               UK_INIT_LIST_HEAD(list);
        else
-               __list_cut_position(list, head, entry);
+               __uk_list_cut_position(list, head, entry);
 }
 
-static inline int list_is_last(const struct list_head *list,
-                               const struct list_head *head)
+static inline int uk_list_is_last(const struct uk_list_head *list,
+                               const struct uk_list_head *head)
 {
        return list->next == head;
 }
 
-#define        hlist_entry(ptr, type, field)   __containerof(ptr, type, field)
+#define        uk_hlist_entry(ptr, type, field)        __containerof(ptr, 
type, field)
 
-#define        hlist_for_each(p, head)                                         
\
+#define        uk_hlist_for_each(p, head)                                      
        \
        for (p = (head)->first; p; p = (p)->next)
 
-#define        hlist_for_each_safe(p, n, head)                                 
\
+#define        uk_hlist_for_each_safe(p, n, head)                              
        \
        for (p = (head)->first; p && ({ n = (p)->next; 1; }); p = n)
 
-#define        hlist_entry_safe(ptr, type, member) \
-       ((ptr) ? hlist_entry(ptr, type, member) : NULL)
+#define        uk_hlist_entry_safe(ptr, type, member) \
+       ((ptr) ? uk_hlist_entry(ptr, type, member) : NULL)
 
-#define        hlist_for_each_entry(pos, head, member)                         
\
-       for (pos = hlist_entry_safe((head)->first, typeof(*(pos)), member);\
+#define        uk_hlist_for_each_entry(pos, head, member)                      
        \
+       for (pos = uk_hlist_entry_safe((head)->first, typeof(*(pos)), member);\
             pos;                                                       \
-            pos = hlist_entry_safe((pos)->member.next, typeof(*(pos)), member))
+            pos = uk_hlist_entry_safe((pos)->member.next, typeof(*(pos)), 
member))
 
-#define        hlist_for_each_entry_continue(pos, member)                      
\
-       for (pos = hlist_entry_safe((pos)->member.next, typeof(*(pos)), 
member); \
+#define        uk_hlist_for_each_entry_continue(pos, member)                   
\
+       for (pos = uk_hlist_entry_safe((pos)->member.next, typeof(*(pos)), 
member); \
             (pos);                                                     \
-            pos = hlist_entry_safe((pos)->member.next, typeof(*(pos)), member))
+            pos = uk_hlist_entry_safe((pos)->member.next, typeof(*(pos)), 
member))
 
-#define        hlist_for_each_entry_from(pos, member)                          
\
+#define        uk_hlist_for_each_entry_from(pos, member)                       
        \
        for (; (pos);                                                           
\
-            pos = hlist_entry_safe((pos)->member.next, typeof(*(pos)), member))
+            pos = uk_hlist_entry_safe((pos)->member.next, typeof(*(pos)), 
member))
 
-#define        hlist_for_each_entry_safe(pos, n, head, member)                 
\
-       for (pos = hlist_entry_safe((head)->first, typeof(*(pos)), member); \
+#define        uk_hlist_for_each_entry_safe(pos, n, head, member)              
        \
+       for (pos = uk_hlist_entry_safe((head)->first, typeof(*(pos)), member); \
             (pos) && ({ n = (pos)->member.next; 1; });                 \
-            pos = hlist_entry_safe(n, typeof(*(pos)), member))
+            pos = uk_hlist_entry_safe(n, typeof(*(pos)), member))
 
-extern void list_sort(void *priv, struct list_head *head, int (*cmp)(void 
*priv,
-    struct list_head *a, struct list_head *b));
+extern void list_sort(void *priv, struct uk_list_head *head, int (*cmp)(void 
*priv,
+    struct uk_list_head *a, struct uk_list_head *b));
 
 /* TODO: get rid of the old linked list implementation */
 #include <uk/compat_list.h>
-- 
2.19.2


_______________________________________________
Minios-devel mailing list
Minios-devel@xxxxxxxxxxxxxxxxxxxx
https://lists.xenproject.org/mailman/listinfo/minios-devel