D49970.diff
No OneTemporary
Actions

Size

29 KB

Referenced Files

None

Subscribers

None

D49970.diff
View Options

	diff --git a/sys/sys/queue.h b/sys/sys/queue.h
	--- a/sys/sys/queue.h
	+++ b/sys/sys/queue.h
	@@ -30,7 +30,7 @@
	*/

	#ifndef _SYS_QUEUE_H_
	-#define _SYS_QUEUE_H_
	+#define _SYS_QUEUE_H_

	#include <sys/cdefs.h>

	@@ -117,8 +117,8 @@
	*/
	#ifdef QUEUE_MACRO_DEBUG
	#warn Use QUEUE_MACRO_DEBUG_TRACE and/or QUEUE_MACRO_DEBUG_TRASH
	-#define QUEUE_MACRO_DEBUG_TRACE
	-#define QUEUE_MACRO_DEBUG_TRASH
	+#define QUEUE_MACRO_DEBUG_TRACE
	+#define QUEUE_MACRO_DEBUG_TRASH
	#endif

	#ifdef QUEUE_MACRO_DEBUG_TRACE
	@@ -130,17 +130,17 @@
	const char *prevfile;
	};

	-#define TRACEBUF struct qm_trace trace;
	-#define TRACEBUF_INITIALIZER { __LINE__, 0, __FILE__, NULL } ,
	+#define TRACEBUF struct qm_trace trace;
	+#define TRACEBUF_INITIALIZER { __LINE__, 0, __FILE__, NULL } ,

	-#define QMD_TRACE_HEAD(head) do { \
	+#define QMD_TRACE_HEAD(head) do { \
	(head)->trace.prevline = (head)->trace.lastline; \
	(head)->trace.prevfile = (head)->trace.lastfile; \
	(head)->trace.lastline = __LINE__; \
	(head)->trace.lastfile = __FILE__; \
	} while (0)

	-#define QMD_TRACE_ELEM(elem) do { \
	+#define QMD_TRACE_ELEM(elem) do { \
	(elem)->trace.prevline = (elem)->trace.lastline; \
	(elem)->trace.prevfile = (elem)->trace.lastfile; \
	(elem)->trace.lastline = __LINE__; \
	@@ -148,53 +148,53 @@
	} while (0)

	#else /* !QUEUE_MACRO_DEBUG_TRACE */
	-#define QMD_TRACE_ELEM(elem)
	-#define QMD_TRACE_HEAD(head)
	-#define TRACEBUF
	-#define TRACEBUF_INITIALIZER
	+#define QMD_TRACE_ELEM(elem)
	+#define QMD_TRACE_HEAD(head)
	+#define TRACEBUF
	+#define TRACEBUF_INITIALIZER
	#endif /* QUEUE_MACRO_DEBUG_TRACE */

	#ifdef QUEUE_MACRO_DEBUG_TRASH
	-#define QMD_SAVELINK(name, link) void *name = (void )&(link)
	-#define TRASHIT(x) do {(x) = (void *)-1;} while (0)
	-#define QMD_IS_TRASHED(x) ((x) == (void *)(intptr_t)-1)
	+#define QMD_SAVELINK(name, link) void *name = (void )&(link)
	+#define TRASHIT(x) do {(x) = (void *)-1;} while (0)
	+#define QMD_IS_TRASHED(x) ((x) == (void *)(intptr_t)-1)
	#else /* !QUEUE_MACRO_DEBUG_TRASH */
	-#define QMD_SAVELINK(name, link)
	-#define TRASHIT(x)
	-#define QMD_IS_TRASHED(x) 0
	+#define QMD_SAVELINK(name, link)
	+#define TRASHIT(x)
	+#define QMD_IS_TRASHED(x) 0
	#endif /* QUEUE_MACRO_DEBUG_TRASH */

	#ifdef __cplusplus
	/*
	* In C++ there can be structure lists and class lists:
	*/
	-#define QUEUE_TYPEOF(type) type
	+#define QUEUE_TYPEOF(type) type
	#else
	-#define QUEUE_TYPEOF(type) struct type
	+#define QUEUE_TYPEOF(type) struct type
	#endif

	/*
	* Singly-linked List declarations.
	*/
	-#define SLIST_HEAD(name, type) \
	+#define SLIST_HEAD(name, type) \
	struct name { \
	struct type slh_first; / first element */ \
	}

	-#define SLIST_CLASS_HEAD(name, type) \
	+#define SLIST_CLASS_HEAD(name, type) \
	struct name { \
	class type slh_first; / first element */ \
	}

	-#define SLIST_HEAD_INITIALIZER(head) \
	+#define SLIST_HEAD_INITIALIZER(head) \
	{ NULL }

	-#define SLIST_ENTRY(type) \
	+#define SLIST_ENTRY(type) \
	struct { \
	struct type sle_next; / next element */ \
	}

	-#define SLIST_CLASS_ENTRY(type) \
	+#define SLIST_CLASS_ENTRY(type) \
	struct { \
	class type sle_next; / next element */ \
	}
	@@ -204,26 +204,26 @@
	*/
	#if (defined(_KERNEL) && defined(INVARIANTS))

	-#define QMD_SLIST_CHECK_PREVPTR(prevp, elm) do { \
	+#define QMD_SLIST_CHECK_PREVPTR(prevp, elm) do { \
	if (*(prevp) != (elm)) \
	panic("Bad prevptr *(%p) == %p != %p", \
	(prevp), *(prevp), (elm)); \
	} while (0)

	-#define SLIST_ASSERT_EMPTY(head) do { \
	+#define SLIST_ASSERT_EMPTY(head) do { \
	if (!SLIST_EMPTY((head))) \
	panic("slist %p is not empty", (head)); \
	} while (0)

	-#define SLIST_ASSERT_NONEMPTY(head) do { \
	+#define SLIST_ASSERT_NONEMPTY(head) do { \
	if (SLIST_EMPTY((head))) \
	panic("slist %p is empty", (head)); \
	} while (0)

	#else
	-#define QMD_SLIST_CHECK_PREVPTR(prevp, elm)
	-#define SLIST_ASSERT_EMPTY(head)
	-#define SLIST_ASSERT_NONEMPTY(head)
	+#define QMD_SLIST_CHECK_PREVPTR(prevp, elm)
	+#define SLIST_ASSERT_EMPTY(head)
	+#define SLIST_ASSERT_NONEMPTY(head)
	#endif


	@@ -240,55 +240,55 @@
	} \
	} while (0)

	-#define SLIST_EMPTY(head) ((head)->slh_first == NULL)
	+#define SLIST_EMPTY(head) ((head)->slh_first == NULL)

	-#define SLIST_EMPTY_ATOMIC(head) \
	+#define SLIST_EMPTY_ATOMIC(head) \
	(atomic_load_ptr(&(head)->slh_first) == NULL)

	-#define SLIST_FIRST(head) ((head)->slh_first)
	+#define SLIST_FIRST(head) ((head)->slh_first)

	-#define SLIST_FOREACH(var, head, field) \
	+#define SLIST_FOREACH(var, head, field) \
	for ((var) = SLIST_FIRST((head)); \
	(var); \
	(var) = SLIST_NEXT((var), field))

	-#define SLIST_FOREACH_FROM(var, head, field) \
	+#define SLIST_FOREACH_FROM(var, head, field) \
	for ((var) = ((var) ? (var) : SLIST_FIRST((head))); \
	(var); \
	(var) = SLIST_NEXT((var), field))

	-#define SLIST_FOREACH_SAFE(var, head, field, tvar) \
	+#define SLIST_FOREACH_SAFE(var, head, field, tvar) \
	for ((var) = SLIST_FIRST((head)); \
	(var) && ((tvar) = SLIST_NEXT((var), field), 1); \
	(var) = (tvar))

	-#define SLIST_FOREACH_FROM_SAFE(var, head, field, tvar) \
	+#define SLIST_FOREACH_FROM_SAFE(var, head, field, tvar) \
	for ((var) = ((var) ? (var) : SLIST_FIRST((head))); \
	(var) && ((tvar) = SLIST_NEXT((var), field), 1); \
	(var) = (tvar))

	-#define SLIST_FOREACH_PREVPTR(var, varp, head, field) \
	+#define SLIST_FOREACH_PREVPTR(var, varp, head, field) \
	for ((varp) = &SLIST_FIRST((head)); \
	((var) = *(varp)) != NULL; \
	(varp) = &SLIST_NEXT((var), field))

	-#define SLIST_INIT(head) do { \
	+#define SLIST_INIT(head) do { \
	SLIST_FIRST((head)) = NULL; \
	} while (0)

	-#define SLIST_INSERT_AFTER(slistelm, elm, field) do { \
	+#define SLIST_INSERT_AFTER(slistelm, elm, field) do { \
	SLIST_NEXT((elm), field) = SLIST_NEXT((slistelm), field); \
	SLIST_NEXT((slistelm), field) = (elm); \
	} while (0)

	-#define SLIST_INSERT_HEAD(head, elm, field) do { \
	+#define SLIST_INSERT_HEAD(head, elm, field) do { \
	SLIST_NEXT((elm), field) = SLIST_FIRST((head)); \
	SLIST_FIRST((head)) = (elm); \
	} while (0)

	-#define SLIST_NEXT(elm, field) ((elm)->field.sle_next)
	+#define SLIST_NEXT(elm, field) ((elm)->field.sle_next)

	-#define SLIST_REMOVE(head, elm, type, field) do { \
	+#define SLIST_REMOVE(head, elm, type, field) do { \
	if (SLIST_FIRST((head)) == (elm)) { \
	SLIST_REMOVE_HEAD((head), field); \
	} \
	@@ -307,19 +307,19 @@
	TRASHIT(*oldnext); \
	} while (0)

	-#define SLIST_REMOVE_HEAD(head, field) do { \
	+#define SLIST_REMOVE_HEAD(head, field) do { \
	QMD_SAVELINK(oldnext, SLIST_FIRST(head)->field.sle_next); \
	SLIST_FIRST((head)) = SLIST_NEXT(SLIST_FIRST((head)), field); \
	TRASHIT(*oldnext); \
	} while (0)

	-#define SLIST_REMOVE_PREVPTR(prevp, elm, field) do { \
	+#define SLIST_REMOVE_PREVPTR(prevp, elm, field) do { \
	QMD_SLIST_CHECK_PREVPTR(prevp, elm); \
	*(prevp) = SLIST_NEXT(elm, field); \
	TRASHIT((elm)->field.sle_next); \
	} while (0)

	-#define SLIST_SPLIT_AFTER(head, elm, rest, field) do { \
	+#define SLIST_SPLIT_AFTER(head, elm, rest, field) do { \
	SLIST_ASSERT_NONEMPTY((head)); \
	SLIST_FIRST((rest)) = SLIST_NEXT((elm), field); \
	SLIST_NEXT((elm), field) = NULL; \
	@@ -331,32 +331,32 @@
	SLIST_FIRST(head2) = swap_first; \
	} while (0)

	-#define SLIST_END(head) NULL
	+#define SLIST_END(head) NULL

	/*
	* Singly-linked Tail queue declarations.
	*/
	-#define STAILQ_HEAD(name, type) \
	+#define STAILQ_HEAD(name, type) \
	struct name { \
	struct type stqh_first;/ first element */ \
	struct type *stqh_last;/ addr of last next element */ \
	}

	-#define STAILQ_CLASS_HEAD(name, type) \
	+#define STAILQ_CLASS_HEAD(name, type) \
	struct name { \
	class type stqh_first; / first element */ \
	class type *stqh_last; / addr of last next element */ \
	}

	-#define STAILQ_HEAD_INITIALIZER(head) \
	+#define STAILQ_HEAD_INITIALIZER(head) \
	{ NULL, &(head).stqh_first }

	-#define STAILQ_ENTRY(type) \
	+#define STAILQ_ENTRY(type) \
	struct { \
	struct type stqe_next; / next element */ \
	}

	-#define STAILQ_CLASS_ENTRY(type) \
	+#define STAILQ_CLASS_ENTRY(type) \
	struct { \
	class type stqe_next; / next element */ \
	}
	@@ -371,7 +371,7 @@
	* Validates that the stailq head's pointer to the last element's next pointer
	* actually points to the head's first element pointer field.
	*/
	-#define QMD_STAILQ_CHECK_EMPTY(head) do { \
	+#define QMD_STAILQ_CHECK_EMPTY(head) do { \
	if ((head)->stqh_last != &(head)->stqh_first) \
	panic("Empty stailq %p->stqh_last is %p, not head's " \
	"first field address", (head), (head)->stqh_last); \
	@@ -382,30 +382,30 @@
	*
	* Validates that the stailq's last element's next pointer is NULL.
	*/
	-#define QMD_STAILQ_CHECK_TAIL(head) do { \
	+#define QMD_STAILQ_CHECK_TAIL(head) do { \
	if (*(head)->stqh_last != NULL) \
	panic("Stailq %p last element's next pointer is %p, " \
	"not NULL", (head), *(head)->stqh_last); \
	} while (0)

	-#define STAILQ_ASSERT_EMPTY(head) do { \
	+#define STAILQ_ASSERT_EMPTY(head) do { \
	if (!STAILQ_EMPTY((head))) \
	panic("stailq %p is not empty", (head)); \
	} while (0)

	-#define STAILQ_ASSERT_NONEMPTY(head) do { \
	+#define STAILQ_ASSERT_NONEMPTY(head) do { \
	if (STAILQ_EMPTY((head))) \
	panic("stailq %p is empty", (head)); \
	} while (0)

	#else
	-#define QMD_STAILQ_CHECK_EMPTY(head)
	-#define QMD_STAILQ_CHECK_TAIL(head)
	-#define STAILQ_ASSERT_EMPTY(head)
	-#define STAILQ_ASSERT_NONEMPTY(head)
	+#define QMD_STAILQ_CHECK_EMPTY(head)
	+#define QMD_STAILQ_CHECK_TAIL(head)
	+#define STAILQ_ASSERT_EMPTY(head)
	+#define STAILQ_ASSERT_NONEMPTY(head)
	#endif /* _KERNEL && INVARIANTS */

	-#define STAILQ_CONCAT(head1, head2) do { \
	+#define STAILQ_CONCAT(head1, head2) do { \
	if (!STAILQ_EMPTY((head2))) { \
	*(head1)->stqh_last = (head2)->stqh_first; \
	(head1)->stqh_last = (head2)->stqh_last; \
	@@ -413,69 +413,69 @@
	} \
	} while (0)

	-#define STAILQ_EMPTY(head) ({ \
	+#define STAILQ_EMPTY(head) ({ \
	if (STAILQ_FIRST(head) == NULL) \
	QMD_STAILQ_CHECK_EMPTY(head); \
	STAILQ_FIRST(head) == NULL; \
	})

	-#define STAILQ_EMPTY_ATOMIC(head) \
	+#define STAILQ_EMPTY_ATOMIC(head) \
	(atomic_load_ptr(&(head)->stqh_first) == NULL)

	-#define STAILQ_FIRST(head) ((head)->stqh_first)
	+#define STAILQ_FIRST(head) ((head)->stqh_first)

	-#define STAILQ_FOREACH(var, head, field) \
	+#define STAILQ_FOREACH(var, head, field) \
	for((var) = STAILQ_FIRST((head)); \
	(var); \
	(var) = STAILQ_NEXT((var), field))

	-#define STAILQ_FOREACH_FROM(var, head, field) \
	+#define STAILQ_FOREACH_FROM(var, head, field) \
	for ((var) = ((var) ? (var) : STAILQ_FIRST((head))); \
	(var); \
	(var) = STAILQ_NEXT((var), field))

	-#define STAILQ_FOREACH_SAFE(var, head, field, tvar) \
	+#define STAILQ_FOREACH_SAFE(var, head, field, tvar) \
	for ((var) = STAILQ_FIRST((head)); \
	(var) && ((tvar) = STAILQ_NEXT((var), field), 1); \
	(var) = (tvar))

	-#define STAILQ_FOREACH_FROM_SAFE(var, head, field, tvar) \
	+#define STAILQ_FOREACH_FROM_SAFE(var, head, field, tvar) \
	for ((var) = ((var) ? (var) : STAILQ_FIRST((head))); \
	(var) && ((tvar) = STAILQ_NEXT((var), field), 1); \
	(var) = (tvar))

	-#define STAILQ_INIT(head) do { \
	+#define STAILQ_INIT(head) do { \
	STAILQ_FIRST((head)) = NULL; \
	(head)->stqh_last = &STAILQ_FIRST((head)); \
	} while (0)

	-#define STAILQ_INSERT_AFTER(head, tqelm, elm, field) do { \
	+#define STAILQ_INSERT_AFTER(head, tqelm, elm, field) do { \
	if ((STAILQ_NEXT((elm), field) = STAILQ_NEXT((tqelm), field)) == NULL)\
	(head)->stqh_last = &STAILQ_NEXT((elm), field); \
	STAILQ_NEXT((tqelm), field) = (elm); \
	} while (0)

	-#define STAILQ_INSERT_HEAD(head, elm, field) do { \
	+#define STAILQ_INSERT_HEAD(head, elm, field) do { \
	if ((STAILQ_NEXT((elm), field) = STAILQ_FIRST((head))) == NULL) \
	(head)->stqh_last = &STAILQ_NEXT((elm), field); \
	STAILQ_FIRST((head)) = (elm); \
	} while (0)

	-#define STAILQ_INSERT_TAIL(head, elm, field) do { \
	+#define STAILQ_INSERT_TAIL(head, elm, field) do { \
	QMD_STAILQ_CHECK_TAIL(head); \
	STAILQ_NEXT((elm), field) = NULL; \
	*(head)->stqh_last = (elm); \
	(head)->stqh_last = &STAILQ_NEXT((elm), field); \
	} while (0)

	-#define STAILQ_LAST(head, type, field) \
	+#define STAILQ_LAST(head, type, field) \
	(STAILQ_EMPTY((head)) ? NULL : \
	__containerof((head)->stqh_last, \
	QUEUE_TYPEOF(type), field.stqe_next))

	-#define STAILQ_NEXT(elm, field) ((elm)->field.stqe_next)
	+#define STAILQ_NEXT(elm, field) ((elm)->field.stqe_next)

	-#define STAILQ_REMOVE(head, elm, type, field) do { \
	+#define STAILQ_REMOVE(head, elm, type, field) do { \
	QMD_SAVELINK(oldnext, (elm)->field.stqe_next); \
	if (STAILQ_FIRST((head)) == (elm)) { \
	STAILQ_REMOVE_HEAD((head), field); \
	@@ -495,13 +495,13 @@
	(head)->stqh_last = &STAILQ_NEXT((elm), field); \
	} while (0)

	-#define STAILQ_REMOVE_HEAD(head, field) do { \
	+#define STAILQ_REMOVE_HEAD(head, field) do { \
	if ((STAILQ_FIRST((head)) = \
	STAILQ_NEXT(STAILQ_FIRST((head)), field)) == NULL) \
	(head)->stqh_last = &STAILQ_FIRST((head)); \
	} while (0)

	-#define STAILQ_SPLIT_AFTER(head, elm, rest, field) do { \
	+#define STAILQ_SPLIT_AFTER(head, elm, rest, field) do { \
	STAILQ_ASSERT_NONEMPTY((head)); \
	QMD_STAILQ_CHECK_TAIL((head)); \
	if (STAILQ_NEXT((elm), field) == NULL) \
	@@ -528,32 +528,32 @@
	(head2)->stqh_last = &STAILQ_FIRST(head2); \
	} while (0)

	-#define STAILQ_END(head) NULL
	+#define STAILQ_END(head) NULL


	/*
	* List declarations.
	*/
	-#define LIST_HEAD(name, type) \
	+#define LIST_HEAD(name, type) \
	struct name { \
	struct type lh_first; / first element */ \
	}

	-#define LIST_CLASS_HEAD(name, type) \
	+#define LIST_CLASS_HEAD(name, type) \
	struct name { \
	class type lh_first; / first element */ \
	}

	-#define LIST_HEAD_INITIALIZER(head) \
	+#define LIST_HEAD_INITIALIZER(head) \
	{ NULL }

	-#define LIST_ENTRY(type) \
	+#define LIST_ENTRY(type) \
	struct { \
	struct type le_next; / next element */ \
	struct type *le_prev; / address of previous next element */ \
	}

	-#define LIST_CLASS_ENTRY(type) \
	+#define LIST_CLASS_ENTRY(type) \
	struct { \
	class type le_next; / next element */ \
	class type *le_prev; / address of previous next element */ \
	@@ -570,7 +570,7 @@
	* If the list is non-empty, validates that the first element of the list
	* points back at 'head.'
	*/
	-#define QMD_LIST_CHECK_HEAD(head, field) do { \
	+#define QMD_LIST_CHECK_HEAD(head, field) do { \
	if (LIST_FIRST((head)) != NULL && \
	LIST_FIRST((head))->field.le_prev != \
	&LIST_FIRST((head))) \
	@@ -583,7 +583,7 @@
	* If an element follows 'elm' in the list, validates that the next element
	* points back at 'elm.'
	*/
	-#define QMD_LIST_CHECK_NEXT(elm, field) do { \
	+#define QMD_LIST_CHECK_NEXT(elm, field) do { \
	if (LIST_NEXT((elm), field) != NULL && \
	LIST_NEXT((elm), field)->field.le_prev != \
	&((elm)->field.le_next)) \
	@@ -595,27 +595,27 @@
	*
	* Validates that the previous element (or head of the list) points to 'elm.'
	*/
	-#define QMD_LIST_CHECK_PREV(elm, field) do { \
	+#define QMD_LIST_CHECK_PREV(elm, field) do { \
	if (*(elm)->field.le_prev != (elm)) \
	panic("Bad link elm %p prev->next != elm", (elm)); \
	} while (0)

	-#define LIST_ASSERT_EMPTY(head) do { \
	+#define LIST_ASSERT_EMPTY(head) do { \
	if (!LIST_EMPTY((head))) \
	panic("list %p is not empty", (head)); \
	} while (0)

	-#define LIST_ASSERT_NONEMPTY(head) do { \
	+#define LIST_ASSERT_NONEMPTY(head) do { \
	if (LIST_EMPTY((head))) \
	panic("list %p is empty", (head)); \
	} while (0)

	#else
	-#define QMD_LIST_CHECK_HEAD(head, field)
	-#define QMD_LIST_CHECK_NEXT(elm, field)
	-#define QMD_LIST_CHECK_PREV(elm, field)
	-#define LIST_ASSERT_EMPTY(head)
	-#define LIST_ASSERT_NONEMPTY(head)
	+#define QMD_LIST_CHECK_HEAD(head, field)
	+#define QMD_LIST_CHECK_NEXT(elm, field)
	+#define QMD_LIST_CHECK_PREV(elm, field)
	+#define LIST_ASSERT_EMPTY(head)
	+#define LIST_ASSERT_NONEMPTY(head)
	#endif /* (_KERNEL && INVARIANTS) */

	#define LIST_CONCAT(head1, head2, type, field) do { \
	@@ -635,38 +635,38 @@
	} \
	} while (0)

	-#define LIST_EMPTY(head) ((head)->lh_first == NULL)
	+#define LIST_EMPTY(head) ((head)->lh_first == NULL)

	-#define LIST_EMPTY_ATOMIC(head) \
	+#define LIST_EMPTY_ATOMIC(head) \
	(atomic_load_ptr(&(head)->lh_first) == NULL)

	-#define LIST_FIRST(head) ((head)->lh_first)
	+#define LIST_FIRST(head) ((head)->lh_first)

	-#define LIST_FOREACH(var, head, field) \
	+#define LIST_FOREACH(var, head, field) \
	for ((var) = LIST_FIRST((head)); \
	(var); \
	(var) = LIST_NEXT((var), field))

	-#define LIST_FOREACH_FROM(var, head, field) \
	+#define LIST_FOREACH_FROM(var, head, field) \
	for ((var) = ((var) ? (var) : LIST_FIRST((head))); \
	(var); \
	(var) = LIST_NEXT((var), field))

	-#define LIST_FOREACH_SAFE(var, head, field, tvar) \
	+#define LIST_FOREACH_SAFE(var, head, field, tvar) \
	for ((var) = LIST_FIRST((head)); \
	(var) && ((tvar) = LIST_NEXT((var), field), 1); \
	(var) = (tvar))

	-#define LIST_FOREACH_FROM_SAFE(var, head, field, tvar) \
	+#define LIST_FOREACH_FROM_SAFE(var, head, field, tvar) \
	for ((var) = ((var) ? (var) : LIST_FIRST((head))); \
	(var) && ((tvar) = LIST_NEXT((var), field), 1); \
	(var) = (tvar))

	-#define LIST_INIT(head) do { \
	+#define LIST_INIT(head) do { \
	LIST_FIRST((head)) = NULL; \
	} while (0)

	-#define LIST_INSERT_AFTER(listelm, elm, field) do { \
	+#define LIST_INSERT_AFTER(listelm, elm, field) do { \
	QMD_LIST_CHECK_NEXT(listelm, field); \
	if ((LIST_NEXT((elm), field) = LIST_NEXT((listelm), field)) != NULL)\
	LIST_NEXT((listelm), field)->field.le_prev = \
	@@ -675,7 +675,7 @@
	(elm)->field.le_prev = &LIST_NEXT((listelm), field); \
	} while (0)

	-#define LIST_INSERT_BEFORE(listelm, elm, field) do { \
	+#define LIST_INSERT_BEFORE(listelm, elm, field) do { \
	QMD_LIST_CHECK_PREV(listelm, field); \
	(elm)->field.le_prev = (listelm)->field.le_prev; \
	LIST_NEXT((elm), field) = (listelm); \
	@@ -683,7 +683,7 @@
	(listelm)->field.le_prev = &LIST_NEXT((elm), field); \
	} while (0)

	-#define LIST_INSERT_HEAD(head, elm, field) do { \
	+#define LIST_INSERT_HEAD(head, elm, field) do { \
	QMD_LIST_CHECK_HEAD((head), field); \
	if ((LIST_NEXT((elm), field) = LIST_FIRST((head))) != NULL) \
	LIST_FIRST((head))->field.le_prev = &LIST_NEXT((elm), field);\
	@@ -691,9 +691,9 @@
	(elm)->field.le_prev = &LIST_FIRST((head)); \
	} while (0)

	-#define LIST_NEXT(elm, field) ((elm)->field.le_next)
	+#define LIST_NEXT(elm, field) ((elm)->field.le_next)

	-#define LIST_PREV(elm, head, type, field) \
	+#define LIST_PREV(elm, head, type, field) \
	((elm)->field.le_prev == &LIST_FIRST((head)) ? NULL : \
	__containerof((elm)->field.le_prev, \
	QUEUE_TYPEOF(type), field.le_next))
	@@ -701,7 +701,7 @@
	#define LIST_REMOVE_HEAD(head, field) \
	LIST_REMOVE(LIST_FIRST(head), field)

	-#define LIST_REMOVE(elm, field) do { \
	+#define LIST_REMOVE(elm, field) do { \
	QMD_SAVELINK(oldnext, (elm)->field.le_next); \
	QMD_SAVELINK(oldprev, (elm)->field.le_prev); \
	QMD_LIST_CHECK_NEXT(elm, field); \
	@@ -729,7 +729,7 @@
	TRASHIT(*oldprev); \
	} while (0)

	-#define LIST_SPLIT_AFTER(head, elm, rest, field) do { \
	+#define LIST_SPLIT_AFTER(head, elm, rest, field) do { \
	LIST_ASSERT_NONEMPTY((head)); \
	if (LIST_NEXT((elm), field) == NULL) \
	/* 'elm' is the last element in 'head'. */ \
	@@ -752,36 +752,36 @@
	swap_tmp->field.le_prev = &LIST_FIRST((head2)); \
	} while (0)

	-#define LIST_END(head) NULL
	+#define LIST_END(head) NULL

	/*
	* Tail queue declarations.
	*/
	-#define TAILQ_HEAD(name, type) \
	+#define TAILQ_HEAD(name, type) \
	struct name { \
	struct type tqh_first; / first element */ \
	struct type *tqh_last; / addr of last next element */ \
	TRACEBUF \
	}

	-#define TAILQ_CLASS_HEAD(name, type) \
	+#define TAILQ_CLASS_HEAD(name, type) \
	struct name { \
	class type tqh_first; / first element */ \
	class type *tqh_last; / addr of last next element */ \
	TRACEBUF \
	}

	-#define TAILQ_HEAD_INITIALIZER(head) \
	+#define TAILQ_HEAD_INITIALIZER(head) \
	{ NULL, &(head).tqh_first, TRACEBUF_INITIALIZER }

	-#define TAILQ_ENTRY(type) \
	+#define TAILQ_ENTRY(type) \
	struct { \
	struct type tqe_next; / next element */ \
	struct type *tqe_prev; / address of previous next element */ \
	TRACEBUF \
	}

	-#define TAILQ_CLASS_ENTRY(type) \
	+#define TAILQ_CLASS_ENTRY(type) \
	struct { \
	class type tqe_next; / next element */ \
	class type *tqe_prev; / address of previous next element */ \
	@@ -798,7 +798,7 @@
	* If the tailq is non-empty, validates that the first element of the tailq
	* points back at 'head.'
	*/
	-#define QMD_TAILQ_CHECK_HEAD(head, field) do { \
	+#define QMD_TAILQ_CHECK_HEAD(head, field) do { \
	if (!TAILQ_EMPTY(head) && \
	TAILQ_FIRST((head))->field.tqe_prev != \
	&TAILQ_FIRST((head))) \
	@@ -810,7 +810,7 @@
	*
	* Validates that the tail of the tailq is a pointer to pointer to NULL.
	*/
	-#define QMD_TAILQ_CHECK_TAIL(head, field) do { \
	+#define QMD_TAILQ_CHECK_TAIL(head, field) do { \
	if (*(head)->tqh_last != NULL) \
	panic("Bad tailq NEXT(%p->tqh_last) != NULL", (head)); \
	} while (0)
	@@ -821,7 +821,7 @@
	* If an element follows 'elm' in the tailq, validates that the next element
	* points back at 'elm.'
	*/
	-#define QMD_TAILQ_CHECK_NEXT(elm, field) do { \
	+#define QMD_TAILQ_CHECK_NEXT(elm, field) do { \
	if (TAILQ_NEXT((elm), field) != NULL && \
	TAILQ_NEXT((elm), field)->field.tqe_prev != \
	&((elm)->field.tqe_next)) \
	@@ -833,31 +833,31 @@
	*
	* Validates that the previous element (or head of the tailq) points to 'elm.'
	*/
	-#define QMD_TAILQ_CHECK_PREV(elm, field) do { \
	+#define QMD_TAILQ_CHECK_PREV(elm, field) do { \
	if (*(elm)->field.tqe_prev != (elm)) \
	panic("Bad link elm %p prev->next != elm", (elm)); \
	} while (0)

	-#define TAILQ_ASSERT_EMPTY(head) do { \
	+#define TAILQ_ASSERT_EMPTY(head) do { \
	if (!TAILQ_EMPTY((head))) \
	panic("tailq %p is not empty", (head)); \
	} while (0)

	-#define TAILQ_ASSERT_NONEMPTY(head) do { \
	+#define TAILQ_ASSERT_NONEMPTY(head) do { \
	if (TAILQ_EMPTY((head))) \
	panic("tailq %p is empty", (head)); \
	} while (0)

	#else
	-#define QMD_TAILQ_CHECK_HEAD(head, field)
	-#define QMD_TAILQ_CHECK_TAIL(head, headname)
	-#define QMD_TAILQ_CHECK_NEXT(elm, field)
	-#define QMD_TAILQ_CHECK_PREV(elm, field)
	-#define TAILQ_ASSERT_EMPTY(head)
	-#define TAILQ_ASSERT_NONEMPTY(head)
	+#define QMD_TAILQ_CHECK_HEAD(head, field)
	+#define QMD_TAILQ_CHECK_TAIL(head, headname)
	+#define QMD_TAILQ_CHECK_NEXT(elm, field)
	+#define QMD_TAILQ_CHECK_PREV(elm, field)
	+#define TAILQ_ASSERT_EMPTY(head)
	+#define TAILQ_ASSERT_NONEMPTY(head)
	#endif /* (_KERNEL && INVARIANTS) */

	-#define TAILQ_CONCAT(head1, head2, field) do { \
	+#define TAILQ_CONCAT(head1, head2, field) do { \
	if (!TAILQ_EMPTY(head2)) { \
	*(head1)->tqh_last = (head2)->tqh_first; \
	(head2)->tqh_first->field.tqe_prev = (head1)->tqh_last; \
	@@ -868,60 +868,60 @@
	} \
	} while (0)

	-#define TAILQ_EMPTY(head) ((head)->tqh_first == NULL)
	+#define TAILQ_EMPTY(head) ((head)->tqh_first == NULL)

	-#define TAILQ_EMPTY_ATOMIC(head) \
	+#define TAILQ_EMPTY_ATOMIC(head) \
	(atomic_load_ptr(&(head)->tqh_first) == NULL)

	-#define TAILQ_FIRST(head) ((head)->tqh_first)
	+#define TAILQ_FIRST(head) ((head)->tqh_first)

	-#define TAILQ_FOREACH(var, head, field) \
	+#define TAILQ_FOREACH(var, head, field) \
	for ((var) = TAILQ_FIRST((head)); \
	(var); \
	(var) = TAILQ_NEXT((var), field))

	-#define TAILQ_FOREACH_FROM(var, head, field) \
	+#define TAILQ_FOREACH_FROM(var, head, field) \
	for ((var) = ((var) ? (var) : TAILQ_FIRST((head))); \
	(var); \
	(var) = TAILQ_NEXT((var), field))

	-#define TAILQ_FOREACH_SAFE(var, head, field, tvar) \
	+#define TAILQ_FOREACH_SAFE(var, head, field, tvar) \
	for ((var) = TAILQ_FIRST((head)); \
	(var) && ((tvar) = TAILQ_NEXT((var), field), 1); \
	(var) = (tvar))

	-#define TAILQ_FOREACH_FROM_SAFE(var, head, field, tvar) \
	+#define TAILQ_FOREACH_FROM_SAFE(var, head, field, tvar) \
	for ((var) = ((var) ? (var) : TAILQ_FIRST((head))); \
	(var) && ((tvar) = TAILQ_NEXT((var), field), 1); \
	(var) = (tvar))

	-#define TAILQ_FOREACH_REVERSE(var, head, headname, field) \
	+#define TAILQ_FOREACH_REVERSE(var, head, headname, field) \
	for ((var) = TAILQ_LAST((head), headname); \
	(var); \
	(var) = TAILQ_PREV((var), headname, field))

	-#define TAILQ_FOREACH_REVERSE_FROM(var, head, headname, field) \
	+#define TAILQ_FOREACH_REVERSE_FROM(var, head, headname, field) \
	for ((var) = ((var) ? (var) : TAILQ_LAST((head), headname)); \
	(var); \
	(var) = TAILQ_PREV((var), headname, field))

	-#define TAILQ_FOREACH_REVERSE_SAFE(var, head, headname, field, tvar) \
	+#define TAILQ_FOREACH_REVERSE_SAFE(var, head, headname, field, tvar) \
	for ((var) = TAILQ_LAST((head), headname); \
	(var) && ((tvar) = TAILQ_PREV((var), headname, field), 1); \
	(var) = (tvar))

	-#define TAILQ_FOREACH_REVERSE_FROM_SAFE(var, head, headname, field, tvar)\
	+#define TAILQ_FOREACH_REVERSE_FROM_SAFE(var, head, headname, field, tvar)\
	for ((var) = ((var) ? (var) : TAILQ_LAST((head), headname)); \
	(var) && ((tvar) = TAILQ_PREV((var), headname, field), 1); \
	(var) = (tvar))

	-#define TAILQ_INIT(head) do { \
	+#define TAILQ_INIT(head) do { \
	TAILQ_FIRST((head)) = NULL; \
	(head)->tqh_last = &TAILQ_FIRST((head)); \
	QMD_TRACE_HEAD(head); \
	} while (0)

	-#define TAILQ_INSERT_AFTER(head, listelm, elm, field) do { \
	+#define TAILQ_INSERT_AFTER(head, listelm, elm, field) do { \
	QMD_TAILQ_CHECK_NEXT(listelm, field); \
	if ((TAILQ_NEXT((elm), field) = TAILQ_NEXT((listelm), field)) != NULL)\
	TAILQ_NEXT((elm), field)->field.tqe_prev = \
	@@ -936,7 +936,7 @@
	QMD_TRACE_ELEM(&(listelm)->field); \
	} while (0)

	-#define TAILQ_INSERT_BEFORE(listelm, elm, field) do { \
	+#define TAILQ_INSERT_BEFORE(listelm, elm, field) do { \
	QMD_TAILQ_CHECK_PREV(listelm, field); \
	(elm)->field.tqe_prev = (listelm)->field.tqe_prev; \
	TAILQ_NEXT((elm), field) = (listelm); \
	@@ -946,7 +946,7 @@
	QMD_TRACE_ELEM(&(listelm)->field); \
	} while (0)

	-#define TAILQ_INSERT_HEAD(head, elm, field) do { \
	+#define TAILQ_INSERT_HEAD(head, elm, field) do { \
	QMD_TAILQ_CHECK_HEAD(head, field); \
	if ((TAILQ_NEXT((elm), field) = TAILQ_FIRST((head))) != NULL) \
	TAILQ_FIRST((head))->field.tqe_prev = \
	@@ -959,7 +959,7 @@
	QMD_TRACE_ELEM(&(elm)->field); \
	} while (0)

	-#define TAILQ_INSERT_TAIL(head, elm, field) do { \
	+#define TAILQ_INSERT_TAIL(head, elm, field) do { \
	QMD_TAILQ_CHECK_TAIL(head, field); \
	TAILQ_NEXT((elm), field) = NULL; \
	(elm)->field.tqe_prev = (head)->tqh_last; \
	@@ -969,7 +969,7 @@
	QMD_TRACE_ELEM(&(elm)->field); \
	} while (0)

	-#define TAILQ_LAST(head, headname) \
	+#define TAILQ_LAST(head, headname) \
	((((struct headname )((head)->tqh_last))->tqh_last))

	/*
	@@ -979,22 +979,22 @@
	* the previous element. FAST is very useful for instances when
	* you may want to prefetch the last data element.
	*/
	-#define TAILQ_LAST_FAST(head, type, field) \
	+#define TAILQ_LAST_FAST(head, type, field) \
	(TAILQ_EMPTY(head) ? NULL : __containerof((head)->tqh_last, QUEUE_TYPEOF(type), field.tqe_next))

	-#define TAILQ_NEXT(elm, field) ((elm)->field.tqe_next)
	+#define TAILQ_NEXT(elm, field) ((elm)->field.tqe_next)

	-#define TAILQ_PREV(elm, headname, field) \
	+#define TAILQ_PREV(elm, headname, field) \
	((((struct headname )((elm)->field.tqe_prev))->tqh_last))

	-#define TAILQ_PREV_FAST(elm, head, type, field) \
	+#define TAILQ_PREV_FAST(elm, head, type, field) \
	((elm)->field.tqe_prev == &(head)->tqh_first ? NULL : \
	__containerof((elm)->field.tqe_prev, QUEUE_TYPEOF(type), field.tqe_next))

	#define TAILQ_REMOVE_HEAD(head, field) \
	TAILQ_REMOVE(head, TAILQ_FIRST(head), field)

	-#define TAILQ_REMOVE(head, elm, field) do { \
	+#define TAILQ_REMOVE(head, elm, field) do { \
	QMD_SAVELINK(oldnext, (elm)->field.tqe_next); \
	QMD_SAVELINK(oldprev, (elm)->field.tqe_prev); \
	QMD_TAILQ_CHECK_NEXT(elm, field); \
	@@ -1030,7 +1030,7 @@
	QMD_TRACE_ELEM(&(elm)->field); \
	} while (0)

	-#define TAILQ_SPLIT_AFTER(head, elm, rest, field) do { \
	+#define TAILQ_SPLIT_AFTER(head, elm, rest, field) do { \
	TAILQ_ASSERT_NONEMPTY((head)); \
	QMD_TAILQ_CHECK_TAIL((head), field); \
	if (TAILQ_NEXT((elm), field) == NULL) \
	@@ -1064,6 +1064,6 @@
	(head2)->tqh_last = &(head2)->tqh_first; \
	} while (0)

	-#define TAILQ_END(head) NULL
	+#define TAILQ_END(head) NULL

	#endif /* !_SYS_QUEUE_H_ */

File Metadata

Mime Type: text/plain
Expires: Thu, Apr 24, 4:05 PM (19 h, 27 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 17755435
Default Alt Text: D49970.diff (29 KB)

D49970.diffNo OneTemporaryActions

D49970.diffView Options

File Metadata

Event Timeline

D49970.diff
No OneTemporary
Actions

D49970.diff
View Options