#define INITIALIZED_LIST_HEAD(name) struct list_head name = {&(name), &(name)}
/** This must be called before using any other list functions. */
-#define INIT_LIST_HEAD(ptr) do { \
- (ptr)->next = (ptr); (ptr)->prev = (ptr); \
-} while (0)
-
-/*
- * 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.
- */
-
-/*
- * Insert a new entry between two known consecutive entries.
- *
- * \param new The new entry to add.
- * \param prev The entry preceeding the new entry.
- * \param next The entry following the new entry.
- *
- * This is only for internal list manipulations where we know the prev/next
- * entries already.
- */
-static inline void __list_add(struct list_head *new,
- struct list_head *prev, struct list_head *next)
+static inline void init_list_head(struct list_head *head)
{
- next->prev = new;
- new->next = next;
- new->prev = prev;
- prev->next = new;
+ head->next = head;
+ head->prev = head;
}
/**
* Insert a new entry after the specified head.
*
- * \param new The new entry to add.
+ * \param entry The new entry to add.
* \param head The list head to add it after.
*
* This is good for implementing stacks.
*/
-static inline void para_list_add(struct list_head *new, struct list_head *head)
+static inline void para_list_add(struct list_head *entry, struct list_head *head)
{
- __list_add(new, head, head->next);
+ entry->prev = head;
+ entry->next = head->next;
+ head->next->prev = entry;
+ head->next = entry;
}
/**
* Insert a new entry before the specified head.
*
- * \param new The new entry to add.
+ * \param entry The new entry to add.
* \param head list head to add it before.
*
* This is useful for implementing queues.
*/
-static inline void list_add_tail(struct list_head *new, struct list_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.
- */
-static inline void __list_del(struct list_head *prev, struct list_head *next)
+static inline void list_add_tail(struct list_head *entry, struct list_head *head)
{
- next->prev = prev;
- prev->next = next;
+ entry->prev = head->prev;
+ entry->next = head;
+ head->prev->next = entry;
+ head->prev = entry;
}
-/*
- * These non-NULL pointers result in page faults when dereferenced. This helps
- * to catch bugs resulting from using deleted list heads.
- */
-
-/** Used for poisoning the next pointer. */
-#define LIST_POISON1 ((void *)0x00100100)
-
-/** Used for poisoning the prev pointer. */
-#define LIST_POISON2 ((void *)0x00200200)
-
/**
* Delete an entry from a list.
*
*/
static inline void list_del(struct list_head *entry)
{
- __list_del(entry->prev, entry->next);
- entry->next = LIST_POISON1;
- entry->prev = LIST_POISON2;
+ entry->prev->next = entry->next;
+ entry->next->prev = entry->prev;
+ /*
+ * These non-NULL pointers result in page faults when dereferenced.
+ * This helps to catch bugs resulting from using deleted list heads.
+ */
+ entry->next = (void *)0x00100100;
+ entry->prev = (void *)0x00200200;
}
/**
* Delete an entry from one list and add it as another list's head.
*
- * \param list The entry to move.
+ * \param entry 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)
+static inline void list_move(struct list_head *entry, struct list_head *head)
{
- __list_del(list->prev, list->next);
- para_list_add(list, head);
+ list_del(entry);
+ para_list_add(entry, head);
}
/**
return head->next == head;
}
+/**
+ * Test whether a list has just one entry.
+ *
+ * \param head The list to test.
+ */
+static inline int list_is_singular(const struct list_head *head)
+{
+ return !list_empty(head) && (head->next == head->prev);
+}
+
/**
* Get the struct in which this entry is embedded in.
*
/**
* Iterate over a list.
*
- * \param pos A list head pointer which serves as the iterator.
+ * \param pos A struct pointer which serves as the iterator.
* \param head The head of the list.
* \param member The name of the list head member within the structure.
*/
/**
* Iterate over list, safe against removal of list entry.
*
- * \param pos The iterator.
- * \param n A list head pointer which is used as temporary storage.
+ * \param pos The iterator struct pointer.
+ * \param n A second struct pointer which is used as temporary storage.
* \param head The head of the list.
* \param member The name of the list head member within the structure.
*/
*/
#define list_first_entry(ptr, type, member) \
list_entry((ptr)->next, type, member)
-
-/**
- * Test whether a list has just one entry.
- *
- * \param head The list to test.
- */
-static inline int list_is_singular(const struct list_head *head)
-{
- return !list_empty(head) && (head->next == head->prev);
-}