WebSVN – Kolibri OS – Diff – /drivers/include/linux/list.h

 #ifndef _LINUX_LIST_H
 #define _LINUX_LIST_H
 #include
 #include
+#include
-//#include
-//#include
-//#include
+#define prefetch(x) __builtin_prefetch(x)
 /*
  * Simple doubly linked list implementation.
  * 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_POISON1   ((struct list_head*)0xFFFF0100)
-#define LIST_POISON2   ((struct list_head*)0xFFFF0200)
-#define prefetch(x) __builtin_prefetch(x)
-struct list_head {
-	struct list_head *next, *prev;
-};
 #define LIST_HEAD_INIT(name) { &(name), &(name) }
 	struct list_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
+ */
+static inline void list_rotate_left(struct list_head *head)
+{
+	struct list_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.
  */
 static inline int list_is_singular(const struct list_head *head)
 		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
+ * 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.
 		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
+ * 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.
 	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
+ * 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.
 	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).
- */
-struct hlist_head {
-	struct hlist_node *first;
-};
-struct hlist_node {
-	struct hlist_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)
+}
 static inline void hlist_del(struct hlist_node *n)
+{
 	__hlist_del(n);
-    n->next = (struct hlist_node*)LIST_POISON1;
+	n->next = LIST_POISON1;
-    n->pprev = (struct hlist_node**)LIST_POISON2;
+	n->pprev = LIST_POISON2;
+}
 static inline void hlist_del_init(struct hlist_node *n)
 	if(next->next)
 		next->next->pprev  = &next->next;
+}
+/* after that we'll appear to be on some hlist and hlist_del will work */
+static inline void hlist_add_fake(struct hlist_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.

Subversion Repositories Kolibri OS

(root)/drivers/include/linux/list.h – Rev 1408 → 1964