Linked list

include/structures/list.h

struct list_head

struct list_head {
    struct list_head  *next;
};

struct list_head referenced types:

• struct list_head

INIT_LIST_HEAD

void INIT_LIST_HEAD(struct list_head *list);

INIT_LIST_HEAD referenced types:

• struct list_head

__list_add

void __list_add(struct list_head *new, struct list_head *prev, struct list_head *next);

__list_add referenced types:

• struct list_head

list_add

void list_add(struct list_head *new, struct list_head *head);

list_add referenced types:

• struct list_head

list_add_tail

void list_add_tail(struct list_head *new, struct list_head *head);

list_add_tail referenced types:

• struct list_head

__list_del

void __list_del(struct list_head *prev, struct list_head *next);

__list_del referenced types:

• struct list_head

list_del

void list_del(struct list_head *entry);

list_del referenced types:

• struct list_head

list_del_init

void list_del_init(struct list_head *entry);

list_del_init referenced types:

• struct list_head

list_empty

int list_empty(struct list_head *head);

list_empty referenced types:

• struct list_head

list_pop_front

struct list_head list_pop_front(struct list_head *head);

list_pop_front referenced types:

• struct list_head

list_pop_front_init

struct list_head list_pop_front_init(struct list_head *head);

list_pop_front_init referenced types:

• struct list_head

__list_splice

void __list_splice(struct list_head *list, struct list_head *prev, struct list_head *next);

__list_splice referenced types:

• struct list_head

list_splice_init

void list_splice_init(struct list_head *src, struct list_head *dst);

list_splice_init referenced types:

• struct list_head

list_splice_tail_init

void list_splice_tail_init(struct list_head *list, struct list_head *head);

list_splice_tail_init referenced types:

• struct list_head

Defines

LIST_HEAD_INIT(name)

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

LIST_HEAD(name)

#define LIST_HEAD(name) struct list_head name = LIST_HEAD_INIT(name)

list_entry(ptr, type, member)

#define list_entry(ptr, type, member)                                          \ ((type *) ((char *) (ptr) - (offsetof(type, member))))

list_for_each(pos, head)

#define list_for_each(pos, head)                                               \ for (pos = (head)->next; pos != (head); pos = pos->next)

list_for_each_safe(pos, n, head)

#define list_for_each_safe(pos, n, head)                                       \ for (pos = (head)->next, n = pos->next; pos != (head);                     \ pos = n, n = pos->next)

list_for_each_entry(pos, head, member)

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

list_first_entry(ptr, type, member)

#define list_first_entry(ptr, type, member)                                    \ list_entry((ptr)->next, type, member)

list_for_each_entry_safe(pos, n, head, 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))

list_for_each_entry_safe_continue(pos, n, head, member)

#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);                \ &pos->member != (head);                                               \ pos = n, n = list_entry(n->member.next, typeof(*n), member))

SLIST_HEAD(name, type)

#define SLIST_HEAD(name, type)                                                 \ struct name {                                                              \ struct type *slh_first;                                                \ }

SLIST_EMPTY(head)

#define SLIST_EMPTY(head) ((head)->slh_first == NULL)

SLIST_HEAD_INIT(head)

#define SLIST_HEAD_INIT(head) {.slh_first = NULL}

SLIST_INIT(head)

#define SLIST_INIT(head)                                                       \ do {                                                                       \ (head)->slh_first = NULL;                                              \ } while (0)

SLIST_ENTRY(type)

#define SLIST_ENTRY(type)                                                      \ struct {                                                                   \ struct type *sle_next;                                                 \ }

SLIST_FIRST(head)

#define SLIST_FIRST(head) ((head)->slh_first)

SLIST_NEXT(elm, field)

#define SLIST_NEXT(elm, field) ((elm)->field.sle_next)

SLIST_INSERT_HEAD(head, elm, field)

#define SLIST_INSERT_HEAD(head, elm, field)                                    \ do {                                                                       \ (elm)->field.sle_next = (head)->slh_first;                             \ (head)->slh_first = (elm);                                             \ } while (0)

SLIST_REMOVE_HEAD(head, field)

#define SLIST_REMOVE_HEAD(head, field)                                         \ do {                                                                       \ (head)->slh_first = (head)->slh_first->field.sle_next;                 \ } while (0)

SLIST_FOREACH(var, head, field)

#define SLIST_FOREACH(var, head, field)                                        \ for ((var) = (head)->slh_first; (var); (var) = (var)->field.sle_next)

---