#ifndef _LINUX_LIST_H#define _LINUX_LIST_H#include<linux/types.h>#include<linux/stddef.h>#include<linux/poison.h>#include<linux/const.h>/* * Simple doubly linked list implementation. * * Some of the internal functions ("__xxx") are useful when * manipulating whole lists rather than single entries, as * sometimes we already know the next/prev entries and we can * generate better code by using them directly rather than * using the generic single-entry routines. */#define LIST_HEAD_INIT(name) { &(name), &(name) }#define LIST_HEAD(name) \ struct list_head name = LIST_HEAD_INIT(name)staticinlinevoidINIT_LIST_HEAD(structlist_head*list){list->next=list;list->prev=list;}/* * Insert a new entry between two known consecutive entries. * * This is only for internal list manipulation where we know * the prev/next entries already! */#ifndef CONFIG_DEBUG_LISTstaticinlinevoid__list_add(structlist_head*new,structlist_head*prev,structlist_head*next){next->prev=new;new->next=next;new->prev=prev;prev->next=new;}#elseexternvoid__list_add(structlist_head*new,structlist_head*prev,structlist_head*next);#endif/** * list_add - add a new entry * @new: new entry to be added * @head: list head to add it after * * Insert a new entry after the specified head. * This is good for implementing stacks. */staticinlinevoidlist_add(structlist_head*new,structlist_head*head){__list_add(new,head,head->next);}/** * list_add_tail - add a new entry * @new: new entry to be added * @head: list head to add it before * * Insert a new entry before the specified head. * This is useful for implementing queues. */staticinlinevoidlist_add_tail(structlist_head*new,structlist_head*head){__list_add(new,head->prev,head);}/* * Delete a list entry by making the prev/next entries * point to each other. * * This is only for internal list manipulation where we know * the prev/next entries already! */staticinlinevoid__list_del(structlist_head*prev,structlist_head*next){next->prev=prev;prev->next=next;}/** * list_del - deletes entry from list. * @entry: the element to delete from the list. * Note: list_empty() on entry does not return true after this, the entry is * in an undefined state. */#ifndef CONFIG_DEBUG_LISTstaticinlinevoid__list_del_entry(structlist_head*entry){__list_del(entry->prev,entry->next);}staticinlinevoidlist_del(structlist_head*entry){__list_del(entry->prev,entry->next);entry->next=LIST_POISON1;entry->prev=LIST_POISON2;}#elseexternvoid__list_del_entry(structlist_head*entry);externvoidlist_del(structlist_head*entry);#endif/** * list_replace - replace old entry by new one * @old : the element to be replaced * @new : the new element to insert * * If @old was empty, it will be overwritten. */staticinlinevoidlist_replace(structlist_head*old,structlist_head*new){new->next=old->next;new->next->prev=new;new->prev=old->prev;new->prev->next=new;}staticinlinevoidlist_replace_init(structlist_head*old,structlist_head*new){list_replace(old,new);INIT_LIST_HEAD(old);}/** * list_del_init - deletes entry from list and reinitialize it. * @entry: the element to delete from the list. */staticinlinevoidlist_del_init(structlist_head*entry){__list_del_entry(entry);INIT_LIST_HEAD(entry);}/** * list_move - delete from one list and add as another's head * @list: the entry to move * @head: the head that will precede our entry */staticinlinevoidlist_move(structlist_head*list,structlist_head*head){__list_del_entry(list);list_add(list,head);}/** * list_move_tail - delete from one list and add as another's tail * @list: the entry to move * @head: the head that will follow our entry */staticinlinevoidlist_move_tail(structlist_head*list,structlist_head*head){__list_del_entry(list);list_add_tail(list,head);}/** * list_is_last - tests whether @list is the last entry in list @head * @list: the entry to test * @head: the head of the list */staticinlineintlist_is_last(conststructlist_head*list,conststructlist_head*head){returnlist->next==head;}/** * list_empty - tests whether a list is empty * @head: the list to test. */staticinlineintlist_empty(conststructlist_head*head){returnhead->next==head;}/** * list_empty_careful - tests whether a list is empty and not being modified * @head: the list to test * * Description: * tests whether a list is empty _and_ checks that no other CPU might be * in the process of modifying either member (next or prev) * * NOTE: using list_empty_careful() without synchronization * can only be safe if the only activity that can happen * to the list entry is list_del_init(). Eg. it cannot be used * if another CPU could re-list_add() it. */staticinlineintlist_empty_careful(conststructlist_head*head){structlist_head*next=head->next;return(next==head)&&(next==head->prev);}/** * list_rotate_left - rotate the list to the left * @head: the head of the list */staticinlinevoidlist_rotate_left(structlist_head*head){structlist_head*first;if(!list_empty(head)){first=head->next;list_move_tail(first,head);}}/** * list_is_singular - tests whether a list has just one entry. * @head: the list to test. */staticinlineintlist_is_singular(conststructlist_head*head){return!list_empty(head)&&(head->next==head->prev);}staticinlinevoid__list_cut_position(structlist_head*list,structlist_head*head,structlist_head*entry){structlist_head*new_first=entry->next;list->next=head->next;list->next->prev=list;list->prev=entry;entry->next=list;head->next=new_first;new_first->prev=head;}/** * list_cut_position - cut a list into two * @list: a new list to add all removed entries * @head: a list with entries * @entry: an entry within head, could be the head itself * and if so we won't cut the list * * This helper moves the initial part of @head, up to and * including @entry, from @head to @list. You should * pass on @entry an element you know is on @head. @list * should be an empty list or a list you do not care about * losing its data. * */staticinlinevoidlist_cut_position(structlist_head*list,structlist_head*head,structlist_head*entry){if(list_empty(head))return;if(list_is_singular(head)&&(head->next!=entry&&head!=entry))return;if(entry==head)INIT_LIST_HEAD(list);else__list_cut_position(list,head,entry);}staticinlinevoid__list_splice(conststructlist_head*list,structlist_head*prev,structlist_head*next){structlist_head*first=list->next;structlist_head*last=list->prev;first->prev=prev;prev->next=first;last->next=next;next->prev=last;}/** * list_splice - join two lists, this is designed for stacks * @list: the new list to add. * @head: the place to add it in the first list. */staticinlinevoidlist_splice(conststructlist_head*list,structlist_head*head){if(!list_empty(list))__list_splice(list,head,head->next);}/** * list_splice_tail - join two lists, each list being a queue * @list: the new list to add. * @head: the place to add it in the first list. */staticinlinevoidlist_splice_tail(structlist_head*list,structlist_head*head){if(!list_empty(list))__list_splice(list,head->prev,head);}/** * list_splice_init - join two lists and reinitialise the emptied list. * @list: the new list to add. * @head: the place to add it in the first list. * * The list at @list is reinitialised */staticinlinevoidlist_splice_init(structlist_head*list,structlist_head*head){if(!list_empty(list)){__list_splice(list,head,head->next);INIT_LIST_HEAD(list);}}/** * list_splice_tail_init - join two lists and reinitialise the emptied list * @list: the new list to add. * @head: the place to add it in the first list. * * Each of the lists is a queue. * The list at @list is reinitialised */staticinlinevoidlist_splice_tail_init(structlist_head*list,structlist_head*head){if(!list_empty(list)){__list_splice(list,head->prev,head);INIT_LIST_HEAD(list);}}/** * list_entry - get the struct for this entry * @ptr: the &struct list_head pointer. * @type: the type of the struct this is embedded in. * @member: the name of the list_struct within the struct. */#define list_entry(ptr, type, member) \container_of(ptr, type, member)/** * list_first_entry - get the first element from a list * @ptr: the list head to take the element from. * @type: the type of the struct this is embedded in. * @member: the name of the list_struct within the struct. * * Note, that list is expected to be not empty. */#define list_first_entry(ptr, type, member) \list_entry((ptr)->next, type, member)/** * list_for_each - iterate over a list * @pos: the &struct list_head to use as a loop cursor. * @head: the head for your list. */#define list_for_each(pos, head) \ for (pos = (head)->next; pos != (head); pos = pos->next)/** * __list_for_each - iterate over a list * @pos: the &struct list_head to use as a loop cursor. * @head: the head for your list. * * This variant doesn't differ from list_for_each() any more. * We don't do prefetching in either case. */#define __list_for_each(pos, head) \ for (pos = (head)->next; pos != (head); pos = pos->next)/** * list_for_each_prev - iterate over a list backwards * @pos: the &struct list_head to use as a loop cursor. * @head: the head for your list. */#define list_for_each_prev(pos, head) \ for (pos = (head)->prev; pos != (head); pos = pos->prev)/** * list_for_each_safe - iterate over a list safe against removal of list entry * @pos: the &struct list_head to use as a loop cursor. * @n: another &struct list_head to use as temporary storage * @head: the head for your list. */#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_prev_safe - iterate over a list backwards safe against removal of list entry * @pos: the &struct list_head to use as a loop cursor. * @n: another &struct list_head to use as temporary storage * @head: the head for your list. */#define list_for_each_prev_safe(pos, n, head) \ for (pos = (head)->prev, n = pos->prev; \pos != (head); \pos = n, n = pos->prev)/** * list_for_each_entry - iterate over list of given type * @pos: the type * to use as a loop cursor. * @head: the head for your list. * @member: the name of the list_struct within the struct. */#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_for_each_entry_reverse - iterate backwards over list of given type. * @pos: the type * to use as a loop cursor. * @head: the head for your list. * @member: the name of the list_struct within the struct. */#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))/** * list_prepare_entry - prepare a pos entry for use in list_for_each_entry_continue() * @pos: the type * to use as a start point * @head: the head of the list * @member: the name of the list_struct within the struct. * * Prepares a pos entry for use as a start point in list_for_each_entry_continue(). */#define list_prepare_entry(pos, head, member) \ ((pos) ? : list_entry(head, typeof(*pos), member))/** * list_for_each_entry_continue - continue iteration over list of given type * @pos: the type * to use as a loop cursor. * @head: the head for your list. * @member: the name of the list_struct within the struct. * * Continue to iterate over list of given type, continuing after * the current position. */#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))/** * list_for_each_entry_continue_reverse - iterate backwards from the given point * @pos: the type * to use as a loop cursor. * @head: the head for your list. * @member: the name of the list_struct within the struct. * * Start to iterate over list of given type backwards, continuing after * the current position. */#define list_for_each_entry_continue_reverse(pos, head, member) \ for (pos = list_entry(pos->member.prev, typeof(*pos), member); \ &pos->member != (head); \pos = list_entry(pos->member.prev, typeof(*pos), member))/** * list_for_each_entry_from - iterate over list of given type from the current point * @pos: the type * to use as a loop cursor. * @head: the head for your list. * @member: the name of the list_struct within the struct. * * Iterate over list of given type, continuing from current position. */#define list_for_each_entry_from(pos, head, member) \ for (; &pos->member != (head); \pos = list_entry(pos->member.next, typeof(*pos), member))/** * list_for_each_entry_safe - iterate over list of given type safe against removal of list entry * @pos: the type * to use as a loop cursor. * @n: another type * to use as temporary storage * @head: the head for your list. * @member: the name of the list_struct within the struct. */#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 - continue list iteration safe against removal * @pos: the type * to use as a loop cursor. * @n: another type * to use as temporary storage * @head: the head for your list. * @member: the name of the list_struct within the struct. * * Iterate over list of given type, continuing after current point, * safe against removal of list entry. */#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))/** * list_for_each_entry_safe_from - iterate over list from current point safe against removal * @pos: the type * to use as a loop cursor. * @n: another type * to use as temporary storage * @head: the head for your list. * @member: the name of the list_struct within the struct. * * Iterate over list of given type from current point, safe against * removal of list entry. */#define list_for_each_entry_safe_from(pos, n, head, member) \ for (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_reverse - iterate backwards over list safe against removal * @pos: the type * to use as a loop cursor. * @n: another type * to use as temporary storage * @head: the head for your list. * @member: the name of the list_struct within the struct. * * Iterate backwards over list of given type, safe against removal * of list entry. */#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))/** * list_safe_reset_next - reset a stale list_for_each_entry_safe loop * @pos: the loop cursor used in the list_for_each_entry_safe loop * @n: temporary storage used in list_for_each_entry_safe * @member: the name of the list_struct within the struct. * * list_safe_reset_next is not safe to use in general if the list may be * modified concurrently (eg. the lock is dropped in the loop body). An * exception to this is if the cursor element (pos) is pinned in the list, * and list_safe_reset_next is called after re-taking the lock and before * completing the current iteration of the loop body. */#define list_safe_reset_next(pos, n, member) \ n = list_entry(pos->member.next, typeof(*pos), member)/* * Double linked lists with a single pointer list head. * Mostly useful for hash tables where the two pointer list head is * too wasteful. * You lose the ability to access the tail in O(1). */#define HLIST_HEAD_INIT { .first = NULL }#define HLIST_HEAD(name) struct hlist_head name = { .first = NULL }#define INIT_HLIST_HEAD(ptr) ((ptr)->first = NULL)staticinlinevoidINIT_HLIST_NODE(structhlist_node*h){h->next=NULL;h->pprev=NULL;}staticinlineinthlist_unhashed(conststructhlist_node*h){return!h->pprev;}staticinlineinthlist_empty(conststructhlist_head*h){return!h->first;}staticinlinevoid__hlist_del(structhlist_node*n){structhlist_node*next=n->next;structhlist_node**pprev=n->pprev;*pprev=next;if(next)next->pprev=pprev;}staticinlinevoidhlist_del(structhlist_node*n){__hlist_del(n);n->next=LIST_POISON1;n->pprev=LIST_POISON2;}staticinlinevoidhlist_del_init(structhlist_node*n){if(!hlist_unhashed(n)){__hlist_del(n);INIT_HLIST_NODE(n);}}staticinlinevoidhlist_add_head(structhlist_node*n,structhlist_head*h){structhlist_node*first=h->first;n->next=first;if(first)first->pprev=&n->next;h->first=n;n->pprev=&h->first;}/* next must be != NULL */staticinlinevoidhlist_add_before(structhlist_node*n,structhlist_node*next){n->pprev=next->pprev;n->next=next;next->pprev=&n->next;*(n->pprev)=n;}staticinlinevoidhlist_add_after(structhlist_node*n,structhlist_node*next){next->next=n->next;n->next=next;next->pprev=&n->next;if(next->next)next->next->pprev=&next->next;}/* after that we'll appear to be on some hlist and hlist_del will work */staticinlinevoidhlist_add_fake(structhlist_node*n){n->pprev=&n->next;}/* * Move a list from one list head to another. Fixup the pprev * reference of the first entry if it exists. */staticinlinevoidhlist_move_list(structhlist_head*old,structhlist_head*new){new->first=old->first;if(new->first)new->first->pprev=&new->first;old->first=NULL;}#define hlist_entry(ptr, type, member) container_of(ptr,type,member)#define hlist_for_each(pos, head) \ for (pos = (head)->first; pos ; pos = pos->next)#define hlist_for_each_safe(pos, n, head) \ for (pos = (head)->first; pos && ({ n = pos->next; 1; }); \pos = n)/** * hlist_for_each_entry - iterate over list of given type * @tpos: the type * to use as a loop cursor. * @pos: the &struct hlist_node to use as a loop cursor. * @head: the head for your list. * @member: the name of the hlist_node within the struct. */#define hlist_for_each_entry(tpos, pos, head, member) \ for (pos = (head)->first; \pos && \ ({ tpos = hlist_entry(pos, typeof(*tpos), member); 1;}); \pos = pos->next)/** * hlist_for_each_entry_continue - iterate over a hlist continuing after current point * @tpos: the type * to use as a loop cursor. * @pos: the &struct hlist_node to use as a loop cursor. * @member: the name of the hlist_node within the struct. */#define hlist_for_each_entry_continue(tpos, pos, member) \ for (pos = (pos)->next; \pos && \ ({ tpos = hlist_entry(pos, typeof(*tpos), member); 1;}); \pos = pos->next)/** * hlist_for_each_entry_from - iterate over a hlist continuing from current point * @tpos: the type * to use as a loop cursor. * @pos: the &struct hlist_node to use as a loop cursor. * @member: the name of the hlist_node within the struct. */#define hlist_for_each_entry_from(tpos, pos, member) \ for (; pos && \ ({ tpos = hlist_entry(pos, typeof(*tpos), member); 1;}); \pos = pos->next)/** * hlist_for_each_entry_safe - iterate over list of given type safe against removal of list entry * @tpos: the type * to use as a loop cursor. * @pos: the &struct hlist_node to use as a loop cursor. * @n: another &struct hlist_node to use as temporary storage * @head: the head for your list. * @member: the name of the hlist_node within the struct. */#define hlist_for_each_entry_safe(tpos, pos, n, head, member) \ for (pos = (head)->first; \pos && ({ n = pos->next; 1; }) && \ ({ tpos = hlist_entry(pos, typeof(*tpos), member); 1;}); \pos = n)#endif