1. clamav-devel
  2. Commit 31c7d4065fd5b138473984a394d5b7212544b465
Browse code

Pull in queue.h from FreeBSD

Shawn Webb authored on 2014/08/14 00:33:52
Showing 4 changed files
clamav-config.h.in
History View file @ 31c7d40
... ... 
@@ -396,6 +396,9 @@
396 396 
 /* Define to 1 if you have the <sys/param.h> header file. */
397 397 
 #undef HAVE_SYS_PARAM_H
398 398
399 
+/* Define to 1 if you have the <sys/queue.h> header file. */
400 
+#undef HAVE_SYS_QUEUE_H
401 
+
399 402 
 /* "have <sys/select.h>" */
400 403 
 #undef HAVE_SYS_SELECT_H
401 404
configure
History View file @ 31c7d40
... ... 
@@ -14210,7 +14210,7 @@ esac
14210 14210
14211 14211
14212 14212
14213 
-for ac_header in stdint.h unistd.h sys/int_types.h dlfcn.h inttypes.h sys/inttypes.h sys/times.h memory.h ndir.h stdlib.h strings.h string.h sys/mman.h sys/param.h sys/stat.h sys/types.h malloc.h poll.h limits.h sys/filio.h sys/uio.h termios.h stdbool.h pwd.h grp.h
14213 
+for ac_header in stdint.h unistd.h sys/int_types.h dlfcn.h inttypes.h sys/inttypes.h sys/times.h memory.h ndir.h stdlib.h strings.h string.h sys/mman.h sys/param.h sys/stat.h sys/types.h malloc.h poll.h limits.h sys/filio.h sys/uio.h termios.h stdbool.h pwd.h grp.h sys/queue.h
14214 14214 
 do :
14215 14215 
   as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh`
14216 14216 
 ac_fn_c_check_header_mongrel "$LINENO" "$ac_header" "$as_ac_Header" "$ac_includes_default"
m4/reorganization/headers.m4
History View file @ 31c7d40
... ... 
@@ -1,4 +1,4 @@
1 
-AC_CHECK_HEADERS([stdint.h unistd.h sys/int_types.h dlfcn.h inttypes.h sys/inttypes.h sys/times.h memory.h ndir.h stdlib.h strings.h string.h sys/mman.h sys/param.h sys/stat.h sys/types.h malloc.h poll.h limits.h sys/filio.h sys/uio.h termios.h stdbool.h pwd.h grp.h])
1 
+AC_CHECK_HEADERS([stdint.h unistd.h sys/int_types.h dlfcn.h inttypes.h sys/inttypes.h sys/times.h memory.h ndir.h stdlib.h strings.h string.h sys/mman.h sys/param.h sys/stat.h sys/types.h malloc.h poll.h limits.h sys/filio.h sys/uio.h termios.h stdbool.h pwd.h grp.h sys/queue.h])
2 2 
 AC_CHECK_HEADER([syslog.h],AC_DEFINE([USE_SYSLOG],1,[use syslog]),)
3 3
4 4 
 have_pthreads=no
shared/queue.h
History View file @ 31c7d40
5 5 
new file mode 100644
... ... 
@@ -0,0 +1,694 @@
0 
+/*-
1 
+ * Copyright (c) 1991, 1993
2 
+ *	The Regents of the University of California.  All rights reserved.
3 
+ *
4 
+ * Redistribution and use in source and binary forms, with or without
5 
+ * modification, are permitted provided that the following conditions
6 
+ * are met:
7 
+ * 1. Redistributions of source code must retain the above copyright
8 
+ *    notice, this list of conditions and the following disclaimer.
9 
+ * 2. Redistributions in binary form must reproduce the above copyright
10 
+ *    notice, this list of conditions and the following disclaimer in the
11 
+ *    documentation and/or other materials provided with the distribution.
12 
+ * 4. Neither the name of the University nor the names of its contributors
13 
+ *    may be used to endorse or promote products derived from this software
14 
+ *    without specific prior written permission.
15 
+ *
16 
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
17 
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18 
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19 
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
20 
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
21 
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
22 
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
23 
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
24 
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
25 
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
26 
+ * SUCH DAMAGE.
27 
+ *
28 
+ *	@(#)queue.h	8.5 (Berkeley) 8/20/94
29 
+ * $FreeBSD$
30 
+ */
31 
+
32 
+#ifndef _SYS_QUEUE_H_
33 
+#define	_SYS_QUEUE_H_
34 
+
35 
+#include <sys/cdefs.h>
36 
+
37 
+/*
38 
+ * This file defines four types of data structures: singly-linked lists,
39 
+ * singly-linked tail queues, lists and tail queues.
40 
+ *
41 
+ * A singly-linked list is headed by a single forward pointer. The elements
42 
+ * are singly linked for minimum space and pointer manipulation overhead at
43 
+ * the expense of O(n) removal for arbitrary elements. New elements can be
44 
+ * added to the list after an existing element or at the head of the list.
45 
+ * Elements being removed from the head of the list should use the explicit
46 
+ * macro for this purpose for optimum efficiency. A singly-linked list may
47 
+ * only be traversed in the forward direction.  Singly-linked lists are ideal
48 
+ * for applications with large datasets and few or no removals or for
49 
+ * implementing a LIFO queue.
50 
+ *
51 
+ * A singly-linked tail queue is headed by a pair of pointers, one to the
52 
+ * head of the list and the other to the tail of the list. The elements are
53 
+ * singly linked for minimum space and pointer manipulation overhead at the
54 
+ * expense of O(n) removal for arbitrary elements. New elements can be added
55 
+ * to the list after an existing element, at the head of the list, or at the
56 
+ * end of the list. Elements being removed from the head of the tail queue
57 
+ * should use the explicit macro for this purpose for optimum efficiency.
58 
+ * A singly-linked tail queue may only be traversed in the forward direction.
59 
+ * Singly-linked tail queues are ideal for applications with large datasets
60 
+ * and few or no removals or for implementing a FIFO queue.
61 
+ *
62 
+ * A list is headed by a single forward pointer (or an array of forward
63 
+ * pointers for a hash table header). The elements are doubly linked
64 
+ * so that an arbitrary element can be removed without a need to
65 
+ * traverse the list. New elements can be added to the list before
66 
+ * or after an existing element or at the head of the list. A list
67 
+ * may be traversed in either direction.
68 
+ *
69 
+ * A tail queue is headed by a pair of pointers, one to the head of the
70 
+ * list and the other to the tail of the list. The elements are doubly
71 
+ * linked so that an arbitrary element can be removed without a need to
72 
+ * traverse the list. New elements can be added to the list before or
73 
+ * after an existing element, at the head of the list, or at the end of
74 
+ * the list. A tail queue may be traversed in either direction.
75 
+ *
76 
+ * For details on the use of these macros, see the queue(3) manual page.
77 
+ *
78 
+ *
79 
+ *				SLIST	LIST	STAILQ	TAILQ
80 
+ * _HEAD			+	+	+	+
81 
+ * _HEAD_INITIALIZER		+	+	+	+
82 
+ * _ENTRY			+	+	+	+
83 
+ * _INIT			+	+	+	+
84 
+ * _EMPTY			+	+	+	+
85 
+ * _FIRST			+	+	+	+
86 
+ * _NEXT			+	+	+	+
87 
+ * _PREV			-	+	-	+
88 
+ * _LAST			-	-	+	+
89 
+ * _FOREACH			+	+	+	+
90 
+ * _FOREACH_FROM		+	+	+	+
91 
+ * _FOREACH_SAFE		+	+	+	+
92 
+ * _FOREACH_FROM_SAFE		+	+	+	+
93 
+ * _FOREACH_REVERSE		-	-	-	+
94 
+ * _FOREACH_REVERSE_FROM	-	-	-	+
95 
+ * _FOREACH_REVERSE_SAFE	-	-	-	+
96 
+ * _FOREACH_REVERSE_FROM_SAFE	-	-	-	+
97 
+ * _INSERT_HEAD			+	+	+	+
98 
+ * _INSERT_BEFORE		-	+	-	+
99 
+ * _INSERT_AFTER		+	+	+	+
100 
+ * _INSERT_TAIL			-	-	+	+
101 
+ * _CONCAT			-	-	+	+
102 
+ * _REMOVE_AFTER		+	-	+	-
103 
+ * _REMOVE_HEAD			+	-	+	-
104 
+ * _REMOVE			+	+	+	+
105 
+ * _SWAP			+	+	+	+
106 
+ *
107 
+ */
108 
+#ifdef QUEUE_MACRO_DEBUG
109 
+/* Store the last 2 places the queue element or head was altered */
110 
+struct qm_trace {
111 
+	unsigned long	 lastline;
112 
+	unsigned long	 prevline;
113 
+	const char	*lastfile;
114 
+	const char	*prevfile;
115 
+};
116 
+
117 
+#define	TRACEBUF	struct qm_trace trace;
118 
+#define	TRACEBUF_INITIALIZER	{ __FILE__, __LINE__, NULL, 0 } ,
119 
+#define	TRASHIT(x)	do {(x) = (void *)-1;} while (0)
120 
+#define	QMD_SAVELINK(name, link)	void **name = (void *)&(link)
121 
+
122 
+#define	QMD_TRACE_HEAD(head) do {					\
123 
+	(head)->trace.prevline = (head)->trace.lastline;		\
124 
+	(head)->trace.prevfile = (head)->trace.lastfile;		\
125 
+	(head)->trace.lastline = __LINE__;				\
126 
+	(head)->trace.lastfile = __FILE__;				\
127 
+} while (0)
128 
+
129 
+#define	QMD_TRACE_ELEM(elem) do {					\
130 
+	(elem)->trace.prevline = (elem)->trace.lastline;		\
131 
+	(elem)->trace.prevfile = (elem)->trace.lastfile;		\
132 
+	(elem)->trace.lastline = __LINE__;				\
133 
+	(elem)->trace.lastfile = __FILE__;				\
134 
+} while (0)
135 
+
136 
+#else
137 
+#define	QMD_TRACE_ELEM(elem)
138 
+#define	QMD_TRACE_HEAD(head)
139 
+#define	QMD_SAVELINK(name, link)
140 
+#define	TRACEBUF
141 
+#define	TRACEBUF_INITIALIZER
142 
+#define	TRASHIT(x)
143 
+#endif	/* QUEUE_MACRO_DEBUG */
144 
+
145 
+/*
146 
+ * Singly-linked List declarations.
147 
+ */
148 
+#define	SLIST_HEAD(name, type)						\
149 
+struct name {								\
150 
+	struct type *slh_first;	/* first element */			\
151 
+}
152 
+
153 
+#define	SLIST_HEAD_INITIALIZER(head)					\
154 
+	{ NULL }
155 
+
156 
+#define	SLIST_ENTRY(type)						\
157 
+struct {								\
158 
+	struct type *sle_next;	/* next element */			\
159 
+}
160 
+
161 
+/*
162 
+ * Singly-linked List functions.
163 
+ */
164 
+#define	SLIST_EMPTY(head)	((head)->slh_first == NULL)
165 
+
166 
+#define	SLIST_FIRST(head)	((head)->slh_first)
167 
+
168 
+#define	SLIST_FOREACH(var, head, field)					\
169 
+	for ((var) = SLIST_FIRST((head));				\
170 
+	    (var);							\
171 
+	    (var) = SLIST_NEXT((var), field))
172 
+
173 
+#define	SLIST_FOREACH_FROM(var, head, field)				\
174 
+	for ((var) = ((var) ? (var) : SLIST_FIRST((head)));		\
175 
+	    (var);							\
176 
+	    (var) = SLIST_NEXT((var), field))
177 
+
178 
+#define	SLIST_FOREACH_SAFE(var, head, field, tvar)			\
179 
+	for ((var) = SLIST_FIRST((head));				\
180 
+	    (var) && ((tvar) = SLIST_NEXT((var), field), 1);		\
181 
+	    (var) = (tvar))
182 
+
183 
+#define	SLIST_FOREACH_FROM_SAFE(var, head, field, tvar)			\
184 
+	for ((var) = ((var) ? (var) : SLIST_FIRST((head)));		\
185 
+	    (var) && ((tvar) = SLIST_NEXT((var), field), 1);		\
186 
+	    (var) = (tvar))
187 
+
188 
+#define	SLIST_FOREACH_PREVPTR(var, varp, head, field)			\
189 
+	for ((varp) = &SLIST_FIRST((head));				\
190 
+	    ((var) = *(varp)) != NULL;					\
191 
+	    (varp) = &SLIST_NEXT((var), field))
192 
+
193 
+#define	SLIST_INIT(head) do {						\
194 
+	SLIST_FIRST((head)) = NULL;					\
195 
+} while (0)
196 
+
197 
+#define	SLIST_INSERT_AFTER(slistelm, elm, field) do {			\
198 
+	SLIST_NEXT((elm), field) = SLIST_NEXT((slistelm), field);	\
199 
+	SLIST_NEXT((slistelm), field) = (elm);				\
200 
+} while (0)
201 
+
202 
+#define	SLIST_INSERT_HEAD(head, elm, field) do {			\
203 
+	SLIST_NEXT((elm), field) = SLIST_FIRST((head));			\
204 
+	SLIST_FIRST((head)) = (elm);					\
205 
+} while (0)
206 
+
207 
+#define	SLIST_NEXT(elm, field)	((elm)->field.sle_next)
208 
+
209 
+#define	SLIST_REMOVE(head, elm, type, field) do {			\
210 
+	QMD_SAVELINK(oldnext, (elm)->field.sle_next);			\
211 
+	if (SLIST_FIRST((head)) == (elm)) {				\
212 
+		SLIST_REMOVE_HEAD((head), field);			\
213 
+	}								\
214 
+	else {								\
215 
+		struct type *curelm = SLIST_FIRST((head));		\
216 
+		while (SLIST_NEXT(curelm, field) != (elm))		\
217 
+			curelm = SLIST_NEXT(curelm, field);		\
218 
+		SLIST_REMOVE_AFTER(curelm, field);			\
219 
+	}								\
220 
+	TRASHIT(*oldnext);						\
221 
+} while (0)
222 
+
223 
+#define SLIST_REMOVE_AFTER(elm, field) do {				\
224 
+	SLIST_NEXT(elm, field) =					\
225 
+	    SLIST_NEXT(SLIST_NEXT(elm, field), field);			\
226 
+} while (0)
227 
+
228 
+#define	SLIST_REMOVE_HEAD(head, field) do {				\
229 
+	SLIST_FIRST((head)) = SLIST_NEXT(SLIST_FIRST((head)), field);	\
230 
+} while (0)
231 
+
232 
+#define SLIST_SWAP(head1, head2, type) do {				\
233 
+	struct type *swap_first = SLIST_FIRST(head1);			\
234 
+	SLIST_FIRST(head1) = SLIST_FIRST(head2);			\
235 
+	SLIST_FIRST(head2) = swap_first;				\
236 
+} while (0)
237 
+
238 
+/*
239 
+ * Singly-linked Tail queue declarations.
240 
+ */
241 
+#define	STAILQ_HEAD(name, type)						\
242 
+struct name {								\
243 
+	struct type *stqh_first;/* first element */			\
244 
+	struct type **stqh_last;/* addr of last next element */		\
245 
+}
246 
+
247 
+#define	STAILQ_HEAD_INITIALIZER(head)					\
248 
+	{ NULL, &(head).stqh_first }
249 
+
250 
+#define	STAILQ_ENTRY(type)						\
251 
+struct {								\
252 
+	struct type *stqe_next;	/* next element */			\
253 
+}
254 
+
255 
+/*
256 
+ * Singly-linked Tail queue functions.
257 
+ */
258 
+#define	STAILQ_CONCAT(head1, head2) do {				\
259 
+	if (!STAILQ_EMPTY((head2))) {					\
260 
+		*(head1)->stqh_last = (head2)->stqh_first;		\
261 
+		(head1)->stqh_last = (head2)->stqh_last;		\
262 
+		STAILQ_INIT((head2));					\
263 
+	}								\
264 
+} while (0)
265 
+
266 
+#define	STAILQ_EMPTY(head)	((head)->stqh_first == NULL)
267 
+
268 
+#define	STAILQ_FIRST(head)	((head)->stqh_first)
269 
+
270 
+#define	STAILQ_FOREACH(var, head, field)				\
271 
+	for((var) = STAILQ_FIRST((head));				\
272 
+	   (var);							\
273 
+	   (var) = STAILQ_NEXT((var), field))
274 
+
275 
+#define	STAILQ_FOREACH_FROM(var, head, field)				\
276 
+	for ((var) = ((var) ? (var) : STAILQ_FIRST((head)));		\
277 
+	   (var);							\
278 
+	   (var) = STAILQ_NEXT((var), field))
279 
+
280 
+#define	STAILQ_FOREACH_SAFE(var, head, field, tvar)			\
281 
+	for ((var) = STAILQ_FIRST((head));				\
282 
+	    (var) && ((tvar) = STAILQ_NEXT((var), field), 1);		\
283 
+	    (var) = (tvar))
284 
+
285 
+#define	STAILQ_FOREACH_FROM_SAFE(var, head, field, tvar)		\
286 
+	for ((var) = ((var) ? (var) : STAILQ_FIRST((head)));		\
287 
+	    (var) && ((tvar) = STAILQ_NEXT((var), field), 1);		\
288 
+	    (var) = (tvar))
289 
+
290 
+#define	STAILQ_INIT(head) do {						\
291 
+	STAILQ_FIRST((head)) = NULL;					\
292 
+	(head)->stqh_last = &STAILQ_FIRST((head));			\
293 
+} while (0)
294 
+
295 
+#define	STAILQ_INSERT_AFTER(head, tqelm, elm, field) do {		\
296 
+	if ((STAILQ_NEXT((elm), field) = STAILQ_NEXT((tqelm), field)) == NULL)\
297 
+		(head)->stqh_last = &STAILQ_NEXT((elm), field);		\
298 
+	STAILQ_NEXT((tqelm), field) = (elm);				\
299 
+} while (0)
300 
+
301 
+#define	STAILQ_INSERT_HEAD(head, elm, field) do {			\
302 
+	if ((STAILQ_NEXT((elm), field) = STAILQ_FIRST((head))) == NULL)	\
303 
+		(head)->stqh_last = &STAILQ_NEXT((elm), field);		\
304 
+	STAILQ_FIRST((head)) = (elm);					\
305 
+} while (0)
306 
+
307 
+#define	STAILQ_INSERT_TAIL(head, elm, field) do {			\
308 
+	STAILQ_NEXT((elm), field) = NULL;				\
309 
+	*(head)->stqh_last = (elm);					\
310 
+	(head)->stqh_last = &STAILQ_NEXT((elm), field);			\
311 
+} while (0)
312 
+
313 
+#define	STAILQ_LAST(head, type, field)					\
314 
+	(STAILQ_EMPTY((head)) ? NULL :					\
315 
+	    __containerof((head)->stqh_last, struct type, field.stqe_next))
316 
+
317 
+#define	STAILQ_NEXT(elm, field)	((elm)->field.stqe_next)
318 
+
319 
+#define	STAILQ_REMOVE(head, elm, type, field) do {			\
320 
+	QMD_SAVELINK(oldnext, (elm)->field.stqe_next);			\
321 
+	if (STAILQ_FIRST((head)) == (elm)) {				\
322 
+		STAILQ_REMOVE_HEAD((head), field);			\
323 
+	}								\
324 
+	else {								\
325 
+		struct type *curelm = STAILQ_FIRST((head));		\
326 
+		while (STAILQ_NEXT(curelm, field) != (elm))		\
327 
+			curelm = STAILQ_NEXT(curelm, field);		\
328 
+		STAILQ_REMOVE_AFTER(head, curelm, field);		\
329 
+	}								\
330 
+	TRASHIT(*oldnext);						\
331 
+} while (0)
332 
+
333 
+#define STAILQ_REMOVE_AFTER(head, elm, field) do {			\
334 
+	if ((STAILQ_NEXT(elm, field) =					\
335 
+	     STAILQ_NEXT(STAILQ_NEXT(elm, field), field)) == NULL)	\
336 
+		(head)->stqh_last = &STAILQ_NEXT((elm), field);		\
337 
+} while (0)
338 
+
339 
+#define	STAILQ_REMOVE_HEAD(head, field) do {				\
340 
+	if ((STAILQ_FIRST((head)) =					\
341 
+	     STAILQ_NEXT(STAILQ_FIRST((head)), field)) == NULL)		\
342 
+		(head)->stqh_last = &STAILQ_FIRST((head));		\
343 
+} while (0)
344 
+
345 
+#define STAILQ_SWAP(head1, head2, type) do {				\
346 
+	struct type *swap_first = STAILQ_FIRST(head1);			\
347 
+	struct type **swap_last = (head1)->stqh_last;			\
348 
+	STAILQ_FIRST(head1) = STAILQ_FIRST(head2);			\
349 
+	(head1)->stqh_last = (head2)->stqh_last;			\
350 
+	STAILQ_FIRST(head2) = swap_first;				\
351 
+	(head2)->stqh_last = swap_last;					\
352 
+	if (STAILQ_EMPTY(head1))					\
353 
+		(head1)->stqh_last = &STAILQ_FIRST(head1);		\
354 
+	if (STAILQ_EMPTY(head2))					\
355 
+		(head2)->stqh_last = &STAILQ_FIRST(head2);		\
356 
+} while (0)
357 
+
358 
+
359 
+/*
360 
+ * List declarations.
361 
+ */
362 
+#define	LIST_HEAD(name, type)						\
363 
+struct name {								\
364 
+	struct type *lh_first;	/* first element */			\
365 
+}
366 
+
367 
+#define	LIST_HEAD_INITIALIZER(head)					\
368 
+	{ NULL }
369 
+
370 
+#define	LIST_ENTRY(type)						\
371 
+struct {								\
372 
+	struct type *le_next;	/* next element */			\
373 
+	struct type **le_prev;	/* address of previous next element */	\
374 
+}
375 
+
376 
+/*
377 
+ * List functions.
378 
+ */
379 
+
380 
+#if (defined(_KERNEL) && defined(INVARIANTS))
381 
+#define	QMD_LIST_CHECK_HEAD(head, field) do {				\
382 
+	if (LIST_FIRST((head)) != NULL &&				\
383 
+	    LIST_FIRST((head))->field.le_prev !=			\
384 
+	     &LIST_FIRST((head)))					\
385 
+		panic("Bad list head %p first->prev != head", (head));	\
386 
+} while (0)
387 
+
388 
+#define	QMD_LIST_CHECK_NEXT(elm, field) do {				\
389 
+	if (LIST_NEXT((elm), field) != NULL &&				\
390 
+	    LIST_NEXT((elm), field)->field.le_prev !=			\
391 
+	     &((elm)->field.le_next))					\
392 
+	     	panic("Bad link elm %p next->prev != elm", (elm));	\
393 
+} while (0)
394 
+
395 
+#define	QMD_LIST_CHECK_PREV(elm, field) do {				\
396 
+	if (*(elm)->field.le_prev != (elm))				\
397 
+		panic("Bad link elm %p prev->next != elm", (elm));	\
398 
+} while (0)
399 
+#else
400 
+#define	QMD_LIST_CHECK_HEAD(head, field)
401 
+#define	QMD_LIST_CHECK_NEXT(elm, field)
402 
+#define	QMD_LIST_CHECK_PREV(elm, field)
403 
+#endif /* (_KERNEL && INVARIANTS) */
404 
+
405 
+#define	LIST_EMPTY(head)	((head)->lh_first == NULL)
406 
+
407 
+#define	LIST_FIRST(head)	((head)->lh_first)
408 
+
409 
+#define	LIST_FOREACH(var, head, field)					\
410 
+	for ((var) = LIST_FIRST((head));				\
411 
+	    (var);							\
412 
+	    (var) = LIST_NEXT((var), field))
413 
+
414 
+#define	LIST_FOREACH_FROM(var, head, field)				\
415 
+	for ((var) = ((var) ? (var) : LIST_FIRST((head)));		\
416 
+	    (var);							\
417 
+	    (var) = LIST_NEXT((var), field))
418 
+
419 
+#define	LIST_FOREACH_SAFE(var, head, field, tvar)			\
420 
+	for ((var) = LIST_FIRST((head));				\
421 
+	    (var) && ((tvar) = LIST_NEXT((var), field), 1);		\
422 
+	    (var) = (tvar))
423 
+
424 
+#define	LIST_FOREACH_FROM_SAFE(var, head, field, tvar)			\
425 
+	for ((var) = ((var) ? (var) : LIST_FIRST((head)));		\
426 
+	    (var) && ((tvar) = LIST_NEXT((var), field), 1);		\
427 
+	    (var) = (tvar))
428 
+
429 
+#define	LIST_INIT(head) do {						\
430 
+	LIST_FIRST((head)) = NULL;					\
431 
+} while (0)
432 
+
433 
+#define	LIST_INSERT_AFTER(listelm, elm, field) do {			\
434 
+	QMD_LIST_CHECK_NEXT(listelm, field);				\
435 
+	if ((LIST_NEXT((elm), field) = LIST_NEXT((listelm), field)) != NULL)\
436 
+		LIST_NEXT((listelm), field)->field.le_prev =		\
437 
+		    &LIST_NEXT((elm), field);				\
438 
+	LIST_NEXT((listelm), field) = (elm);				\
439 
+	(elm)->field.le_prev = &LIST_NEXT((listelm), field);		\
440 
+} while (0)
441 
+
442 
+#define	LIST_INSERT_BEFORE(listelm, elm, field) do {			\
443 
+	QMD_LIST_CHECK_PREV(listelm, field);				\
444 
+	(elm)->field.le_prev = (listelm)->field.le_prev;		\
445 
+	LIST_NEXT((elm), field) = (listelm);				\
446 
+	*(listelm)->field.le_prev = (elm);				\
447 
+	(listelm)->field.le_prev = &LIST_NEXT((elm), field);		\
448 
+} while (0)
449 
+
450 
+#define	LIST_INSERT_HEAD(head, elm, field) do {				\
451 
+	QMD_LIST_CHECK_HEAD((head), field);				\
452 
+	if ((LIST_NEXT((elm), field) = LIST_FIRST((head))) != NULL)	\
453 
+		LIST_FIRST((head))->field.le_prev = &LIST_NEXT((elm), field);\
454 
+	LIST_FIRST((head)) = (elm);					\
455 
+	(elm)->field.le_prev = &LIST_FIRST((head));			\
456 
+} while (0)
457 
+
458 
+#define	LIST_NEXT(elm, field)	((elm)->field.le_next)
459 
+
460 
+#define	LIST_PREV(elm, head, type, field)				\
461 
+	((elm)->field.le_prev == &LIST_FIRST((head)) ? NULL :		\
462 
+	    __containerof((elm)->field.le_prev, struct type, field.le_next))
463 
+
464 
+#define	LIST_REMOVE(elm, field) do {					\
465 
+	QMD_SAVELINK(oldnext, (elm)->field.le_next);			\
466 
+	QMD_SAVELINK(oldprev, (elm)->field.le_prev);			\
467 
+	QMD_LIST_CHECK_NEXT(elm, field);				\
468 
+	QMD_LIST_CHECK_PREV(elm, field);				\
469 
+	if (LIST_NEXT((elm), field) != NULL)				\
470 
+		LIST_NEXT((elm), field)->field.le_prev = 		\
471 
+		    (elm)->field.le_prev;				\
472 
+	*(elm)->field.le_prev = LIST_NEXT((elm), field);		\
473 
+	TRASHIT(*oldnext);						\
474 
+	TRASHIT(*oldprev);						\
475 
+} while (0)
476 
+
477 
+#define LIST_SWAP(head1, head2, type, field) do {			\
478 
+	struct type *swap_tmp = LIST_FIRST((head1));			\
479 
+	LIST_FIRST((head1)) = LIST_FIRST((head2));			\
480 
+	LIST_FIRST((head2)) = swap_tmp;					\
481 
+	if ((swap_tmp = LIST_FIRST((head1))) != NULL)			\
482 
+		swap_tmp->field.le_prev = &LIST_FIRST((head1));		\
483 
+	if ((swap_tmp = LIST_FIRST((head2))) != NULL)			\
484 
+		swap_tmp->field.le_prev = &LIST_FIRST((head2));		\
485 
+} while (0)
486 
+
487 
+/*
488 
+ * Tail queue declarations.
489 
+ */
490 
+#define	TAILQ_HEAD(name, type)						\
491 
+struct name {								\
492 
+	struct type *tqh_first;	/* first element */			\
493 
+	struct type **tqh_last;	/* addr of last next element */		\
494 
+	TRACEBUF							\
495 
+}
496 
+
497 
+#define	TAILQ_HEAD_INITIALIZER(head)					\
498 
+	{ NULL, &(head).tqh_first, TRACEBUF_INITIALIZER }
499 
+
500 
+#define	TAILQ_ENTRY(type)						\
501 
+struct {								\
502 
+	struct type *tqe_next;	/* next element */			\
503 
+	struct type **tqe_prev;	/* address of previous next element */	\
504 
+	TRACEBUF							\
505 
+}
506 
+
507 
+/*
508 
+ * Tail queue functions.
509 
+ */
510 
+#if (defined(_KERNEL) && defined(INVARIANTS))
511 
+#define	QMD_TAILQ_CHECK_HEAD(head, field) do {				\
512 
+	if (!TAILQ_EMPTY(head) &&					\
513 
+	    TAILQ_FIRST((head))->field.tqe_prev !=			\
514 
+	     &TAILQ_FIRST((head)))					\
515 
+		panic("Bad tailq head %p first->prev != head", (head));	\
516 
+} while (0)
517 
+
518 
+#define	QMD_TAILQ_CHECK_TAIL(head, field) do {				\
519 
+	if (*(head)->tqh_last != NULL)					\
520 
+	    	panic("Bad tailq NEXT(%p->tqh_last) != NULL", (head)); 	\
521 
+} while (0)
522 
+
523 
+#define	QMD_TAILQ_CHECK_NEXT(elm, field) do {				\
524 
+	if (TAILQ_NEXT((elm), field) != NULL &&				\
525 
+	    TAILQ_NEXT((elm), field)->field.tqe_prev !=			\
526 
+	     &((elm)->field.tqe_next))					\
527 
+		panic("Bad link elm %p next->prev != elm", (elm));	\
528 
+} while (0)
529 
+
530 
+#define	QMD_TAILQ_CHECK_PREV(elm, field) do {				\
531 
+	if (*(elm)->field.tqe_prev != (elm))				\
532 
+		panic("Bad link elm %p prev->next != elm", (elm));	\
533 
+} while (0)
534 
+#else
535 
+#define	QMD_TAILQ_CHECK_HEAD(head, field)
536 
+#define	QMD_TAILQ_CHECK_TAIL(head, headname)
537 
+#define	QMD_TAILQ_CHECK_NEXT(elm, field)
538 
+#define	QMD_TAILQ_CHECK_PREV(elm, field)
539 
+#endif /* (_KERNEL && INVARIANTS) */
540 
+
541 
+#define	TAILQ_CONCAT(head1, head2, field) do {				\
542 
+	if (!TAILQ_EMPTY(head2)) {					\
543 
+		*(head1)->tqh_last = (head2)->tqh_first;		\
544 
+		(head2)->tqh_first->field.tqe_prev = (head1)->tqh_last;	\
545 
+		(head1)->tqh_last = (head2)->tqh_last;			\
546 
+		TAILQ_INIT((head2));					\
547 
+		QMD_TRACE_HEAD(head1);					\
548 
+		QMD_TRACE_HEAD(head2);					\
549 
+	}								\
550 
+} while (0)
551 
+
552 
+#define	TAILQ_EMPTY(head)	((head)->tqh_first == NULL)
553 
+
554 
+#define	TAILQ_FIRST(head)	((head)->tqh_first)
555 
+
556 
+#define	TAILQ_FOREACH(var, head, field)					\
557 
+	for ((var) = TAILQ_FIRST((head));				\
558 
+	    (var);							\
559 
+	    (var) = TAILQ_NEXT((var), field))
560 
+
561 
+#define	TAILQ_FOREACH_FROM(var, head, field)				\
562 
+	for ((var) = ((var) ? (var) : TAILQ_FIRST((head)));		\
563 
+	    (var);							\
564 
+	    (var) = TAILQ_NEXT((var), field))
565 
+
566 
+#define	TAILQ_FOREACH_SAFE(var, head, field, tvar)			\
567 
+	for ((var) = TAILQ_FIRST((head));				\
568 
+	    (var) && ((tvar) = TAILQ_NEXT((var), field), 1);		\
569 
+	    (var) = (tvar))
570 
+
571 
+#define	TAILQ_FOREACH_FROM_SAFE(var, head, field, tvar)			\
572 
+	for ((var) = ((var) ? (var) : TAILQ_FIRST((head)));		\
573 
+	    (var) && ((tvar) = TAILQ_NEXT((var), field), 1);		\
574 
+	    (var) = (tvar))
575 
+
576 
+#define	TAILQ_FOREACH_REVERSE(var, head, headname, field)		\
577 
+	for ((var) = TAILQ_LAST((head), headname);			\
578 
+	    (var);							\
579 
+	    (var) = TAILQ_PREV((var), headname, field))
580 
+
581 
+#define	TAILQ_FOREACH_REVERSE_FROM(var, head, headname, field)		\
582 
+	for ((var) = ((var) ? (var) : TAILQ_LAST((head), headname));	\
583 
+	    (var);							\
584 
+	    (var) = TAILQ_PREV((var), headname, field))
585 
+
586 
+#define	TAILQ_FOREACH_REVERSE_SAFE(var, head, headname, field, tvar)	\
587 
+	for ((var) = TAILQ_LAST((head), headname);			\
588 
+	    (var) && ((tvar) = TAILQ_PREV((var), headname, field), 1);	\
589 
+	    (var) = (tvar))
590 
+
591 
+#define	TAILQ_FOREACH_REVERSE_FROM_SAFE(var, head, headname, field, tvar) \
592 
+	for ((var) = ((var) ? (var) : TAILQ_LAST((head), headname));	\
593 
+	    (var) && ((tvar) = TAILQ_PREV((var), headname, field), 1);	\
594 
+	    (var) = (tvar))
595 
+
596 
+#define	TAILQ_INIT(head) do {						\
597 
+	TAILQ_FIRST((head)) = NULL;					\
598 
+	(head)->tqh_last = &TAILQ_FIRST((head));			\
599 
+	QMD_TRACE_HEAD(head);						\
600 
+} while (0)
601 
+
602 
+#define	TAILQ_INSERT_AFTER(head, listelm, elm, field) do {		\
603 
+	QMD_TAILQ_CHECK_NEXT(listelm, field);				\
604 
+	if ((TAILQ_NEXT((elm), field) = TAILQ_NEXT((listelm), field)) != NULL)\
605 
+		TAILQ_NEXT((elm), field)->field.tqe_prev = 		\
606 
+		    &TAILQ_NEXT((elm), field);				\
607 
+	else {								\
608 
+		(head)->tqh_last = &TAILQ_NEXT((elm), field);		\
609 
+		QMD_TRACE_HEAD(head);					\
610 
+	}								\
611 
+	TAILQ_NEXT((listelm), field) = (elm);				\
612 
+	(elm)->field.tqe_prev = &TAILQ_NEXT((listelm), field);		\
613 
+	QMD_TRACE_ELEM(&(elm)->field);					\
614 
+	QMD_TRACE_ELEM(&listelm->field);				\
615 
+} while (0)
616 
+
617 
+#define	TAILQ_INSERT_BEFORE(listelm, elm, field) do {			\
618 
+	QMD_TAILQ_CHECK_PREV(listelm, field);				\
619 
+	(elm)->field.tqe_prev = (listelm)->field.tqe_prev;		\
620 
+	TAILQ_NEXT((elm), field) = (listelm);				\
621 
+	*(listelm)->field.tqe_prev = (elm);				\
622 
+	(listelm)->field.tqe_prev = &TAILQ_NEXT((elm), field);		\
623 
+	QMD_TRACE_ELEM(&(elm)->field);					\
624 
+	QMD_TRACE_ELEM(&listelm->field);				\
625 
+} while (0)
626 
+
627 
+#define	TAILQ_INSERT_HEAD(head, elm, field) do {			\
628 
+	QMD_TAILQ_CHECK_HEAD(head, field);				\
629 
+	if ((TAILQ_NEXT((elm), field) = TAILQ_FIRST((head))) != NULL)	\
630 
+		TAILQ_FIRST((head))->field.tqe_prev =			\
631 
+		    &TAILQ_NEXT((elm), field);				\
632 
+	else								\
633 
+		(head)->tqh_last = &TAILQ_NEXT((elm), field);		\
634 
+	TAILQ_FIRST((head)) = (elm);					\
635 
+	(elm)->field.tqe_prev = &TAILQ_FIRST((head));			\
636 
+	QMD_TRACE_HEAD(head);						\
637 
+	QMD_TRACE_ELEM(&(elm)->field);					\
638 
+} while (0)
639 
+
640 
+#define	TAILQ_INSERT_TAIL(head, elm, field) do {			\
641 
+	QMD_TAILQ_CHECK_TAIL(head, field);				\
642 
+	TAILQ_NEXT((elm), field) = NULL;				\
643 
+	(elm)->field.tqe_prev = (head)->tqh_last;			\
644 
+	*(head)->tqh_last = (elm);					\
645 
+	(head)->tqh_last = &TAILQ_NEXT((elm), field);			\
646 
+	QMD_TRACE_HEAD(head);						\
647 
+	QMD_TRACE_ELEM(&(elm)->field);					\
648 
+} while (0)
649 
+
650 
+#define	TAILQ_LAST(head, headname)					\
651 
+	(*(((struct headname *)((head)->tqh_last))->tqh_last))
652 
+
653 
+#define	TAILQ_NEXT(elm, field) ((elm)->field.tqe_next)
654 
+
655 
+#define	TAILQ_PREV(elm, headname, field)				\
656 
+	(*(((struct headname *)((elm)->field.tqe_prev))->tqh_last))
657 
+
658 
+#define	TAILQ_REMOVE(head, elm, field) do {				\
659 
+	QMD_SAVELINK(oldnext, (elm)->field.tqe_next);			\
660 
+	QMD_SAVELINK(oldprev, (elm)->field.tqe_prev);			\
661 
+	QMD_TAILQ_CHECK_NEXT(elm, field);				\
662 
+	QMD_TAILQ_CHECK_PREV(elm, field);				\
663 
+	if ((TAILQ_NEXT((elm), field)) != NULL)				\
664 
+		TAILQ_NEXT((elm), field)->field.tqe_prev = 		\
665 
+		    (elm)->field.tqe_prev;				\
666 
+	else {								\
667 
+		(head)->tqh_last = (elm)->field.tqe_prev;		\
668 
+		QMD_TRACE_HEAD(head);					\
669 
+	}								\
670 
+	*(elm)->field.tqe_prev = TAILQ_NEXT((elm), field);		\
671 
+	TRASHIT(*oldnext);						\
672 
+	TRASHIT(*oldprev);						\
673 
+	QMD_TRACE_ELEM(&(elm)->field);					\
674 
+} while (0)
675 
+
676 
+#define TAILQ_SWAP(head1, head2, type, field) do {			\
677 
+	struct type *swap_first = (head1)->tqh_first;			\
678 
+	struct type **swap_last = (head1)->tqh_last;			\
679 
+	(head1)->tqh_first = (head2)->tqh_first;			\
680 
+	(head1)->tqh_last = (head2)->tqh_last;				\
681 
+	(head2)->tqh_first = swap_first;				\
682 
+	(head2)->tqh_last = swap_last;					\
683 
+	if ((swap_first = (head1)->tqh_first) != NULL)			\
684 
+		swap_first->field.tqe_prev = &(head1)->tqh_first;	\
685 
+	else								\
686 
+		(head1)->tqh_last = &(head1)->tqh_first;		\
687 
+	if ((swap_first = (head2)->tqh_first) != NULL)			\
688 
+		swap_first->field.tqe_prev = &(head2)->tqh_first;	\
689 
+	else								\
690 
+		(head2)->tqh_last = &(head2)->tqh_first;		\
691 
+} while (0)
692 
+
693 
+#endif /* !_SYS_QUEUE_H_ */