Lines Matching refs:head
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
117 /* Store the last 2 places the queue element or head was altered */
130 #define QMD_TRACE_HEAD(head) do { \
131 (head)->trace.prevline = (head)->trace.lastline; \
132 (head)->trace.prevfile = (head)->trace.lastfile; \
133 (head)->trace.lastline = __LINE__; \
134 (head)->trace.lastfile = __FILE__; \
146 #define QMD_TRACE_HEAD(head)
175 #define SLIST_HEAD_INITIALIZER(head) \
204 #define SLIST_EMPTY(head) ((head)->slh_first == NULL)
206 #define SLIST_FIRST(head) ((head)->slh_first)
208 #define SLIST_FOREACH(var, head, field) \
209 for ((var) = SLIST_FIRST((head)); \
213 #define SLIST_FOREACH_FROM(var, head, field) \
214 for ((var) = ((var) ? (var) : SLIST_FIRST((head))); \
218 #define SLIST_FOREACH_SAFE(var, head, field, tvar) \
219 for ((var) = SLIST_FIRST((head)); \
223 #define SLIST_FOREACH_FROM_SAFE(var, head, field, tvar) \
224 for ((var) = ((var) ? (var) : SLIST_FIRST((head))); \
228 #define SLIST_FOREACH_PREVPTR(var, varp, head, field) \
229 for ((varp) = &SLIST_FIRST((head)); \
233 #define SLIST_INIT(head) do { \
234 SLIST_FIRST((head)) = NULL; \
242 #define SLIST_INSERT_HEAD(head, elm, field) do { \
243 SLIST_NEXT((elm), field) = SLIST_FIRST((head)); \
244 SLIST_FIRST((head)) = (elm); \
249 #define SLIST_REMOVE(head, elm, type, field) do { \
251 if (SLIST_FIRST((head)) == (elm)) { \
252 SLIST_REMOVE_HEAD((head), field); \
255 QUEUE_TYPEOF(type) *curelm = SLIST_FIRST(head); \
268 #define SLIST_REMOVE_HEAD(head, field) do { \
269 SLIST_FIRST((head)) = SLIST_NEXT(SLIST_FIRST((head)), field); \
293 #define STAILQ_HEAD_INITIALIZER(head) \
294 { NULL, &(head).stqh_first }
317 #define STAILQ_EMPTY(head) ((head)->stqh_first == NULL)
319 #define STAILQ_FIRST(head) ((head)->stqh_first)
321 #define STAILQ_FOREACH(var, head, field) \
322 for((var) = STAILQ_FIRST((head)); \
326 #define STAILQ_FOREACH_FROM(var, head, field) \
327 for ((var) = ((var) ? (var) : STAILQ_FIRST((head))); \
331 #define STAILQ_FOREACH_SAFE(var, head, field, tvar) \
332 for ((var) = STAILQ_FIRST((head)); \
336 #define STAILQ_FOREACH_FROM_SAFE(var, head, field, tvar) \
337 for ((var) = ((var) ? (var) : STAILQ_FIRST((head))); \
341 #define STAILQ_INIT(head) do { \
342 STAILQ_FIRST((head)) = NULL; \
343 (head)->stqh_last = &STAILQ_FIRST((head)); \
346 #define STAILQ_INSERT_AFTER(head, tqelm, elm, field) do { \
348 (head)->stqh_last = &STAILQ_NEXT((elm), field); \
352 #define STAILQ_INSERT_HEAD(head, elm, field) do { \
353 if ((STAILQ_NEXT((elm), field) = STAILQ_FIRST((head))) == NULL) \
354 (head)->stqh_last = &STAILQ_NEXT((elm), field); \
355 STAILQ_FIRST((head)) = (elm); \
358 #define STAILQ_INSERT_TAIL(head, elm, field) do { \
360 *(head)->stqh_last = (elm); \
361 (head)->stqh_last = &STAILQ_NEXT((elm), field); \
364 #define STAILQ_LAST(head, type, field) \
365 (STAILQ_EMPTY((head)) ? NULL : \
366 __containerof((head)->stqh_last, \
371 #define STAILQ_REMOVE(head, elm, type, field) do { \
373 if (STAILQ_FIRST((head)) == (elm)) { \
374 STAILQ_REMOVE_HEAD((head), field); \
377 QUEUE_TYPEOF(type) *curelm = STAILQ_FIRST(head); \
380 STAILQ_REMOVE_AFTER(head, curelm, field); \
385 #define STAILQ_REMOVE_AFTER(head, elm, field) do { \
388 (head)->stqh_last = &STAILQ_NEXT((elm), field); \
391 #define STAILQ_REMOVE_HEAD(head, field) do { \
392 if ((STAILQ_FIRST((head)) = \
393 STAILQ_NEXT(STAILQ_FIRST((head)), field)) == NULL) \
394 (head)->stqh_last = &STAILQ_FIRST((head)); \
424 #define LIST_HEAD_INITIALIZER(head) \
444 #define QMD_LIST_CHECK_HEAD(head, field) do { \
445 if (LIST_FIRST((head)) != NULL && \
446 LIST_FIRST((head))->field.le_prev != \
447 &LIST_FIRST((head))) \
448 panic("Bad list head %p first->prev != head", (head)); \
463 #define QMD_LIST_CHECK_HEAD(head, field)
485 #define LIST_EMPTY(head) ((head)->lh_first == NULL)
487 #define LIST_FIRST(head) ((head)->lh_first)
489 #define LIST_FOREACH(var, head, field) \
490 for ((var) = LIST_FIRST((head)); \
494 #define LIST_FOREACH_FROM(var, head, field) \
495 for ((var) = ((var) ? (var) : LIST_FIRST((head))); \
499 #define LIST_FOREACH_SAFE(var, head, field, tvar) \
500 for ((var) = LIST_FIRST((head)); \
504 #define LIST_FOREACH_FROM_SAFE(var, head, field, tvar) \
505 for ((var) = ((var) ? (var) : LIST_FIRST((head))); \
509 #define LIST_INIT(head) do { \
510 LIST_FIRST((head)) = NULL; \
530 #define LIST_INSERT_HEAD(head, elm, field) do { \
531 QMD_LIST_CHECK_HEAD((head), field); \
532 if ((LIST_NEXT((elm), field) = LIST_FIRST((head))) != NULL) \
533 LIST_FIRST((head))->field.le_prev = &LIST_NEXT((elm), field);\
534 LIST_FIRST((head)) = (elm); \
535 (elm)->field.le_prev = &LIST_FIRST((head)); \
540 #define LIST_PREV(elm, head, type, field) \
541 ((elm)->field.le_prev == &LIST_FIRST((head)) ? NULL : \
585 #define TAILQ_HEAD_INITIALIZER(head) \
586 { NULL, &(head).tqh_first, TRACEBUF_INITIALIZER }
606 #define QMD_TAILQ_CHECK_HEAD(head, field) do { \
607 if (!TAILQ_EMPTY(head) && \
608 TAILQ_FIRST((head))->field.tqe_prev != \
609 &TAILQ_FIRST((head))) \
610 panic("Bad tailq head %p first->prev != head", (head)); \
613 #define QMD_TAILQ_CHECK_TAIL(head, field) do { \
614 if (*(head)->tqh_last != NULL) \
615 panic("Bad tailq NEXT(%p->tqh_last) != NULL", (head)); \
630 #define QMD_TAILQ_CHECK_HEAD(head, field)
631 #define QMD_TAILQ_CHECK_TAIL(head, headname)
647 #define TAILQ_EMPTY(head) ((head)->tqh_first == NULL)
649 #define TAILQ_FIRST(head) ((head)->tqh_first)
651 #define TAILQ_FOREACH(var, head, field) \
652 for ((var) = TAILQ_FIRST((head)); \
656 #define TAILQ_FOREACH_FROM(var, head, field) \
657 for ((var) = ((var) ? (var) : TAILQ_FIRST((head))); \
661 #define TAILQ_FOREACH_SAFE(var, head, field, tvar) \
662 for ((var) = TAILQ_FIRST((head)); \
666 #define TAILQ_FOREACH_FROM_SAFE(var, head, field, tvar) \
667 for ((var) = ((var) ? (var) : TAILQ_FIRST((head))); \
671 #define TAILQ_FOREACH_REVERSE(var, head, headname, field) \
672 for ((var) = TAILQ_LAST((head), headname); \
676 #define TAILQ_FOREACH_REVERSE_FROM(var, head, headname, field) \
677 for ((var) = ((var) ? (var) : TAILQ_LAST((head), headname)); \
681 #define TAILQ_FOREACH_REVERSE_SAFE(var, head, headname, field, tvar) \
682 for ((var) = TAILQ_LAST((head), headname); \
686 #define TAILQ_FOREACH_REVERSE_FROM_SAFE(var, head, headname, field, tvar) \
687 for ((var) = ((var) ? (var) : TAILQ_LAST((head), headname)); \
691 #define TAILQ_INIT(head) do { \
692 TAILQ_FIRST((head)) = NULL; \
693 (head)->tqh_last = &TAILQ_FIRST((head)); \
694 QMD_TRACE_HEAD(head); \
697 #define TAILQ_INSERT_AFTER(head, listelm, elm, field) do { \
703 (head)->tqh_last = &TAILQ_NEXT((elm), field); \
704 QMD_TRACE_HEAD(head); \
722 #define TAILQ_INSERT_HEAD(head, elm, field) do { \
723 QMD_TAILQ_CHECK_HEAD(head, field); \
724 if ((TAILQ_NEXT((elm), field) = TAILQ_FIRST((head))) != NULL) \
725 TAILQ_FIRST((head))->field.tqe_prev = \
728 (head)->tqh_last = &TAILQ_NEXT((elm), field); \
729 TAILQ_FIRST((head)) = (elm); \
730 (elm)->field.tqe_prev = &TAILQ_FIRST((head)); \
731 QMD_TRACE_HEAD(head); \
735 #define TAILQ_INSERT_TAIL(head, elm, field) do { \
736 QMD_TAILQ_CHECK_TAIL(head, field); \
738 (elm)->field.tqe_prev = (head)->tqh_last; \
739 *(head)->tqh_last = (elm); \
740 (head)->tqh_last = &TAILQ_NEXT((elm), field); \
741 QMD_TRACE_HEAD(head); \
745 #define TAILQ_LAST(head, headname) \
746 (*(((struct headname *)((head)->tqh_last))->tqh_last))
750 * then the access to the head. The standard LAST function above
755 #define TAILQ_LAST_FAST(head, type, field) \
756 (TAILQ_EMPTY(head) ? NULL : __containerof((head)->tqh_last, QUEUE_TYPEOF(type), field.tqe_next))
763 #define TAILQ_PREV_FAST(elm, head, type, field) \
764 ((elm)->field.tqe_prev == &(head)->tqh_first ? NULL : \
767 #define TAILQ_REMOVE(head, elm, field) do { \
776 (head)->tqh_last = (elm)->field.tqe_prev; \
777 QMD_TRACE_HEAD(head); \