[netfilter-cvslog] r6296 - in branches/ulog/ulogd2: include/ulogd output src

laforge at netfilter.org laforge at netfilter.org
Mon Dec 5 15:55:47 CET 2005


Author: laforge at netfilter.org
Date: 2005-12-05 15:55:37 +0100 (Mon, 05 Dec 2005)
New Revision: 6296

Modified:
   branches/ulog/ulogd2/include/ulogd/linuxlist.h
   branches/ulog/ulogd2/include/ulogd/ulogd.h
   branches/ulog/ulogd2/output/ulogd_output_OPRINT.c
   branches/ulog/ulogd2/src/select.c
   branches/ulog/ulogd2/src/ulogd.c
Log:
rename all linux list related structs/functs/macros to 'llist', since mysql is now cluttering the namespace by its 'list_add' function.


Modified: branches/ulog/ulogd2/include/ulogd/linuxlist.h
===================================================================
--- branches/ulog/ulogd2/include/ulogd/linuxlist.h	2005-12-05 14:52:55 UTC (rev 6295)
+++ branches/ulog/ulogd2/include/ulogd/linuxlist.h	2005-12-05 14:55:37 UTC (rev 6296)
@@ -1,5 +1,5 @@
-#ifndef _LINUX_LIST_H
-#define _LINUX_LIST_H
+#ifndef _LINUX_LLIST_H
+#define _LINUX_LLIST_H
 
 #include <stddef.h>
 
@@ -25,43 +25,43 @@
 /*
  * 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-initialized llist entries.
  */
-#define LIST_POISON1  ((void *) 0x00100100)
-#define LIST_POISON2  ((void *) 0x00200200)
+#define LLIST_POISON1  ((void *) 0x00100100)
+#define LLIST_POISON2  ((void *) 0x00200200)
 
 /*
- * Simple doubly linked list implementation.
+ * Simple doubly linked llist implementation.
  *
  * Some of the internal functions ("__xxx") are useful when
- * manipulating whole lists rather than single entries, as
+ * manipulating whole llists 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.
  */
 
-struct list_head {
-	struct list_head *next, *prev;
+struct llist_head {
+	struct llist_head *next, *prev;
 };
 
-#define LIST_HEAD_INIT(name) { &(name), &(name) }
+#define LLIST_HEAD_INIT(name) { &(name), &(name) }
 
-#define LIST_HEAD(name) \
-	struct list_head name = LIST_HEAD_INIT(name)
+#define LLIST_HEAD(name) \
+	struct llist_head name = LLIST_HEAD_INIT(name)
 
-#define INIT_LIST_HEAD(ptr) do { \
+#define INIT_LLIST_HEAD(ptr) do { \
 	(ptr)->next = (ptr); (ptr)->prev = (ptr); \
 } while (0)
 
 /*
  * Insert a new entry between two known consecutive entries. 
  *
- * This is only for internal list manipulation where we know
+ * This is only for internal llist manipulation 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 __llist_add(struct llist_head *new,
+			      struct llist_head *prev,
+			      struct llist_head *next)
 {
 	next->prev = new;
 	new->next = next;
@@ -70,105 +70,105 @@
 }
 
 /**
- * list_add - add a new entry
+ * llist_add - add a new entry
  * @new: new entry to be added
- * @head: list head to add it after
+ * @head: llist head to add it after
  *
  * Insert a new entry after the specified head.
  * This is good for implementing stacks.
  */
-static inline void list_add(struct list_head *new, struct list_head *head)
+static inline void llist_add(struct llist_head *new, struct llist_head *head)
 {
-	__list_add(new, head, head->next);
+	__llist_add(new, head, head->next);
 }
 
 /**
- * list_add_tail - add a new entry
+ * llist_add_tail - add a new entry
  * @new: new entry to be added
- * @head: list head to add it before
+ * @head: llist head to add it before
  *
  * Insert a new entry before the specified head.
  * This is useful for implementing queues.
  */
-static inline void list_add_tail(struct list_head *new, struct list_head *head)
+static inline void llist_add_tail(struct llist_head *new, struct llist_head *head)
 {
-	__list_add(new, head->prev, head);
+	__llist_add(new, head->prev, head);
 }
 
 /*
- * Delete a list entry by making the prev/next entries
+ * Delete a llist entry by making the prev/next entries
  * point to each other.
  *
- * This is only for internal list manipulation where we know
+ * This is only for internal llist 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 __llist_del(struct llist_head * prev, struct llist_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
+ * llist_del - deletes entry from llist.
+ * @entry: the element to delete from the llist.
+ * Note: llist_empty on entry does not return true after this, the entry is
  * in an undefined state.
  */
-static inline void list_del(struct list_head *entry)
+static inline void llist_del(struct llist_head *entry)
 {
-	__list_del(entry->prev, entry->next);
-	entry->next = LIST_POISON1;
-	entry->prev = LIST_POISON2;
+	__llist_del(entry->prev, entry->next);
+	entry->next = LLIST_POISON1;
+	entry->prev = LLIST_POISON2;
 }
 
 /**
- * list_del_init - deletes entry from list and reinitialize it.
- * @entry: the element to delete from the list.
+ * llist_del_init - deletes entry from llist and reinitialize it.
+ * @entry: the element to delete from the llist.
  */
-static inline void list_del_init(struct list_head *entry)
+static inline void llist_del_init(struct llist_head *entry)
 {
-	__list_del(entry->prev, entry->next);
-	INIT_LIST_HEAD(entry); 
+	__llist_del(entry->prev, entry->next);
+	INIT_LLIST_HEAD(entry); 
 }
 
 /**
- * list_move - delete from one list and add as another's head
- * @list: the entry to move
+ * llist_move - delete from one llist and add as another's head
+ * @llist: the entry to move
  * @head: the head that will precede our entry
  */
-static inline void list_move(struct list_head *list, struct list_head *head)
+static inline void llist_move(struct llist_head *llist, struct llist_head *head)
 {
-        __list_del(list->prev, list->next);
-        list_add(list, head);
+        __llist_del(llist->prev, llist->next);
+        llist_add(llist, head);
 }
 
 /**
- * list_move_tail - delete from one list and add as another's tail
- * @list: the entry to move
+ * llist_move_tail - delete from one llist and add as another's tail
+ * @llist: the entry to move
  * @head: the head that will follow our entry
  */
-static inline void list_move_tail(struct list_head *list,
-				  struct list_head *head)
+static inline void llist_move_tail(struct llist_head *llist,
+				  struct llist_head *head)
 {
-        __list_del(list->prev, list->next);
-        list_add_tail(list, head);
+        __llist_del(llist->prev, llist->next);
+        llist_add_tail(llist, head);
 }
 
 /**
- * list_empty - tests whether a list is empty
- * @head: the list to test.
+ * llist_empty - tests whether a llist is empty
+ * @head: the llist to test.
  */
-static inline int list_empty(const struct list_head *head)
+static inline int llist_empty(const struct llist_head *head)
 {
 	return head->next == head;
 }
 
-static inline void __list_splice(struct list_head *list,
-				 struct list_head *head)
+static inline void __llist_splice(struct llist_head *llist,
+				 struct llist_head *head)
 {
-	struct list_head *first = list->next;
-	struct list_head *last = list->prev;
-	struct list_head *at = head->next;
+	struct llist_head *first = llist->next;
+	struct llist_head *last = llist->prev;
+	struct llist_head *at = head->next;
 
 	first->prev = head;
 	head->next = first;
@@ -178,181 +178,181 @@
 }
 
 /**
- * list_splice - join two lists
- * @list: the new list to add.
- * @head: the place to add it in the first list.
+ * llist_splice - join two llists
+ * @llist: the new llist to add.
+ * @head: the place to add it in the first llist.
  */
-static inline void list_splice(struct list_head *list, struct list_head *head)
+static inline void llist_splice(struct llist_head *llist, struct llist_head *head)
 {
-	if (!list_empty(list))
-		__list_splice(list, head);
+	if (!llist_empty(llist))
+		__llist_splice(llist, 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.
+ * llist_splice_init - join two llists and reinitialise the emptied llist.
+ * @llist: the new llist to add.
+ * @head: the place to add it in the first llist.
  *
- * The list at @list is reinitialised
+ * The llist at @llist is reinitialised
  */
-static inline void list_splice_init(struct list_head *list,
-				    struct list_head *head)
+static inline void llist_splice_init(struct llist_head *llist,
+				    struct llist_head *head)
 {
-	if (!list_empty(list)) {
-		__list_splice(list, head);
-		INIT_LIST_HEAD(list);
+	if (!llist_empty(llist)) {
+		__llist_splice(llist, head);
+		INIT_LLIST_HEAD(llist);
 	}
 }
 
 /**
- * list_entry - get the struct for this entry
- * @ptr:	the &struct list_head pointer.
+ * llist_entry - get the struct for this entry
+ * @ptr:	the &struct llist_head pointer.
  * @type:	the type of the struct this is embedded in.
- * @member:	the name of the list_struct within the struct.
+ * @member:	the name of the llist_struct within the struct.
  */
-#define list_entry(ptr, type, member) \
+#define llist_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 counter.
- * @head:	the head for your list.
+ * llist_for_each	-	iterate over a llist
+ * @pos:	the &struct llist_head to use as a loop counter.
+ * @head:	the head for your llist.
  */
-#define list_for_each(pos, head) \
+#define llist_for_each(pos, head) \
 	for (pos = (head)->next, prefetch(pos->next); pos != (head); \
         	pos = pos->next, prefetch(pos->next))
 
 /**
- * __list_for_each	-	iterate over a list
- * @pos:	the &struct list_head to use as a loop counter.
- * @head:	the head for your list.
+ * __llist_for_each	-	iterate over a llist
+ * @pos:	the &struct llist_head to use as a loop counter.
+ * @head:	the head for your llist.
  *
- * 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
+ * This variant differs from llist_for_each() in that it's the
+ * simplest possible llist iteration code, no prefetching is done.
+ * Use this for code that knows the llist to be very short (empty
  * or 1 entry) most of the time.
  */
-#define __list_for_each(pos, head) \
+#define __llist_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 counter.
- * @head:	the head for your list.
+ * llist_for_each_prev	-	iterate over a llist backwards
+ * @pos:	the &struct llist_head to use as a loop counter.
+ * @head:	the head for your llist.
  */
-#define list_for_each_prev(pos, head) \
+#define llist_for_each_prev(pos, head) \
 	for (pos = (head)->prev, prefetch(pos->prev); pos != (head); \
         	pos = pos->prev, prefetch(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 counter.
- * @n:		another &struct list_head to use as temporary storage
- * @head:	the head for your list.
+ * llist_for_each_safe	-	iterate over a llist safe against removal of llist entry
+ * @pos:	the &struct llist_head to use as a loop counter.
+ * @n:		another &struct llist_head to use as temporary storage
+ * @head:	the head for your llist.
  */
-#define list_for_each_safe(pos, n, head) \
+#define llist_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
+ * llist_for_each_entry	-	iterate over llist 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.
+ * @head:	the head for your llist.
+ * @member:	the name of the llist_struct within the struct.
  */
-#define list_for_each_entry(pos, head, member)				\
-	for (pos = list_entry((head)->next, typeof(*pos), member),	\
+#define llist_for_each_entry(pos, head, member)				\
+	for (pos = llist_entry((head)->next, typeof(*pos), member),	\
 		     prefetch(pos->member.next);			\
 	     &pos->member != (head); 					\
-	     pos = list_entry(pos->member.next, typeof(*pos), member),	\
+	     pos = llist_entry(pos->member.next, typeof(*pos), member),	\
 		     prefetch(pos->member.next))
 
 /**
- * list_for_each_entry_reverse - iterate backwards over list of given type.
+ * llist_for_each_entry_reverse - iterate backwards over llist 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.
+ * @head:	the head for your llist.
+ * @member:	the name of the llist_struct within the struct.
  */
-#define list_for_each_entry_reverse(pos, head, member)			\
-	for (pos = list_entry((head)->prev, typeof(*pos), member),	\
+#define llist_for_each_entry_reverse(pos, head, member)			\
+	for (pos = llist_entry((head)->prev, typeof(*pos), member),	\
 		     prefetch(pos->member.prev);			\
 	     &pos->member != (head); 					\
-	     pos = list_entry(pos->member.prev, typeof(*pos), member),	\
+	     pos = llist_entry(pos->member.prev, typeof(*pos), member),	\
 		     prefetch(pos->member.prev))
 
 /**
- * list_for_each_entry_continue -	iterate over list of given type
+ * llist_for_each_entry_continue -	iterate over llist of given type
  *			continuing after existing point
  * @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.
+ * @head:	the head for your llist.
+ * @member:	the name of the llist_struct within the struct.
  */
-#define list_for_each_entry_continue(pos, head, member) 		\
-	for (pos = list_entry(pos->member.next, typeof(*pos), member),	\
+#define llist_for_each_entry_continue(pos, head, member) 		\
+	for (pos = llist_entry(pos->member.next, typeof(*pos), member),	\
 		     prefetch(pos->member.next);			\
 	     &pos->member != (head);					\
-	     pos = list_entry(pos->member.next, typeof(*pos), member),	\
+	     pos = llist_entry(pos->member.next, typeof(*pos), member),	\
 		     prefetch(pos->member.next))
 
 /**
- * list_for_each_entry_safe - iterate over list of given type safe against removal of list entry
+ * llist_for_each_entry_safe - iterate over llist of given type safe against removal of llist 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.
+ * @head:	the head for your llist.
+ * @member:	the name of the llist_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);	\
+#define llist_for_each_entry_safe(pos, n, head, member)			\
+	for (pos = llist_entry((head)->next, typeof(*pos), member),	\
+		n = llist_entry(pos->member.next, typeof(*pos), member);	\
 	     &pos->member != (head); 					\
-	     pos = n, n = list_entry(n->member.next, typeof(*n), member))
+	     pos = n, n = llist_entry(n->member.next, typeof(*n), member))
 
 /**
- * list_for_each_rcu	-	iterate over an rcu-protected list
- * @pos:	the &struct list_head to use as a loop counter.
- * @head:	the head for your list.
+ * llist_for_each_rcu	-	iterate over an rcu-protected llist
+ * @pos:	the &struct llist_head to use as a loop counter.
+ * @head:	the head for your llist.
  */
-#define list_for_each_rcu(pos, head) \
+#define llist_for_each_rcu(pos, head) \
 	for (pos = (head)->next, prefetch(pos->next); pos != (head); \
         	pos = pos->next, ({ smp_read_barrier_depends(); 0;}), prefetch(pos->next))
         	
-#define __list_for_each_rcu(pos, head) \
+#define __llist_for_each_rcu(pos, head) \
 	for (pos = (head)->next; pos != (head); \
         	pos = pos->next, ({ smp_read_barrier_depends(); 0;}))
         	
 /**
- * list_for_each_safe_rcu	-	iterate over an rcu-protected 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.
+ * llist_for_each_safe_rcu	-	iterate over an rcu-protected llist safe
+ *					against removal of llist entry
+ * @pos:	the &struct llist_head to use as a loop counter.
+ * @n:		another &struct llist_head to use as temporary storage
+ * @head:	the head for your llist.
  */
-#define list_for_each_safe_rcu(pos, n, head) \
+#define llist_for_each_safe_rcu(pos, n, head) \
 	for (pos = (head)->next, n = pos->next; pos != (head); \
 		pos = n, ({ smp_read_barrier_depends(); 0;}), n = pos->next)
 
 /**
- * list_for_each_entry_rcu	-	iterate over rcu list of given type
+ * llist_for_each_entry_rcu	-	iterate over rcu llist 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.
+ * @head:	the head for your llist.
+ * @member:	the name of the llist_struct within the struct.
  */
-#define list_for_each_entry_rcu(pos, head, member)			\
-	for (pos = list_entry((head)->next, typeof(*pos), member),	\
+#define llist_for_each_entry_rcu(pos, head, member)			\
+	for (pos = llist_entry((head)->next, typeof(*pos), member),	\
 		     prefetch(pos->member.next);			\
 	     &pos->member != (head); 					\
-	     pos = list_entry(pos->member.next, typeof(*pos), member),	\
+	     pos = llist_entry(pos->member.next, typeof(*pos), member),	\
 		     ({ smp_read_barrier_depends(); 0;}),		\
 		     prefetch(pos->member.next))
 
 
 /**
- * list_for_each_continue_rcu	-	iterate over an rcu-protected list 
+ * llist_for_each_continue_rcu	-	iterate over an rcu-protected llist 
  *			continuing after existing point.
- * @pos:	the &struct list_head to use as a loop counter.
- * @head:	the head for your list.
+ * @pos:	the &struct llist_head to use as a loop counter.
+ * @head:	the head for your llist.
  */
-#define list_for_each_continue_rcu(pos, head) \
+#define llist_for_each_continue_rcu(pos, head) \
 	for ((pos) = (pos)->next, prefetch((pos)->next); (pos) != (head); \
         	(pos) = (pos)->next, ({ smp_read_barrier_depends(); 0;}), prefetch((pos)->next))
 

Modified: branches/ulog/ulogd2/include/ulogd/ulogd.h
===================================================================
--- branches/ulog/ulogd2/include/ulogd/ulogd.h	2005-12-05 14:52:55 UTC (rev 6295)
+++ branches/ulog/ulogd2/include/ulogd/ulogd.h	2005-12-05 14:55:37 UTC (rev 6296)
@@ -126,7 +126,7 @@
 struct ulogd_pluginstance;
 struct ulogd_plugin {
 	/* global list of plugins */
-	struct list_head list;
+	struct llist_head list;
 	/* version */
 	char *version;
 	/* name of this plugin (predefined by plugin) */
@@ -165,7 +165,7 @@
 /* an instance of a plugin, element in a stack */
 struct ulogd_pluginstance {
 	/* local list of plugins in this stack */
-	struct list_head list;
+	struct llist_head list;
 	/* plugin */
 	struct ulogd_plugin *plugin;
 	/* stack that we're part of */
@@ -184,9 +184,9 @@
 
 struct ulogd_pluginstance_stack {
 	/* global list of pluginstance stacks */
-	struct list_head stack_list;
+	struct llist_head stack_list;
 	/* list of plugins in this stack */
-	struct list_head list;
+	struct llist_head list;
 	char *name;
 };
 
@@ -236,7 +236,7 @@
 #define ULOGD_FD_EXCEPT	0x0004
 
 struct ulogd_fd {
-	struct list_head list;
+	struct llist_head list;
 	int fd;				/* file descriptor */
 	unsigned int when;
 	int (*cb)(int fd, unsigned int what, void *data);

Modified: branches/ulog/ulogd2/output/ulogd_output_OPRINT.c
===================================================================
--- branches/ulog/ulogd2/output/ulogd_output_OPRINT.c	2005-12-05 14:52:55 UTC (rev 6295)
+++ branches/ulog/ulogd2/output/ulogd_output_OPRINT.c	2005-12-05 14:55:37 UTC (rev 6296)
@@ -150,7 +150,7 @@
 	 * the inter-key pointers, everything will work as expected. */
 
 	/* first pass: count keys */
-	list_for_each_entry(pi_cur, &stack->list, list) {
+	llist_for_each_entry(pi_cur, &stack->list, list) {
 		ulogd_log(ULOGD_DEBUG, "iterating over pluginstance '%s'\n",
 			  pi_cur->id);
 		num_keys += pi_cur->plugin->output.num_keys;
@@ -162,7 +162,7 @@
 		return -ENOMEM;
 
 	/* second pass: copy key names */
-	list_for_each_entry(pi_cur, &stack->list, list) {
+	llist_for_each_entry(pi_cur, &stack->list, list) {
 		struct ulogd_key *cur;
 		int i;
 

Modified: branches/ulog/ulogd2/src/select.c
===================================================================
--- branches/ulog/ulogd2/src/select.c	2005-12-05 14:52:55 UTC (rev 6295)
+++ branches/ulog/ulogd2/src/select.c	2005-12-05 14:55:37 UTC (rev 6296)
@@ -26,7 +26,7 @@
 #include <ulogd/linuxlist.h>
 
 static int maxfd = 0;
-static LIST_HEAD(ulogd_fds);
+static LLIST_HEAD(ulogd_fds);
 
 int ulogd_register_fd(struct ulogd_fd *fd)
 {
@@ -45,14 +45,14 @@
 	if (fd->fd > maxfd)
 		maxfd = fd->fd;
 
-	list_add_tail(&fd->list, &ulogd_fds);
+	llist_add_tail(&fd->list, &ulogd_fds);
 
 	return 0;
 }
 
 void ulogd_unregister_fd(struct ulogd_fd *fd)
 {
-	list_del(&fd->list);
+	llist_del(&fd->list);
 }
 
 int ulogd_select_main()
@@ -66,7 +66,7 @@
 	FD_ZERO(&exceptset);
 
 	/* prepare read and write fdsets */
-	list_for_each_entry(ufd, &ulogd_fds, list) {
+	llist_for_each_entry(ufd, &ulogd_fds, list) {
 		if (ufd->when & ULOGD_FD_READ)
 			FD_SET(ufd->fd, &readset);
 
@@ -80,7 +80,7 @@
 	i = select(maxfd+1, &readset, &writeset, &exceptset, NULL);
 	if (i > 0) {
 		/* call registered callback functions */
-		list_for_each_entry(ufd, &ulogd_fds, list) {
+		llist_for_each_entry(ufd, &ulogd_fds, list) {
 			int flags = 0;
 
 			if (FD_ISSET(ufd->fd, &readset))

Modified: branches/ulog/ulogd2/src/ulogd.c
===================================================================
--- branches/ulog/ulogd2/src/ulogd.c	2005-12-05 14:52:55 UTC (rev 6295)
+++ branches/ulog/ulogd2/src/ulogd.c	2005-12-05 14:55:37 UTC (rev 6296)
@@ -89,8 +89,8 @@
 static FILE *syslog_dummy;
 
 /* linked list for all registered plugins */
-static LIST_HEAD(ulogd_plugins);
-static LIST_HEAD(ulogd_pi_stacks);
+static LLIST_HEAD(ulogd_plugins);
+static LLIST_HEAD(ulogd_pi_stacks);
 
 
 static int load_plugin(char *file);
@@ -141,7 +141,7 @@
 {
 	struct ulogd_plugin *pl;
 
-	list_for_each_entry(pl, &ulogd_plugins, list) {
+	llist_for_each_entry(pl, &ulogd_plugins, list) {
 		if (strcmp(name, pl->name) == 0)
 			return pl;
 	}
@@ -163,7 +163,7 @@
 		exit(EXIT_FAILURE);
 	}
 	ulogd_log(ULOGD_NOTICE, "registering plugin `%s'\n", me->name);
-	list_add(&me->list, &ulogd_plugins);
+	llist_add(&me->list, &ulogd_plugins);
 }
 
 /***********************************************************************
@@ -238,7 +238,7 @@
 {
 	struct ulogd_pluginstance *cur = pi;
 	/* iterate over remaining plugin stack */
-	list_for_each_entry_continue(cur, &pi->stack->list, list) {
+	llist_for_each_entry_continue(cur, &pi->stack->list, list) {
 		int ret;
 		
 		ret = cur->plugin->interp(cur);
@@ -303,7 +303,7 @@
 
 	/* initialize */
 	memset(pi, 0, size);
-	INIT_LIST_HEAD(&pi->list);
+	INIT_LLIST_HEAD(&pi->list);
 	pi->plugin = pl;
 	pi->stack = stack;
 	memcpy(pi->id, pi_id, sizeof(pi->id));
@@ -366,7 +366,7 @@
 {
 	struct ulogd_pluginstance *pi;
 
-	list_for_each_entry_reverse(pi, &start->list, list) {
+	llist_for_each_entry_reverse(pi, &start->list, list) {
 		int i;
 
 		if ((void *)&pi->list == &stack->list)
@@ -394,9 +394,9 @@
 
 	/* PASS 2: */
 	ulogd_log(ULOGD_DEBUG, "connecting input/output keys of stack:\n");
-	list_for_each_entry_reverse(pi_cur, &stack->list, list) {
+	llist_for_each_entry_reverse(pi_cur, &stack->list, list) {
 		struct ulogd_pluginstance *pi_prev = 
-					list_entry(pi_cur->list.prev,
+					llist_entry(pi_cur->list.prev,
 						   struct ulogd_pluginstance,
 						   list);
 		i++;
@@ -490,7 +490,7 @@
 	struct ulogd_pluginstance *pi;
 
 	/* start from input to output plugin */
-	list_for_each_entry(pi, &stack->list, list) {
+	llist_for_each_entry(pi, &stack->list, list) {
 		if (!pi->plugin->start)
 			continue;
 
@@ -520,7 +520,7 @@
 	stack = malloc(sizeof(*stack));
 	if (!stack)
 		return -ENOMEM;
-	INIT_LIST_HEAD(&stack->list);
+	INIT_LLIST_HEAD(&stack->list);
 
 	ulogd_log(ULOGD_DEBUG, "building new pluginstance stack (%s):\n",
 		  option);
@@ -569,7 +569,7 @@
 		 * fix up input/output keys */
 			
 		ulogd_log(ULOGD_DEBUG, "pushing `%s' on stack\n", pl->name);
-		list_add_tail(&pi->list, &stack->list);
+		llist_add_tail(&pi->list, &stack->list);
 	}
 
 	/* PASS 2: resolve key connections from bottom to top of stack */
@@ -589,7 +589,7 @@
 	}
 
 	/* add head of pluginstance stack to list of stacks */
-	list_add(&stack->stack_list, &ulogd_pi_stacks);
+	llist_add(&stack->stack_list, &ulogd_pi_stacks);
 	return 0;
 }
 	
@@ -680,8 +680,8 @@
 	struct ulogd_pluginstance_stack *stack;
 	struct ulogd_pluginstance *pi;
 
-	list_for_each_entry(stack, &ulogd_pi_stacks, stack_list) {
-		list_for_each_entry(pi, &stack->list, list) {
+	llist_for_each_entry(stack, &ulogd_pi_stacks, stack_list) {
+		llist_for_each_entry(pi, &stack->list, list) {
 			if (pi->plugin->signal)
 				(*pi->plugin->signal)(pi, signal);
 		}
@@ -806,7 +806,7 @@
 		exit(1);
 	}
 
-	if (list_empty(&ulogd_pi_stacks)) {
+	if (llist_empty(&ulogd_pi_stacks)) {
 		ulogd_log(ULOGD_FATAL, 
 			  "not even a single working plugin stack\n");
 		exit(1);




More information about the netfilter-cvslog mailing list