diff options
Diffstat (limited to 'libglusterfs/src/list.h')
-rw-r--r-- | libglusterfs/src/list.h | 276 |
1 files changed, 131 insertions, 145 deletions
diff --git a/libglusterfs/src/list.h b/libglusterfs/src/list.h index b8f9a6eebd8..221a710ca30 100644 --- a/libglusterfs/src/list.h +++ b/libglusterfs/src/list.h @@ -11,40 +11,36 @@ #ifndef _LLIST_H #define _LLIST_H - struct list_head { - struct list_head *next; - struct list_head *prev; + struct list_head *next; + struct list_head *prev; }; - -#define INIT_LIST_HEAD(head) do { \ - (head)->next = (head)->prev = head; \ - } while (0) - +#define INIT_LIST_HEAD(head) \ + do { \ + (head)->next = (head)->prev = head; \ + } while (0) static inline void -list_add (struct list_head *new, struct list_head *head) +list_add(struct list_head *new, struct list_head *head) { - new->prev = head; - new->next = head->next; + new->prev = head; + new->next = head->next; - new->prev->next = new; - new->next->prev = new; + new->prev->next = new; + new->next->prev = new; } - static inline void -list_add_tail (struct list_head *new, struct list_head *head) +list_add_tail(struct list_head *new, struct list_head *head) { - new->next = head; - new->prev = head->prev; + new->next = head; + new->prev = head->prev; - new->prev->next = new; - new->next->prev = new; + new->prev->next = new; + new->next->prev = new; } - /* This function will insert the element to the list in a order. Order will be based on the compare function provided as a input. If element to be inserted in ascending order compare should return: @@ -52,143 +48,133 @@ list_add_tail (struct list_head *new, struct list_head *head) >0: if first argument is greater than second argument <0: if first argument is less than second argument */ static inline void -list_add_order (struct list_head *new, struct list_head *head, - int (*compare)(struct list_head *, struct list_head *)) +list_add_order(struct list_head *new, struct list_head *head, + int (*compare)(struct list_head *, struct list_head *)) { - struct list_head *pos = head->prev; + struct list_head *pos = head->prev; - while ( pos != head ) { - if (compare(new, pos) >= 0) - break; + while (pos != head) { + if (compare(new, pos) >= 0) + break; - /* Iterate the list in the reverse order. This will have - better efficiency if the elements are inserted in the - ascending order */ - pos = pos->prev; - } + /* Iterate the list in the reverse order. This will have + better efficiency if the elements are inserted in the + ascending order */ + pos = pos->prev; + } - list_add (new, pos); + list_add(new, pos); } static inline void -list_del (struct list_head *old) +list_del(struct list_head *old) { - old->prev->next = old->next; - old->next->prev = old->prev; + old->prev->next = old->next; + old->next->prev = old->prev; - old->next = (void *)0xbabebabe; - old->prev = (void *)0xcafecafe; + old->next = (void *)0xbabebabe; + old->prev = (void *)0xcafecafe; } - static inline void -list_del_init (struct list_head *old) +list_del_init(struct list_head *old) { - old->prev->next = old->next; - old->next->prev = old->prev; + old->prev->next = old->next; + old->next->prev = old->prev; - old->next = old; - old->prev = old; + old->next = old; + old->prev = old; } - static inline void -list_move (struct list_head *list, struct list_head *head) +list_move(struct list_head *list, struct list_head *head) { - list_del (list); - list_add (list, head); + list_del(list); + list_add(list, head); } - static inline void -list_move_tail (struct list_head *list, struct list_head *head) +list_move_tail(struct list_head *list, struct list_head *head) { - list_del (list); - list_add_tail (list, head); + list_del(list); + list_add_tail(list, head); } - static inline int -list_empty (struct list_head *head) +list_empty(struct list_head *head) { - return (head->next == head); + return (head->next == head); } - static inline void -__list_splice (struct list_head *list, struct list_head *head) +__list_splice(struct list_head *list, struct list_head *head) { - (list->prev)->next = (head->next); - (head->next)->prev = (list->prev); + (list->prev)->next = (head->next); + (head->next)->prev = (list->prev); - (head)->next = (list->next); - (list->next)->prev = (head); + (head)->next = (list->next); + (list->next)->prev = (head); } - static inline void -list_splice (struct list_head *list, struct list_head *head) +list_splice(struct list_head *list, struct list_head *head) { - if (list_empty (list)) - return; + if (list_empty(list)) + return; - __list_splice (list, head); + __list_splice(list, head); } - /* Splice moves @list to the head of the list at @head. */ static inline void -list_splice_init (struct list_head *list, struct list_head *head) +list_splice_init(struct list_head *list, struct list_head *head) { - if (list_empty (list)) - return; + if (list_empty(list)) + return; - __list_splice (list, head); - INIT_LIST_HEAD (list); + __list_splice(list, head); + INIT_LIST_HEAD(list); } - static inline void -__list_append (struct list_head *list, struct list_head *head) +__list_append(struct list_head *list, struct list_head *head) { - (head->prev)->next = (list->next); - (list->next)->prev = (head->prev); - (head->prev) = (list->prev); - (list->prev)->next = head; + (head->prev)->next = (list->next); + (list->next)->prev = (head->prev); + (head->prev) = (list->prev); + (list->prev)->next = head; } - static inline void -list_append (struct list_head *list, struct list_head *head) +list_append(struct list_head *list, struct list_head *head) { - if (list_empty (list)) - return; + if (list_empty(list)) + return; - __list_append (list, head); + __list_append(list, head); } - /* Append moves @list to the end of @head */ static inline void -list_append_init (struct list_head *list, struct list_head *head) +list_append_init(struct list_head *list, struct list_head *head) { - if (list_empty (list)) - return; + if (list_empty(list)) + return; - __list_append (list, head); - INIT_LIST_HEAD (list); + __list_append(list, head); + INIT_LIST_HEAD(list); } static inline int -list_is_last (struct list_head *list, struct list_head *head) +list_is_last(struct list_head *list, struct list_head *head) { - return (list->next == head); + return (list->next == head); } static inline int list_is_singular(struct list_head *head) { - return !list_empty(head) && (head->next == head->prev); + return !list_empty(head) && (head->next == head->prev); } /** @@ -198,77 +184,75 @@ list_is_singular(struct list_head *head) * * If @old was empty, it will be overwritten. */ -static inline void list_replace(struct list_head *old, - struct list_head *new) +static inline void +list_replace(struct list_head *old, struct list_head *new) { - new->next = old->next; - new->next->prev = new; - new->prev = old->prev; - new->prev->next = new; + new->next = old->next; + new->next->prev = new; + new->prev = old->prev; + new->prev->next = new; } -static inline void list_replace_init(struct list_head *old, - struct list_head *new) +static inline void +list_replace_init(struct list_head *old, struct list_head *new) { - list_replace(old, new); - INIT_LIST_HEAD(old); + list_replace(old, new); + INIT_LIST_HEAD(old); } /** * list_rotate_left - rotate the list to the left * @head: the head of the list */ -static inline void list_rotate_left (struct list_head *head) +static inline void +list_rotate_left(struct list_head *head) { - struct list_head *first; + struct list_head *first; - if (!list_empty (head)) { - first = head->next; - list_move_tail (first, head); - } + if (!list_empty(head)) { + first = head->next; + list_move_tail(first, head); + } } -#define list_entry(ptr, type, member) \ - ((type *)((char *)(ptr)-(unsigned long)(&((type *)0)->member))) - -#define list_first_entry(ptr, type, member) \ - list_entry((ptr)->next, type, member) - -#define list_last_entry(ptr, type, member) \ - list_entry((ptr)->prev, type, member) +#define list_entry(ptr, type, member) \ + ((type *)((char *)(ptr) - (unsigned long)(&((type *)0)->member))) -#define list_next_entry(pos, member) \ - list_entry((pos)->member.next, typeof(*(pos)), member) +#define list_first_entry(ptr, type, member) \ + list_entry((ptr)->next, type, member) -#define list_prev_entry(pos, member) \ - list_entry((pos)->member.prev, typeof(*(pos)), member) +#define list_last_entry(ptr, type, member) list_entry((ptr)->prev, type, member) -#define list_for_each(pos, head) \ - for (pos = (head)->next; pos != (head); pos = pos->next) +#define list_next_entry(pos, member) \ + list_entry((pos)->member.next, typeof(*(pos)), 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)) +#define list_prev_entry(pos, member) \ + list_entry((pos)->member.prev, typeof(*(pos)), member) +#define list_for_each(pos, head) \ + for (pos = (head)->next; pos != (head); pos = pos->next) -#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(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_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_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_safe_reverse(pos, n, head, member) \ - for (pos = list_entry((head)->prev, typeof(*pos), member), \ - n = list_entry(pos->member.prev, typeof(*pos), member); \ - &pos->member != (head); \ - pos = n, n = list_entry(n->member.prev, typeof(*n), member)) +#define list_for_each_entry_safe_reverse(pos, n, head, member) \ + for (pos = list_entry((head)->prev, typeof(*pos), member), \ + n = list_entry(pos->member.prev, typeof(*pos), member); \ + &pos->member != (head); \ + pos = n, n = list_entry(n->member.prev, typeof(*n), member)) /* * This list implementation has some advantages, but one disadvantage: you @@ -276,12 +260,14 @@ static inline void list_rotate_left (struct list_head *head) * address of the head has to be an argument for these macros. */ -#define list_next(ptr, head, type, member) \ - (((ptr)->member.next == head) ? NULL \ - : list_entry((ptr)->member.next, type, member)) +#define list_next(ptr, head, type, member) \ + (((ptr)->member.next == head) \ + ? NULL \ + : list_entry((ptr)->member.next, type, member)) -#define list_prev(ptr, head, type, member) \ - (((ptr)->member.prev == head) ? NULL \ - : list_entry((ptr)->member.prev, type, member)) +#define list_prev(ptr, head, type, member) \ + (((ptr)->member.prev == head) \ + ? NULL \ + : list_entry((ptr)->member.prev, type, member)) #endif /* _LLIST_H */ |