#ifndef _LINUX_LIST_H#define _LINUX_LIST_H#ifdef __KERNEL__#include<linux/stddef.h>#include<linux/poison.h>#include<linux/prefetch.h>#include<asm/system.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. */structlist_head{structlist_head*next,*prev;};#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. */#ifndef CONFIG_DEBUG_LISTstaticinlinevoidlist_add(structlist_head*new,structlist_head*head){__list_add(new,head,head->next);}#elseexternvoidlist_add(structlist_head*new,structlist_head*head);#endif/** * 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);}/* * Insert a new entry between two known consecutive entries. * * This is only for internal list manipulation where we know * the prev/next entries already! */staticinlinevoid__list_add_rcu(structlist_head*new,structlist_head*prev,structlist_head*next){new->next=next;new->prev=prev;smp_wmb();next->prev=new;prev->next=new;}/** * list_add_rcu - add a new entry to rcu-protected list * @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. * * The caller must take whatever precautions are necessary * (such as holding appropriate locks) to avoid racing * with another list-mutation primitive, such as list_add_rcu() * or list_del_rcu(), running on this same list. * However, it is perfectly legal to run concurrently with * the _rcu list-traversal primitives, such as * list_for_each_entry_rcu(). */staticinlinevoidlist_add_rcu(structlist_head*new,structlist_head*head){__list_add_rcu(new,head,head->next);}/** * list_add_tail_rcu - add a new entry to rcu-protected list * @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. * * The caller must take whatever precautions are necessary * (such as holding appropriate locks) to avoid racing * with another list-mutation primitive, such as list_add_tail_rcu() * or list_del_rcu(), running on this same list. * However, it is perfectly legal to run concurrently with * the _rcu list-traversal primitives, such as * list_for_each_entry_rcu(). */staticinlinevoidlist_add_tail_rcu(structlist_head*new,structlist_head*head){__list_add_rcu(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_LISTstaticinlinevoidlist_del(structlist_head*entry){__list_del(entry->prev,entry->next);entry->next=LIST_POISON1;entry->prev=LIST_POISON2;}#elseexternvoidlist_del(structlist_head*entry);#endif/** * list_del_rcu - deletes entry from list without re-initialization * @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. It is useful for RCU based * lockfree traversal. * * In particular, it means that we can not poison the forward * pointers that may still be used for walking the list. * * The caller must take whatever precautions are necessary * (such as holding appropriate locks) to avoid racing * with another list-mutation primitive, such as list_del_rcu() * or list_add_rcu(), running on this same list. * However, it is perfectly legal to run concurrently with * the _rcu list-traversal primitives, such as * list_for_each_entry_rcu(). * * Note that the caller is not permitted to immediately free * the newly deleted entry. Instead, either synchronize_rcu() * or call_rcu() must be used to defer freeing until an RCU * grace period has elapsed. */staticinlinevoidlist_del_rcu(structlist_head*entry){__list_del(entry->prev,entry->next);entry->prev=LIST_POISON2;}/** * list_replace - replace old entry by new one * @old : the element to be replaced * @new : the new element to insert * Note: 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_replace_rcu - replace old entry by new one * @old : the element to be replaced * @new : the new element to insert * * The @old entry will be replaced with the @new entry atomically. * Note: @old should not be empty. */staticinlinevoidlist_replace_rcu(structlist_head*old,structlist_head*new){new->next=old->next;new->prev=old->prev;smp_wmb();new->next->prev=new;new->prev->next=new;old->prev=LIST_POISON2;}/** * 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->prev,entry->next);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(list->prev,list->next);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(list->prev,list->next);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);}staticinlinevoid__list_splice(structlist_head*list,structlist_head*head){structlist_head*first=list->next;structlist_head*last=list->prev;structlist_head*at=head->next;first->prev=head;head->next=first;last->next=at;at->prev=last;}/** * list_splice - join two lists * @list: the new list to add. * @head: the place to add it in the first list. */staticinlinevoidlist_splice(structlist_head*list,structlist_head*head){if(!list_empty(list))__list_splice(list,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);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_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; prefetch(pos->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 differs from list_for_each() in that it's the * simplest possible list iteration code, no prefetching is done. * Use this for code that knows the list to be very short (empty * or 1 entry) most of the time. */#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; prefetch(pos->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_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); \prefetch(pos->member.next), &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); \prefetch(pos->member.prev), &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); \prefetch(pos->member.next), &pos->member != (head); \pos = list_entry(pos->member.next, 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 (; prefetch(pos->member.next), &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 * @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 * @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 * @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_for_each_rcu - iterate over an rcu-protected list * @pos: the &struct list_head to use as a loop cursor. * @head: the head for your list. * * This list-traversal primitive may safely run concurrently with * the _rcu list-mutation primitives such as list_add_rcu() * as long as the traversal is guarded by rcu_read_lock(). */#define list_for_each_rcu(pos, head) \ for (pos = (head)->next; \prefetch(rcu_dereference(pos)->next), pos != (head); \pos = pos->next)#define __list_for_each_rcu(pos, head) \ for (pos = (head)->next; \rcu_dereference(pos) != (head); \pos = pos->next)/** * list_for_each_safe_rcu * @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. * * Iterate over an rcu-protected list, safe against removal of list entry. * * This list-traversal primitive may safely run concurrently with * the _rcu list-mutation primitives such as list_add_rcu() * as long as the traversal is guarded by rcu_read_lock(). */#define list_for_each_safe_rcu(pos, n, head) \ for (pos = (head)->next; \ n = rcu_dereference(pos)->next, pos != (head); \pos = n)/** * list_for_each_entry_rcu - iterate over rcu 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. * * This list-traversal primitive may safely run concurrently with * the _rcu list-mutation primitives such as list_add_rcu() * as long as the traversal is guarded by rcu_read_lock(). */#define list_for_each_entry_rcu(pos, head, member) \ for (pos = list_entry((head)->next, typeof(*pos), member); \prefetch(rcu_dereference(pos)->member.next), \ &pos->member != (head); \pos = list_entry(pos->member.next, typeof(*pos), member))/** * list_for_each_continue_rcu * @pos: the &struct list_head to use as a loop cursor. * @head: the head for your list. * * Iterate over an rcu-protected list, continuing after current point. * * This list-traversal primitive may safely run concurrently with * the _rcu list-mutation primitives such as list_add_rcu() * as long as the traversal is guarded by rcu_read_lock(). */#define list_for_each_continue_rcu(pos, head) \ for ((pos) = (pos)->next; \prefetch(rcu_dereference((pos))->next), (pos) != (head); \ (pos) = (pos)->next)/* * 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). */structhlist_head{structhlist_node*first;};structhlist_node{structhlist_node*next,**pprev;};#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;}/** * hlist_del_rcu - deletes entry from hash list without re-initialization * @n: the element to delete from the hash list. * * Note: list_unhashed() on entry does not return true after this, * the entry is in an undefined state. It is useful for RCU based * lockfree traversal. * * In particular, it means that we can not poison the forward * pointers that may still be used for walking the hash list. * * The caller must take whatever precautions are necessary * (such as holding appropriate locks) to avoid racing * with another list-mutation primitive, such as hlist_add_head_rcu() * or hlist_del_rcu(), running on this same list. * However, it is perfectly legal to run concurrently with * the _rcu list-traversal primitives, such as * hlist_for_each_entry(). */staticinlinevoidhlist_del_rcu(structhlist_node*n){__hlist_del(n);n->pprev=LIST_POISON2;}staticinlinevoidhlist_del_init(structhlist_node*n){if(!hlist_unhashed(n)){__hlist_del(n);INIT_HLIST_NODE(n);}}/** * hlist_replace_rcu - replace old entry by new one * @old : the element to be replaced * @new : the new element to insert * * The @old entry will be replaced with the @new entry atomically. */staticinlinevoidhlist_replace_rcu(structhlist_node*old,structhlist_node*new){structhlist_node*next=old->next;new->next=next;new->pprev=old->pprev;smp_wmb();if(next)new->next->pprev=&new->next;*new->pprev=new;old->pprev=LIST_POISON2;}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;}/** * hlist_add_head_rcu * @n: the element to add to the hash list. * @h: the list to add to. * * Description: * Adds the specified element to the specified hlist, * while permitting racing traversals. * * The caller must take whatever precautions are necessary * (such as holding appropriate locks) to avoid racing * with another list-mutation primitive, such as hlist_add_head_rcu() * or hlist_del_rcu(), running on this same list. * However, it is perfectly legal to run concurrently with * the _rcu list-traversal primitives, such as * hlist_for_each_entry_rcu(), used to prevent memory-consistency * problems on Alpha CPUs. Regardless of the type of CPU, the * list-traversal primitive must be guarded by rcu_read_lock(). */staticinlinevoidhlist_add_head_rcu(structhlist_node*n,structhlist_head*h){structhlist_node*first=h->first;n->next=first;n->pprev=&h->first;smp_wmb();if(first)first->pprev=&n->next;h->first=n;}/* 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;}/** * hlist_add_before_rcu * @n: the new element to add to the hash list. * @next: the existing element to add the new element before. * * Description: * Adds the specified element to the specified hlist * before the specified node while permitting racing traversals. * * The caller must take whatever precautions are necessary * (such as holding appropriate locks) to avoid racing * with another list-mutation primitive, such as hlist_add_head_rcu() * or hlist_del_rcu(), running on this same list. * However, it is perfectly legal to run concurrently with * the _rcu list-traversal primitives, such as * hlist_for_each_entry_rcu(), used to prevent memory-consistency * problems on Alpha CPUs. */staticinlinevoidhlist_add_before_rcu(structhlist_node*n,structhlist_node*next){n->pprev=next->pprev;n->next=next;smp_wmb();next->pprev=&n->next;*(n->pprev)=n;}/** * hlist_add_after_rcu * @prev: the existing element to add the new element after. * @n: the new element to add to the hash list. * * Description: * Adds the specified element to the specified hlist * after the specified node while permitting racing traversals. * * The caller must take whatever precautions are necessary * (such as holding appropriate locks) to avoid racing * with another list-mutation primitive, such as hlist_add_head_rcu() * or hlist_del_rcu(), running on this same list. * However, it is perfectly legal to run concurrently with * the _rcu list-traversal primitives, such as * hlist_for_each_entry_rcu(), used to prevent memory-consistency * problems on Alpha CPUs. */staticinlinevoidhlist_add_after_rcu(structhlist_node*prev,structhlist_node*n){n->next=prev->next;n->pprev=&prev->next;smp_wmb();prev->next=n;if(n->next)n->next->pprev=&n->next;}#define hlist_entry(ptr, type, member) container_of(ptr,type,member)#define hlist_for_each(pos, head) \ for (pos = (head)->first; pos && ({ prefetch(pos->next); 1; }); \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 && ({ prefetch(pos->next); 1;}) && \ ({ 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 && ({ prefetch(pos->next); 1;}) && \ ({ 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 && ({ prefetch(pos->next); 1;}) && \ ({ 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)/** * hlist_for_each_entry_rcu - iterate over rcu 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. * * This list-traversal primitive may safely run concurrently with * the _rcu list-mutation primitives such as hlist_add_head_rcu() * as long as the traversal is guarded by rcu_read_lock(). */#define hlist_for_each_entry_rcu(tpos, pos, head, member) \ for (pos = (head)->first; \rcu_dereference(pos) && ({ prefetch(pos->next); 1;}) && \ ({ tpos = hlist_entry(pos, typeof(*tpos), member); 1;}); \pos = pos->next)#else#warning "don't include kernel headers in userspace"#endif /* __KERNEL__ */#endif