git: a4df0830d74d - main - queue(3): Consistent single space after all #define
- Go to: [ bottom of page ] [ top of archives ] [ this month ]
Date: Mon, 28 Apr 2025 12:23:39 UTC
The branch main has been updated by olce: URL: https://cgit.FreeBSD.org/src/commit/?id=a4df0830d74dba9d20c01d8c108bddeb1ecd62cd commit a4df0830d74dba9d20c01d8c108bddeb1ecd62cd Author: Olivier Certner <olce@FreeBSD.org> AuthorDate: 2025-04-04 19:33:29 +0000 Commit: Olivier Certner <olce@FreeBSD.org> CommitDate: 2025-04-28 12:19:42 +0000 queue(3): Consistent single space after all #define Reviewed by: markj MFC after: 3 days Sponsored by: The FreeBSD Foundation Differential Revision: https://reviews.freebsd.org/D49970 --- sys/sys/queue.h | 302 ++++++++++++++++++++++++++++---------------------------- 1 file changed, 151 insertions(+), 151 deletions(-) diff --git a/sys/sys/queue.h b/sys/sys/queue.h index 91da1ec08640..307ac9f0ba44 100644 --- 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 @@ struct qm_trace { 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 @@ struct qm_trace { } 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 */ \ } @@ -203,25 +203,25 @@ struct { \ * Singly-linked List functions. */ #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("%s: slist %p is not empty", __func__, (head)); \ } while (0) -#define SLIST_ASSERT_NONEMPTY(head) do { \ +#define SLIST_ASSERT_NONEMPTY(head) do { \ if (SLIST_EMPTY((head))) \ panic("%s: slist %p is empty", __func__, (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 #define SLIST_CONCAT(head1, head2, type, field) do { \ @@ -237,55 +237,55 @@ struct { \ } \ } 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); \ } \ @@ -304,19 +304,19 @@ struct { \ 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; \ @@ -328,32 +328,32 @@ struct { \ 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 */ \ } @@ -368,7 +368,7 @@ struct { \ * 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); \ @@ -379,30 +379,30 @@ struct { \ * * 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("%s: stailq %p is not empty", __func__, (head)); \ } while (0) -#define STAILQ_ASSERT_NONEMPTY(head) do { \ +#define STAILQ_ASSERT_NONEMPTY(head) do { \ if (STAILQ_EMPTY((head))) \ panic("%s: stailq %p is empty", __func__, (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; \ @@ -410,69 +410,69 @@ struct { \ } \ } 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); \ @@ -492,13 +492,13 @@ struct { \ (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) \ @@ -525,32 +525,32 @@ struct { \ (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 */ \ @@ -567,7 +567,7 @@ struct { \ * 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))) \ @@ -580,7 +580,7 @@ struct { \ * 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)) \ @@ -592,26 +592,26 @@ struct { \ * * 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("%s: list %p is not empty", __func__, (head)); \ } while (0) -#define LIST_ASSERT_NONEMPTY(head) do { \ +#define LIST_ASSERT_NONEMPTY(head) do { \ if (LIST_EMPTY((head))) \ panic("%s: list %p is empty", __func__, (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 { \ @@ -631,38 +631,38 @@ struct { \ } \ } 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 = \ @@ -671,7 +671,7 @@ struct { \ (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); \ @@ -679,7 +679,7 @@ struct { \ (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);\ @@ -687,9 +687,9 @@ struct { \ (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)) @@ -697,7 +697,7 @@ struct { \ #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); \ @@ -725,7 +725,7 @@ struct { \ 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'. */ \ @@ -748,36 +748,36 @@ struct { \ 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 */ \ @@ -794,7 +794,7 @@ struct { \ * 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))) \ @@ -806,7 +806,7 @@ struct { \ * * 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) @@ -817,7 +817,7 @@ struct { \ * 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)) \ @@ -829,30 +829,30 @@ struct { \ * * 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("%s: tailq %p is not empty", __func__, (head)); \ } while (0) -#define TAILQ_ASSERT_NONEMPTY(head) do { \ +#define TAILQ_ASSERT_NONEMPTY(head) do { \ if (TAILQ_EMPTY((head))) \ panic("%s: tailq %p is empty", __func__, (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; \ @@ -863,60 +863,60 @@ struct { \ } \ } 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 = \ @@ -931,7 +931,7 @@ struct { \ 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); \ @@ -941,7 +941,7 @@ struct { \ 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 = \ @@ -954,7 +954,7 @@ struct { \ 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; \ @@ -964,7 +964,7 @@ struct { \ QMD_TRACE_ELEM(&(elm)->field); \ } while (0) -#define TAILQ_LAST(head, headname) \ +#define TAILQ_LAST(head, headname) \ (*(((struct headname *)((head)->tqh_last))->tqh_last)) /* @@ -974,22 +974,22 @@ struct { \ * 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); \ @@ -1025,7 +1025,7 @@ struct { \ 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) \ @@ -1059,6 +1059,6 @@ struct { \ (head2)->tqh_last = &(head2)->tqh_first; \ } while (0) -#define TAILQ_END(head) NULL +#define TAILQ_END(head) NULL #endif /* !_SYS_QUEUE_H_ */