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

[Sharan Santhanam <sharan.santhanam@xxxxxxxxx>]

Hello Yuri,

This patch seems fine.

Reviewed-by: Sharan Santhanam <sharan.santhanam@xxxxxxxxx>

Thanks & Regards
Sharan

On 1/25/19 3:10 PM, Yuri Volchkov wrote:
> Signed-off-by: Yuri Volchkov <yuri.volchkov@xxxxxxxxx>
> ---
>   include/uk/list.h | 276 +++++++++++++++++++++++-----------------------
>   1 file changed, 138 insertions(+), 138 deletions(-)
>
> diff --git a/include/uk/list.h b/include/uk/list.h
> index bc99e755..161363a5 100644
> --- a/include/uk/list.h
> +++ b/include/uk/list.h
> @@ -38,61 +38,61 @@
>   extern "C" {
>   #endif
>   
> -#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_entry, struct list_head *new_entry)
> +uk_list_replace(struct uk_list_head *old_entry, struct uk_list_head *new_entry)
>   {
>         new_entry->next = old_entry->next;
>         new_entry->next->prev = new_entry;
> @@ -101,15 +101,15 @@ list_replace(struct list_head *old_entry, struct 
> list_head *new_entry)
>   }
>   
>   static inline void
> -list_replace_init(struct list_head *old_entry, struct list_head *new_entry)
> +uk_list_replace_init(struct uk_list_head *old_entry, struct uk_list_head 
> *new_entry)
>   {
> -       list_replace(old_entry, new_entry);
> -       INIT_LIST_HEAD(old_entry);
> +       uk_list_replace(old_entry, new_entry);
> +       UK_INIT_LIST_HEAD(old_entry);
>   }
>   
>   static inline void
> -linux_list_add(struct list_head *new_entry, struct list_head *prev,
> -    struct list_head *next)
> +__uk_list_add(struct uk_list_head *new_entry, struct uk_list_head *prev,
> +    struct uk_list_head *next)
>   {
>   
>   	next->prev = new_entry;
> @@ -119,114 +119,114 @@ linux_list_add(struct list_head *new_entry, 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_entry, struct list_head *head)
> +uk_list_add(struct uk_list_head *new_entry, struct uk_list_head *head)
>   {
>   
> -	linux_list_add(new_entry, head, head->next);
> +       __uk_list_add(new_entry, head, head->next);
>   }
>   
>   static inline void
> -list_add_tail(struct list_head *new_entry, struct list_head *head)
> +uk_list_add_tail(struct uk_list_head *new_entry, struct uk_list_head *head)
>   {
>   
> -	linux_list_add(new_entry, head->prev, head);
> +       __uk_list_add(new_entry, 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;
> @@ -237,69 +237,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);
> @@ -308,17 +308,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;
> @@ -329,7 +329,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;
> @@ -339,7 +339,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;
> @@ -351,7 +351,7 @@ hlist_add_behind(struct hlist_node *n, struct hlist_node 
> *prev)
>   }
>   
>   static inline void
> -hlist_move_list(struct hlist_head *old_entry, struct hlist_head *new_entry)
> +uk_hlist_move_list(struct uk_hlist_head *old_entry, struct uk_hlist_head 
> *new_entry)
>   {
>   
>   	new_entry->first = old_entry->first;
> @@ -360,15 +360,15 @@ hlist_move_list(struct hlist_head *old_entry, struct 
> hlist_head *new_entry)
>         old_entry->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;
> @@ -377,55 +377,55 @@ 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))
>   
>   #ifdef __cplusplus
>   }
_______________________________________________
Minios-devel mailing list
Minios-devel@xxxxxxxxxxxxxxxxxxxx
https://lists.xenproject.org/mailman/listinfo/minios-devel