linux_list.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	list_head
struct	hlist_head
struct	hlist_node

Macros
#define	offsetof(TYPE, MEMBER)   ((size_t) &((TYPE *)0)->MEMBER)
#define	container_of(ptr, type, member)
#define	typecheck(type, x)
#define	prefetch(x)   1
#define	smp_wmb()
#define	LIST_POISON1   ((void *) 0x00100100)
#define	LIST_POISON2   ((void *) 0x00200200)
#define	LIST_HEAD_INIT(name)   { &(name), &(name) }
#define	LIST_HEAD(name)   struct list_head name = LIST_HEAD_INIT(name)
#define	INIT_LIST_HEAD(ptr)
#define	list_entry(ptr, type, member)   container_of(ptr, type, member)
#define	list_for_each(pos, head)
#define	__list_for_each(pos, head)   for (pos = (head)->next; pos != (head); pos = pos->next)
#define	list_for_each_prev(pos, head)
#define	list_for_each_safe(pos, n, head)
#define	list_for_each_entry(pos, head, member)
#define	list_for_each_entry_reverse(pos, head, member)
#define	list_prepare_entry(pos, head, member)   ((pos) ? : list_entry(head, typeof(*pos), member))
#define	list_for_each_entry_continue(pos, head, member)
#define	list_for_each_entry_safe(pos, n, head, member)
#define	list_for_each_rcu(pos, head)
#define	__list_for_each_rcu(pos, head)
#define	list_for_each_safe_rcu(pos, n, head)
#define	list_for_each_entry_rcu(pos, head, member)
#define	list_for_each_continue_rcu(pos, head)
#define	HLIST_HEAD_INIT   { .first = NULL }
#define	HLIST_HEAD(name)   struct hlist_head name = { .first = NULL }
#define	INIT_HLIST_HEAD(ptr)   ((ptr)->first = NULL)
#define	INIT_HLIST_NODE(ptr)   ((ptr)->next = NULL, (ptr)->pprev = NULL)
#define	hlist_del_rcu_init   hlist_del_init
#define	hlist_entry(ptr, type, member)   container_of(ptr,type,member)
#define	hlist_for_each(pos, head)
#define	hlist_for_each_safe(pos, n, head)
#define	hlist_for_each_entry(tpos, pos, head, member)
#define	hlist_for_each_entry_continue(tpos, pos, member)
#define	hlist_for_each_entry_from(tpos, pos, member)
#define	hlist_for_each_entry_safe(tpos, pos, n, head, member)
#define	hlist_for_each_entry_rcu(tpos, pos, head, member)

Functions
static void	__list_add (struct list_head *new, struct list_head *prev, struct list_head *next)
static void	list_add (struct list_head *new, struct list_head *head)
static void	list_add_tail (struct list_head *new, struct list_head *head)
static void	__list_add_rcu (struct list_head *new, struct list_head *prev, struct list_head *next)
static void	list_add_rcu (struct list_head *new, struct list_head *head)
static void	list_add_tail_rcu (struct list_head *new, struct list_head *head)
static void	__list_del (struct list_head *prev, struct list_head *next)
static void	list_del (struct list_head *entry)
static void	list_del_rcu (struct list_head *entry)
static void	list_del_init (struct list_head *entry)
static void	list_move (struct list_head *list, struct list_head *head)
static void	list_move_tail (struct list_head *list, struct list_head *head)
static int	list_empty (const struct list_head *head)
static int	list_empty_careful (const struct list_head *head)
static void	__list_splice (struct list_head *list, struct list_head *head)
static void	list_splice (struct list_head *list, struct list_head *head)
static void	list_splice_init (struct list_head *list, struct list_head *head)
static int	hlist_unhashed (const struct hlist_node *h)
static int	hlist_empty (const struct hlist_head *h)
static void	__hlist_del (struct hlist_node *n)
static void	hlist_del (struct hlist_node *n)
static void	hlist_del_rcu (struct hlist_node *n)
static void	hlist_del_init (struct hlist_node *n)
static void	hlist_add_head (struct hlist_node *n, struct hlist_head *h)
static void	hlist_add_head_rcu (struct hlist_node *n, struct hlist_head *h)
static void	hlist_add_before (struct hlist_node *n, struct hlist_node *next)
static void	hlist_add_after (struct hlist_node *n, struct hlist_node *next)

Macro Definition Documentation

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

__list_for_each - iterate over a list : the &struct list_head to use as a loop counter. : 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_rcu	(		pos,
			head
	)

Value:

for (pos = (head)->next; pos != (head); \
            pos = pos->next, ({ smp_read_barrier_depends(); 0;}))

#define container_of	(		ptr,
			type,
			member
	)

Value:

({          \
        const typeof( ((type *)0)->member ) *__mptr = (ptr);    \
        (type *)( (char *)__mptr - offsetof(type,member) );})

container_of - cast a member of a structure out to the containing structure

: the pointer to the member. : the type of the container struct this is embedded in. : the name of the member within the struct.

#define hlist_del_rcu_init   hlist_del_init

#define hlist_entry	(		ptr,
			type,
			member
	)		container_of(ptr,type,member)

#define hlist_for_each	(		pos,
			head
	)

Value:

for (pos = (head)->first; pos && ({ prefetch(pos->next); 1; }); \
         pos = pos->next)

#define hlist_for_each_entry	(		tpos,
			pos,
			head,
			member
	)

Value:

for (pos = (head)->first;                    \
         pos && ({ prefetch(pos->next); 1;}) &&          \
        ({ tpos = hlist_entry(pos, typeof(*tpos), member); 1;}); \
         pos = pos->next)

hlist_for_each_entry - iterate over list of given type : the type * to use as a loop counter. : the &struct hlist_node to use as a loop counter. : the head for your list. : the name of the hlist_node within the struct.

#define hlist_for_each_entry_continue	(		tpos,
			pos,
			member
	)

Value:

for (pos = (pos)->next;                      \
         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 existing point : the type * to use as a loop counter. : the &struct hlist_node to use as a loop counter. : the name of the hlist_node within the struct.

#define hlist_for_each_entry_from	(		tpos,
			pos,
			member
	)

Value:

for (; 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 existing point : the type * to use as a loop counter. : the &struct hlist_node to use as a loop counter. : the name of the hlist_node within the struct.

#define hlist_for_each_entry_rcu	(		tpos,
			pos,
			head,
			member
	)

Value:

for (pos = (head)->first;                    \
         pos && ({ prefetch(pos->next); 1;}) &&          \
        ({ tpos = hlist_entry(pos, typeof(*tpos), member); 1;}); \
         pos = pos->next, ({ smp_read_barrier_depends(); 0; }) )

hlist_for_each_entry_rcu - iterate over rcu list of given type : the type * to use as a loop counter. : the &struct hlist_node to use as a loop counter. : the head for your list. : 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_rcu() as long as the traversal is guarded by rcu_read_lock().

#define hlist_for_each_entry_safe	(		tpos,
			pos,
			n,
			head,
			member
	)

Value:

for (pos = (head)->first;                    \
         pos && ({ n = pos->next; 1; }) &&               \
        ({ tpos = hlist_entry(pos, typeof(*tpos), member); 1;}); \
         pos = n)

hlist_for_each_entry_safe - iterate over list of given type safe against removal of list entry : the type * to use as a loop counter. : the &struct hlist_node to use as a loop counter.
: another &struct hlist_node to use as temporary storage : the head for your list. : the name of the hlist_node within the struct.

#define hlist_for_each_safe	(		pos,
			n,
			head
	)

Value:

for (pos = (head)->first; pos && ({ n = pos->next; 1; }); \
         pos = n)

#define HLIST_HEAD

(

name

)

struct hlist_head name = { .first = NULL }

#define HLIST_HEAD_INIT   { .first = NULL }

#define INIT_HLIST_HEAD

(

ptr

)

((ptr)->first = NULL)

#define INIT_HLIST_NODE

(

ptr

)

((ptr)->next = NULL, (ptr)->pprev = NULL)

#define INIT_LIST_HEAD

(

ptr

)

Value:

do { \
    (ptr)->next = (ptr); (ptr)->prev = (ptr); \
} while (0)

#define list_entry	(		ptr,
			type,
			member
	)		container_of(ptr, type, member)

list_entry - get the struct for this entry : the &struct list_head pointer. : the type of the struct this is embedded in. : the name of the list_struct within the struct.

#define list_for_each	(		pos,
			head
	)

Value:

for (pos = (head)->next, prefetch(pos->next); pos != (head); \
            pos = pos->next, prefetch(pos->next))

list_for_each - iterate over a list : the &struct list_head to use as a loop counter. : the head for your list.

#define list_for_each_continue_rcu	(		pos,
			head
	)

Value:

for ((pos) = (pos)->next, prefetch((pos)->next); (pos) != (head); \
            (pos) = (pos)->next, ({ smp_read_barrier_depends(); 0;}), prefetch((pos)->next))

list_for_each_continue_rcu - iterate over an rcu-protected list continuing after existing point. : the &struct list_head to use as a loop counter. : 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_entry	(		pos,
			head,
			member
	)

Value:

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),  \
             prefetch(pos->member.next))

list_for_each_entry - iterate over list of given type : the type * to use as a loop counter. : the head for your list. : the name of the list_struct within the struct.

#define list_for_each_entry_continue	(		pos,
			head,
			member
	)

Value:

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),  \
             prefetch(pos->member.next))

list_for_each_entry_continue - iterate over list of given type continuing after existing point : the type * to use as a loop counter. : the head for your list. : the name of the list_struct within the struct.

#define list_for_each_entry_rcu	(		pos,
			head,
			member
	)

Value:

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),  \
             ({ smp_read_barrier_depends(); 0;}),       \
             prefetch(pos->member.next))

list_for_each_entry_rcu - iterate over rcu list of given type : the type * to use as a loop counter. : the head for your list. : 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_reverse	(		pos,
			head,
			member
	)

Value:

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),  \
             prefetch(pos->member.prev))

list_for_each_entry_reverse - iterate backwards over list of given type. : the type * to use as a loop counter. : the head for your list. : the name of the list_struct within the struct.

#define list_for_each_entry_safe	(		pos,
			n,
			head,
			member
	)

Value:

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 - iterate over list of given type safe against removal of list entry : the type * to use as a loop counter.
: another type * to use as temporary storage : the head for your list. : the name of the list_struct within the struct.

#define list_for_each_prev	(		pos,
			head
	)

Value:

for (pos = (head)->prev, prefetch(pos->prev); pos != (head); \
            pos = pos->prev, prefetch(pos->prev))

list_for_each_prev - iterate over a list backwards : the &struct list_head to use as a loop counter. : the head for your list.

#define list_for_each_rcu	(		pos,
			head
	)

Value:

for (pos = (head)->next, prefetch(pos->next); pos != (head); \
            pos = pos->next, ({ smp_read_barrier_depends(); 0;}), prefetch(pos->next))

list_for_each_rcu - iterate over an rcu-protected list : the &struct list_head to use as a loop counter. : 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_safe	(		pos,
			n,
			head
	)

Value:

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

list_for_each_safe - iterate over a list safe against removal of list entry : the &struct list_head to use as a loop counter.
: another &struct list_head to use as temporary storage : the head for your list.

#define list_for_each_safe_rcu	(		pos,
			n,
			head
	)

Value:

for (pos = (head)->next, n = pos->next; pos != (head); \
        pos = n, ({ smp_read_barrier_depends(); 0;}), n = pos->next)

list_for_each_safe_rcu - iterate over an rcu-protected list safe against removal of list entry : the &struct list_head to use as a loop counter.
: another &struct list_head to use as temporary storage : 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_HEAD

(

name

)

struct list_head name = LIST_HEAD_INIT(name)

#define LIST_HEAD_INIT

(

name

)

{ &(name), &(name) }

#define LIST_POISON1   ((void *) 0x00100100)

#define LIST_POISON2   ((void *) 0x00200200)

#define list_prepare_entry	(		pos,
			head,
			member
	)		((pos) ? : list_entry(head, typeof(*pos), member))

list_prepare_entry - prepare a pos entry for use as a start point in list_for_each_entry_continue : the type * to use as a start point : the head of the list : the name of the list_struct within the struct.

#define offsetof	(		TYPE,
			MEMBER
	)		((size_t) &((TYPE *)0)->MEMBER)

#define prefetch

(

x

)

1

#define smp_wmb

(

)

#define typecheck	(		type,
			x
	)

Value:

({  type __dummy; \
    typeof(x) __dummy2; \
    (void)(&__dummy == &__dummy2); \
    1; \
})

Function Documentation

static void __hlist_del ( struct hlist_node *  n )

inlinestatic

Here is the caller graph for this function:

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

inlinestatic

Here is the caller graph for this function:

static void __list_add_rcu ( struct list_head *  new, struct list_head *  prev, struct list_head *  next  )

inlinestatic

Here is the caller graph for this function:

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

inlinestatic

Here is the caller graph for this function:

static void __list_splice ( struct list_head *  list, struct list_head *  head  )

inlinestatic

Here is the caller graph for this function:

static void hlist_add_after ( struct hlist_node *  n, struct hlist_node *  next  )

inlinestatic

static void hlist_add_before ( struct hlist_node *  n, struct hlist_node *  next  )

inlinestatic

static void hlist_add_head ( struct hlist_node *  n, struct hlist_head *  h  )

inlinestatic

static void hlist_add_head_rcu ( struct hlist_node *  n, struct hlist_head *  h  )

inlinestatic

hlist_add_head_rcu - adds the specified element to the specified hlist, while permitting racing traversals.
: the element to add to the hash list. : the list to add to.

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(), but only if smp_read_barrier_depends() is 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().

OK, so why don't we have an hlist_for_each_entry_rcu()???

static void hlist_del ( struct hlist_node *  n )

inlinestatic

Here is the call graph for this function:

static void hlist_del_init ( struct hlist_node *  n )

inlinestatic

Here is the call graph for this function:

static void hlist_del_rcu ( struct hlist_node *  n )

inlinestatic

hlist_del_rcu - deletes entry from hash list without re-initialization
: 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().

Here is the call graph for this function:

static int hlist_empty ( const struct hlist_head *  h )

inlinestatic

static int hlist_unhashed ( const struct hlist_node *  h )

inlinestatic

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

inlinestatic

list_add - add a new entry : new entry to be added : list head to add it after

Insert a new entry after the specified head. This is good for implementing stacks.

Here is the call graph for this function:

Here is the caller graph for this function:

static void list_add_rcu ( struct list_head *  new, struct list_head *  head  )

inlinestatic

list_add_rcu - add a new entry to rcu-protected list : new entry to be added : 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().

Here is the call graph for this function:

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

inlinestatic

list_add_tail - add a new entry : new entry to be added : list head to add it before

Insert a new entry before the specified head. This is useful for implementing queues.

Here is the call graph for this function:

Here is the caller graph for this function:

static void list_add_tail_rcu ( struct list_head *  new, struct list_head *  head  )

inlinestatic

list_add_tail_rcu - add a new entry to rcu-protected list : new entry to be added : 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().

Here is the call graph for this function:

static void list_del ( struct list_head *  entry )

inlinestatic

list_del - deletes entry from list. : 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.

Here is the call graph for this function:

static void list_del_init ( struct list_head *  entry )

inlinestatic

list_del_init - deletes entry from list and reinitialize it. : the element to delete from the list.

Here is the call graph for this function:

static void list_del_rcu ( struct list_head *  entry )

inlinestatic

list_del_rcu - deletes entry from list without re-initialization : 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_kernel() or call_rcu() must be used to defer freeing until an RCU grace period has elapsed.

Here is the call graph for this function:

static int list_empty ( const struct list_head *  head )

inlinestatic

list_empty - tests whether a list is empty : the list to test.

Here is the caller graph for this function:

static int list_empty_careful ( const struct list_head *  head )

inlinestatic

list_empty_careful - tests whether a list is empty and checks that no other CPU might be in the process of still modifying either member

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.

: the list to test.

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

inlinestatic

list_move - delete from one list and add as another's head : the entry to move : the head that will precede our entry

Here is the call graph for this function:

static void list_move_tail ( struct list_head *  list, struct list_head *  head  )

inlinestatic

list_move_tail - delete from one list and add as another's tail : the entry to move : the head that will follow our entry

Here is the call graph for this function:

static void list_splice ( struct list_head *  list, struct list_head *  head  )

inlinestatic

list_splice - join two lists : the new list to add. : the place to add it in the first list.

Here is the call graph for this function:

static void list_splice_init ( struct list_head *  list, struct list_head *  head  )

inlinestatic

list_splice_init - join two lists and reinitialise the emptied list. : the new list to add. : the place to add it in the first list.

The list at is reinitialised

Here is the call graph for this function: