private/firewire/queue.h

45  * added to the list after an existing element or at the head of the list.
46  * Elements being removed from the head of the list should use the explicit
53  * head of the list and the other to the tail of the list. The elements are
56  * to the list after an existing element, at the head of the list, or at the
57  * end of the list. Elements being removed from the head of the tail queue
67  * or after an existing element or at the head of the list. A list
70  * A tail queue is headed by a pair of pointers, one to the head of the
74  * after an existing element, at the head of the list, or at the end of
104 /* Store the last 2 places the queue element or head was altered */
115 #define	QMD_TRACE_HEAD(head) do {					\
116 	(head)->trace.prevline = (head)->trace.lastline;		\
117 	(head)->trace.prevfile = (head)->trace.lastfile;		\
118 	(head)->trace.lastline = __LINE__;				\
119 	(head)->trace.lastfile = __FILE__;				\
131 #define	QMD_TRACE_HEAD(head)
144 #define	SLIST_HEAD_INITIALIZER(head)					\
155 #define	SLIST_EMPTY(head)	((head)->slh_first == NULL)
157 #define	SLIST_FIRST(head)	((head)->slh_first)
159 #define	SLIST_FOREACH(var, head, field)					\
160 	for ((var) = SLIST_FIRST((head));				\
164 #define	SLIST_FOREACH_SAFE(var, head, field, tvar)			\
165 	for ((var) = SLIST_FIRST((head));				\
169 #define	SLIST_FOREACH_PREVPTR(var, varp, head, field)			\
170 	for ((varp) = &SLIST_FIRST((head));				\
174 #define	SLIST_INIT(head) do {						\
175 	SLIST_FIRST((head)) = NULL;					\
183 #define	SLIST_INSERT_HEAD(head, elm, field) do {			\
184 	SLIST_NEXT((elm), field) = SLIST_FIRST((head));			\
185 	SLIST_FIRST((head)) = (elm);					\
190 #define	SLIST_REMOVE(head, elm, type, field) do {			\
191 	if (SLIST_FIRST((head)) == (elm)) {				\
192 		SLIST_REMOVE_HEAD((head), field);			\
195 		struct type *curelm = SLIST_FIRST((head));		\
204 #define	SLIST_REMOVE_HEAD(head, field) do {				\
205 	SLIST_FIRST((head)) = SLIST_NEXT(SLIST_FIRST((head)), field);	\
217 #define	STAILQ_HEAD_INITIALIZER(head)					\
218 	{ NULL, &(head).stqh_first }
236 #define	STAILQ_EMPTY(head)	((head)->stqh_first == NULL)
238 #define	STAILQ_FIRST(head)	((head)->stqh_first)
240 #define	STAILQ_FOREACH(var, head, field)				\
241 	for((var) = STAILQ_FIRST((head));				\
246 #define	STAILQ_FOREACH_SAFE(var, head, field, tvar)			\
247 	for ((var) = STAILQ_FIRST((head));				\
251 #define	STAILQ_INIT(head) do {						\
252 	STAILQ_FIRST((head)) = NULL;					\
253 	(head)->stqh_last = &STAILQ_FIRST((head));			\
256 #define	STAILQ_INSERT_AFTER(head, tqelm, elm, field) do {		\
258 		(head)->stqh_last = &STAILQ_NEXT((elm), field);		\
262 #define	STAILQ_INSERT_HEAD(head, elm, field) do {			\
263 	if ((STAILQ_NEXT((elm), field) = STAILQ_FIRST((head))) == NULL)	\
264 		(head)->stqh_last = &STAILQ_NEXT((elm), field);		\
265 	STAILQ_FIRST((head)) = (elm);					\
268 #define	STAILQ_INSERT_TAIL(head, elm, field) do {			\
270 	*(head)->stqh_last = (elm);					\
271 	(head)->stqh_last = &STAILQ_NEXT((elm), field);			\
274 #define	STAILQ_LAST(head, type, field)					\
275 	(STAILQ_EMPTY((head)) ?						\
278 		((char *)((head)->stqh_last) - __offsetof(struct type, field))))
282 #define	STAILQ_REMOVE(head, elm, type, field) do {			\
283 	if (STAILQ_FIRST((head)) == (elm)) {				\
284 		STAILQ_REMOVE_HEAD((head), field);			\
287 		struct type *curelm = STAILQ_FIRST((head));		\
292 			(head)->stqh_last = &STAILQ_NEXT((curelm), field);\
297 #define	STAILQ_REMOVE_HEAD(head, field) do {				\
298 	if ((STAILQ_FIRST((head)) =					\
299 	     STAILQ_NEXT(STAILQ_FIRST((head)), field)) == NULL)		\
300 		(head)->stqh_last = &STAILQ_FIRST((head));		\
311 #define	LIST_HEAD_INITIALIZER(head)					\
325 #define	QMD_LIST_CHECK_HEAD(head, field) do {				\
326 	if (LIST_FIRST((head)) != NULL &&				\
327 	    LIST_FIRST((head))->field.le_prev !=			\
328 	     &LIST_FIRST((head)))					\
329 		panic("Bad list head %p first->prev != head", (head));	\
344 #define	QMD_LIST_CHECK_HEAD(head, field)
349 #define	LIST_EMPTY(head)	((head)->lh_first == NULL)
351 #define	LIST_FIRST(head)	((head)->lh_first)
353 #define	LIST_FOREACH(var, head, field)					\
354 	for ((var) = LIST_FIRST((head));				\
358 #define	LIST_FOREACH_SAFE(var, head, field, tvar)			\
359 	for ((var) = LIST_FIRST((head));				\
363 #define	LIST_INIT(head) do {						\
364 	LIST_FIRST((head)) = NULL;					\
384 #define	LIST_INSERT_HEAD(head, elm, field) do {				\
385 	QMD_LIST_CHECK_HEAD((head), field);				\
386 	if ((LIST_NEXT((elm), field) = LIST_FIRST((head))) != NULL)	\
387 		LIST_FIRST((head))->field.le_prev = &LIST_NEXT((elm), field);\
388 	LIST_FIRST((head)) = (elm);					\
389 	(elm)->field.le_prev = &LIST_FIRST((head));			\
415 #define	TAILQ_HEAD_INITIALIZER(head)					\
416 	{ NULL, &(head).tqh_first }
429 #define	QMD_TAILQ_CHECK_HEAD(head, field) do {				\
430 	if (!TAILQ_EMPTY(head) &&					\
431 	    TAILQ_FIRST((head))->field.tqe_prev !=			\
432 	     &TAILQ_FIRST((head)))					\
433 		panic("Bad tailq head %p first->prev != head", (head));	\
436 #define	QMD_TAILQ_CHECK_TAIL(head, field) do {				\
437 	if (*(head)->tqh_last != NULL)					\
438 	    	panic("Bad tailq NEXT(%p->tqh_last) != NULL", (head)); 	\
453 #define	QMD_TAILQ_CHECK_HEAD(head, field)
454 #define	QMD_TAILQ_CHECK_TAIL(head, headname)
470 #define	TAILQ_EMPTY(head)	((head)->tqh_first == NULL)
472 #define	TAILQ_FIRST(head)	((head)->tqh_first)
474 #define	TAILQ_FOREACH(var, head, field)					\
475 	for ((var) = TAILQ_FIRST((head));				\
479 #define	TAILQ_FOREACH_SAFE(var, head, field, tvar)			\
480 	for ((var) = TAILQ_FIRST((head));				\
484 #define	TAILQ_FOREACH_REVERSE(var, head, headname, field)		\
485 	for ((var) = TAILQ_LAST((head), headname);			\
489 #define	TAILQ_FOREACH_REVERSE_SAFE(var, head, headname, field, tvar)	\
490 	for ((var) = TAILQ_LAST((head), headname);			\
494 #define	TAILQ_INIT(head) do {						\
495 	TAILQ_FIRST((head)) = NULL;					\
496 	(head)->tqh_last = &TAILQ_FIRST((head));			\
497 	QMD_TRACE_HEAD(head);						\
500 #define	TAILQ_INSERT_AFTER(head, listelm, elm, field) do {		\
506 		(head)->tqh_last = &TAILQ_NEXT((elm), field);		\
507 		QMD_TRACE_HEAD(head);					\
525 #define	TAILQ_INSERT_HEAD(head, elm, field) do {			\
526 	QMD_TAILQ_CHECK_HEAD(head, field);				\
527 	if ((TAILQ_NEXT((elm), field) = TAILQ_FIRST((head))) != NULL)	\
528 		TAILQ_FIRST((head))->field.tqe_prev =			\
531 		(head)->tqh_last = &TAILQ_NEXT((elm), field);		\
532 	TAILQ_FIRST((head)) = (elm);					\
533 	(elm)->field.tqe_prev = &TAILQ_FIRST((head));			\
534 	QMD_TRACE_HEAD(head);						\
538 #define	TAILQ_INSERT_TAIL(head, elm, field) do {			\
539 	QMD_TAILQ_CHECK_TAIL(head, field);				\
541 	(elm)->field.tqe_prev = (head)->tqh_last;			\
542 	*(head)->tqh_last = (elm);					\
543 	(head)->tqh_last = &TAILQ_NEXT((elm), field);			\
544 	QMD_TRACE_HEAD(head);						\
548 #define	TAILQ_LAST(head, headname)					\
549 	(*(((struct headname *)((head)->tqh_last))->tqh_last))
556 #define	TAILQ_REMOVE(head, elm, field) do {				\
563 		(head)->tqh_last = (elm)->field.tqe_prev;		\
564 		QMD_TRACE_HEAD(head);					\
591 		 *head = (struct quehead *)b;
593 	element->qh_link = head->qh_link;
594 	element->qh_rlink = head;
595 	head->qh_link = element;