Archipelago » blktap-utils

/*

 * list.h

 * 

 * This is a subset of linux's list.h intended to be used in user-space.

 * 

 */

#ifndef __LIST_H__

#define __LIST_H__

#include <stddef.h>

#define containerof(_ptr, _type, _memb) \

        ((_type*)((void*)(_ptr) - offsetof(_type, _memb)))

#define LIST_POISON1  ((void *) 0x00100100)

#define LIST_POISON2  ((void *) 0x00200200)

struct list_head {

        struct list_head *next, *prev;

};

#define LIST_HEAD_INIT(name) { &(name), &(name) }

#define LIST_HEAD(name) \

        struct list_head name = LIST_HEAD_INIT(name)

static inline void INIT_LIST_HEAD(struct list_head *list)

{

        list->next = list;

        list->prev = list;

}

static inline void __list_add(struct list_head *new,

                              struct list_head *prev,

                              struct list_head *next)

{

        next->prev = new;

        new->next = next;

        new->prev = prev;

        prev->next = new;

}

static inline void list_add(struct list_head *new, struct list_head *head)

{

        __list_add(new, head, head->next);

}

static inline void list_add_tail(struct list_head *new, struct list_head *head)

{

        __list_add(new, head->prev, head);

}

static inline void __list_del(struct list_head * prev, struct list_head * next)

{

        next->prev = prev;

        prev->next = next;

}

static inline void list_del(struct list_head *entry)

{

        __list_del(entry->prev, entry->next);

        entry->next = (struct list_head *)LIST_POISON1;

        entry->prev = (struct list_head *)LIST_POISON2;

}

static inline void list_del_init(struct list_head *entry)

{

        __list_del(entry->prev, entry->next);

        INIT_LIST_HEAD(entry);

}

static inline void list_move(struct list_head *list, struct list_head *head)

{

        __list_del(list->prev, list->next);

        list_add(list, head);

}

static inline void list_move_tail(struct list_head *list,

                                  struct list_head *head)

{

        __list_del(list->prev, list->next);

        list_add_tail(list, head);

}

static inline int list_empty(const struct list_head *head)

{

        return head->next == head;

}

static inline int list_is_last(const struct list_head *list,

                               const struct list_head *head)

{

        return list->next == head;

}

static inline void __list_splice(const struct list_head *list,

                                 struct list_head *prev,

                                 struct list_head *next)

{

        struct list_head *first = list->next;

        struct list_head *last = list->prev;

        first->prev = prev;

        prev->next = first;

        last->next = next;

        next->prev = last;

}

static inline void list_splice(const struct list_head *list,

                               struct list_head *head)

{

        if (!list_empty(list))

                __list_splice(list, head, head->next);

}

static inline void list_splice_tail(struct list_head *list,

                                    struct list_head *head)

{

        if (!list_empty(list))

                __list_splice(list, head->prev, head);

}

#define list_entry(_ptr, _type, _memb) containerof(_ptr, _type, _memb)

#define list_for_each_entry(pos, head, member)                          \

        for (pos = list_entry((head)->next, typeof(*pos), member);      \

             &pos->member != (head);                                    \

             pos = list_entry(pos->member.next, typeof(*pos), member))

#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);        \

             &pos->member != (head);                                        \

             pos = n, n = list_entry(n->member.next, typeof(*n), member))

#define list_for_each_entry_reverse(pos, head, member)                        \

        for (pos = list_entry((head)->prev, typeof(*pos), member);        \

             &pos->member != (head);                                        \

             pos = list_entry(pos->member.prev, typeof(*pos), member))

#define list_for_each_entry_continue(pos, head, member)                \

        for (pos = list_entry(pos->member.next, typeof(*pos), member);        \

             &pos->member != (head);                                        \

             pos = list_entry(pos->member.next, typeof(*pos), member))

#endif /* __LIST_H__ */