*
*/
+/** \file list.h doubly linked list implementation */
+
#include <stddef.h> /* offsetof */
-#ifndef _LINUX_LIST_H
-#define _LINUX_LIST_H
+/** get the struct this entry is embedded in */
#define container_of(ptr, type, member) ({ \
const typeof( ((type *)0)->member ) *__mptr = (ptr); \
(type *)( (char *)__mptr - offsetof(type,member) );})
-/*
- * These are non-NULL pointers that will result in page faults
- * under normal circumstances, used to verify that nobody uses
- * non-initialized list entries.
+/**
+ * Non-NULL pointers that will result in page faults under normal
+ * circumstances, used to verify that nobody uses non-initialized list entries.
+ * Used for poisoning the \a next pointer of struct list_head.
*/
#define LIST_POISON1 ((void *) 0x00100100)
+/** Non-null pointer, used for poisoning the \a prev pointer of struct
+ * list_head
+ */
#define LIST_POISON2 ((void *) 0x00200200)
+/** Simple doubly linked list implementation. */
+struct list_head {
+ /** pointer to the next list entry */
+ struct list_head *next;
+ /** pointer to the previous list entry */
+ struct list_head *prev;
+};
+
+/** must be called before using any other list functions */
+#define INIT_LIST_HEAD(ptr) do { \
+ (ptr)->next = (ptr); (ptr)->prev = (ptr); \
+} while (0)
+
+
/*
- * 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
* using the generic single-entry routines.
*/
-struct list_head {
- struct list_head *next, *prev;
-};
-
-#define INIT_LIST_HEAD(ptr) do { \
- (ptr)->next = (ptr); (ptr)->prev = (ptr); \
-} while (0)
/*
* Insert a new entry between two known consecutive entries.
/**
* add a new entry
*
- * \param new: new entry to be added
- * \param head: list head to add it after
+ * \param new new entry to be added
+ * \param head list head to add it after
*
* Insert a new entry after the specified head.
* This is good for implementing stacks.
}
/**
- * list_add_tail - add a new entry
- * @new: new entry to be added
- * @head: list head to add it before
+ * add a new entry
+ *
+ * \param new new entry to be added
+ * \param head list head to add it before
*
* Insert a new entry before the specified head.
* This is useful for implementing queues.
}
/**
- * list_del - deletes entry from list.
- * @entry: the element to delete from the list.
+ * Delete entry from list.
+ *
+ * \param 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.
*/
}
/**
- * 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
+ * delete from one list and add as another's head
+ *
+ * \param list: the entry to move
+ * \param head: the head that will precede our entry
*/
static inline void list_move(struct list_head *list, struct list_head *head)
{
}
/**
- * list_empty - tests whether a list is empty
- * @head: the list to test.
+ * test whether a list is empty
+ *
+ * \param head the list to test.
*/
static inline int list_empty(const struct list_head *head)
{
}
/**
- * 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.
+ * get the struct for this entry
+ *
+ * \param ptr the &struct list_head pointer.
+ * \param type the type of the struct this is embedded in.
+ * \param member the name of the list_struct within the struct.
*/
#define list_entry(ptr, type, member) \
container_of(ptr, type, member)
/**
- * list_for_each_safe - iterate over a list safe against removal of list entry
- * @pos: the &struct list_head to use as a loop counter.
- * @n: another &struct list_head to use as temporary storage
- * @head: the head for your list.
+ * iterate over a list safe against removal of list entry
+ *
+ * \param pos the &struct list_head to use as a loop counter.
+ * \param n another &struct list_head to use as temporary storage
+ * \param 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 counter.
- * @head: the head for your list.
- * @member: the name of the list_struct within the struct.
+ * iterate over list of given type
+ *
+ * \param pos the type * to use as a loop counter.
+ * \param head the head for your list.
+ * \param 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 = 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 counter.
- * @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 safe against removal of list entry
+ *
+ * \param pos the type * to use as a loop counter.
+ * \param n another type * to use as temporary storage
+ * \param head the head for your list.
+ * \param 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), \
&pos->member != (head); \
pos = n, n = list_entry(n->member.next, typeof(*n), member))
/**
- * list_for_each_entry_safe_reverse - iterate backwards over list of given type safe against
- * removal of list entry
- * @pos: the type * to use as a loop counter.
- * @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
+ * \param pos the type * to use as a loop counter.
+ * \param n another type * to use as temporary storage
+ * \param head the head for your list.
+ * \param member the name of the list_struct within the struct.
*/
#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))
-
-#endif /* _LIST_H */
projects / paraslash.git / blobdiff