queue.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Defines
#define	QUEUE_MACRO_DEBUG   0
#define	QMD_TRACE_ELEM(elem)
#define	QMD_TRACE_HEAD(head)
#define	TRACEBUF
#define	TRASHIT(x)
#define	SLIST_HEAD(name, type)
#define	SLIST_HEAD_INITIALIZER(head)   { NULL }
#define	SLIST_ENTRY(type)
#define	SLIST_EMPTY(head)   ((head)->slh_first == NULL)
#define	SLIST_FIRST(head)   ((head)->slh_first)
#define	SLIST_FOREACH(var, head, field)
#define	SLIST_FOREACH_PREVPTR(var, varp, head, field)
#define	SLIST_INIT(head)
#define	SLIST_INSERT_AFTER(slistelm, elm, field)
#define	SLIST_INSERT_HEAD(head, elm, field)
#define	SLIST_NEXT(elm, field)   ((elm)->field.sle_next)
#define	SLIST_REMOVE(head, elm, type, field)
#define	SLIST_REMOVE_HEAD(head, field)
#define	STAILQ_HEAD(name, type)
#define	STAILQ_HEAD_INITIALIZER(head)   { NULL, &(head).stqh_first }
#define	STAILQ_ENTRY(type)
#define	STAILQ_CONCAT(head1, head2)
#define	STAILQ_EMPTY(head)   ((head)->stqh_first == NULL)
#define	STAILQ_FIRST(head)   ((head)->stqh_first)
#define	STAILQ_FOREACH(var, head, field)
#define	STAILQ_INIT(head)
#define	STAILQ_INSERT_AFTER(head, tqelm, elm, field)
#define	STAILQ_INSERT_HEAD(head, elm, field)
#define	STAILQ_INSERT_TAIL(head, elm, field)
#define	STAILQ_LAST(head, type, field)
#define	STAILQ_NEXT(elm, field)   ((elm)->field.stqe_next)
#define	STAILQ_REMOVE(head, elm, type, field)
#define	STAILQ_REMOVE_HEAD(head, field)
#define	STAILQ_REMOVE_HEAD_UNTIL(head, elm, field)
#define	ATH_LIST_HEAD(name, type)
#define	LIST_HEAD_INITIALIZER(head)   { NULL }
#define	LIST_ENTRY(type)
#define	LIST_EMPTY(head)   ((head)->lh_first == NULL)
#define	LIST_FIRST(head)   ((head)->lh_first)
#define	LIST_FOREACH(var, head, field)
#define	LIST_INIT(head)
#define	LIST_INSERT_AFTER(listelm, elm, field)
#define	LIST_INSERT_BEFORE(listelm, elm, field)
#define	LIST_INSERT_HEAD(head, elm, field)
#define	LIST_NEXT(elm, field)   ((elm)->field.le_next)
#define	LIST_REMOVE(elm, field)
#define	TAILQ_HEAD(name, type)
#define	TAILQ_HEAD_INITIALIZER(head)   { NULL, &(head).tqh_first }
#define	TAILQ_ENTRY(type)
#define	TAILQ_CONCAT(head1, head2, field)
#define	TAILQ_EMPTY(head)   ((head)->tqh_first == NULL)
#define	TAILQ_FIRST(head)   ((head)->tqh_first)
#define	TAILQ_FOREACH(var, head, field)
#define	TAILQ_FOREACH_REVERSE(var, head, headname, field)
#define	TAILQ_INIT(head)
#define	TAILQ_INSERT_AFTER(head, listelm, elm, field)
#define	TAILQ_INSERT_BEFORE(listelm, elm, field)
#define	TAILQ_INSERT_HEAD(head, elm, field)
#define	TAILQ_INSERT_TAIL(head, elm, field)
#define	TAILQ_LAST(head, headname)   (*(((struct headname *)((head)->tqh_last))->tqh_last))
#define	TAILQ_NEXT(elm, field)   ((elm)->field.tqe_next)
#define	TAILQ_PREV(elm, headname, field)   (*(((struct headname *)((elm)->field.tqe_prev))->tqh_last))
#define	TAILQ_REMOVE(head, elm, field)

---

Define Documentation

#define ATH_LIST_HEAD (  name, type   )

Value: struct name { \ struct type *lh_first; /* first element */ \ } Definition at line 300 of file queue.h.

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

Definition at line 318 of file queue.h.

#define LIST_ENTRY (  type   )

Value: struct { \ struct type *le_next; /* next element */ \ struct type **le_prev; /* address of previous next element */ \ } Definition at line 308 of file queue.h.

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

Definition at line 320 of file queue.h.

#define LIST_FOREACH (  var, head, field   )

Value: for ((var) = LIST_FIRST((head)); \ (var); \ (var) = LIST_NEXT((var), field)) Definition at line 322 of file queue.h.

#define LIST_HEAD_INITIALIZER (  head   )     { NULL }

Definition at line 305 of file queue.h.

#define LIST_INIT (  head   )

Value: do { \ LIST_FIRST((head)) = NULL; \ } while (0) Definition at line 327 of file queue.h.

#define LIST_INSERT_AFTER (  listelm, elm, field   )

Value: do { \ if ((LIST_NEXT((elm), field) = LIST_NEXT((listelm), field)) != NULL)\ LIST_NEXT((listelm), field)->field.le_prev = \ &LIST_NEXT((elm), field); \ LIST_NEXT((listelm), field) = (elm); \ (elm)->field.le_prev = &LIST_NEXT((listelm), field); \ } while (0) Definition at line 331 of file queue.h.

#define LIST_INSERT_BEFORE (  listelm, elm, field   )

Value: do { \ (elm)->field.le_prev = (listelm)->field.le_prev; \ LIST_NEXT((elm), field) = (listelm); \ *(listelm)->field.le_prev = (elm); \ (listelm)->field.le_prev = &LIST_NEXT((elm), field); \ } while (0) Definition at line 339 of file queue.h.

#define LIST_INSERT_HEAD (  head, elm, field   )

Value: do { \ if ((LIST_NEXT((elm), field) = LIST_FIRST((head))) != NULL) \ LIST_FIRST((head))->field.le_prev = &LIST_NEXT((elm), field);\ LIST_FIRST((head)) = (elm); \ (elm)->field.le_prev = &LIST_FIRST((head)); \ } while (0) Definition at line 346 of file queue.h.

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

Definition at line 353 of file queue.h.

#define LIST_REMOVE (  elm, field   )

Value: do { \ if (LIST_NEXT((elm), field) != NULL) \ LIST_NEXT((elm), field)->field.le_prev = \ (elm)->field.le_prev; \ *(elm)->field.le_prev = LIST_NEXT((elm), field); \ } while (0) Definition at line 355 of file queue.h.

#define QMD_TRACE_ELEM (  elem   )

Definition at line 132 of file queue.h.

#define QMD_TRACE_HEAD (  head   )

Definition at line 133 of file queue.h.

#define QUEUE_MACRO_DEBUG   0

Definition at line 104 of file queue.h.

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

Definition at line 157 of file queue.h.

#define SLIST_ENTRY (  type   )

Value: struct { \ struct type *sle_next; /* next element */ \ } Definition at line 149 of file queue.h.

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

Definition at line 159 of file queue.h.

#define SLIST_FOREACH (  var, head, field   )

Value: for ((var) = SLIST_FIRST((head)); \ (var); \ (var) = SLIST_NEXT((var), field)) Definition at line 161 of file queue.h.

#define SLIST_FOREACH_PREVPTR (  var, varp, head, field   )

Value: for ((varp) = &SLIST_FIRST((head)); \ ((var) = *(varp)) != NULL; \ (varp) = &SLIST_NEXT((var), field)) Definition at line 166 of file queue.h.

#define SLIST_HEAD (  name, type   )

Value: struct name { \ struct type *slh_first; /* first element */ \ } Definition at line 141 of file queue.h.

#define SLIST_HEAD_INITIALIZER (  head   )     { NULL }

Definition at line 146 of file queue.h.

#define SLIST_INIT (  head   )

Value: do { \ SLIST_FIRST((head)) = NULL; \ } while (0) Definition at line 171 of file queue.h.

#define SLIST_INSERT_AFTER (  slistelm, elm, field   )

Value: do { \ SLIST_NEXT((elm), field) = SLIST_NEXT((slistelm), field); \ SLIST_NEXT((slistelm), field) = (elm); \ } while (0) Definition at line 175 of file queue.h.

#define SLIST_INSERT_HEAD (  head, elm, field   )

Value: do { \ SLIST_NEXT((elm), field) = SLIST_FIRST((head)); \ SLIST_FIRST((head)) = (elm); \ } while (0) Definition at line 180 of file queue.h.

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

Definition at line 185 of file queue.h.

#define SLIST_REMOVE (  head, elm, type, field   )

Value: do { \ if (SLIST_FIRST((head)) == (elm)) { \ SLIST_REMOVE_HEAD((head), field); \ } \ else { \ struct type *curelm = SLIST_FIRST((head)); \ while (SLIST_NEXT(curelm, field) != (elm)) \ curelm = SLIST_NEXT(curelm, field); \ SLIST_NEXT(curelm, field) = \ SLIST_NEXT(SLIST_NEXT(curelm, field), field); \ } \ } while (0) Definition at line 187 of file queue.h.

#define SLIST_REMOVE_HEAD (  head, field   )

Value: do { \ SLIST_FIRST((head)) = SLIST_NEXT(SLIST_FIRST((head)), field); \ } while (0) Definition at line 200 of file queue.h.

#define STAILQ_CONCAT (  head1, head2   )

Value: do { \ if (!STAILQ_EMPTY((head2))) { \ *(head1)->stqh_last = (head2)->stqh_first; \ (head1)->stqh_last = (head2)->stqh_last; \ STAILQ_INIT((head2)); \ } \ } while (0) Definition at line 224 of file queue.h.

#define STAILQ_EMPTY (  head   )     ((head)->stqh_first == NULL)

Definition at line 232 of file queue.h. Referenced by ath_hardstart(), and ath_tx_tasklet().

#define STAILQ_ENTRY (  type   )

Value: struct { \ struct type *stqe_next; /* next element */ \ } Definition at line 216 of file queue.h.

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

Definition at line 234 of file queue.h. Referenced by ath_hardstart(), ath_rx_tasklet(), ath_startrecv(), ath_tx_draintxq(), and ath_tx_processq().

#define STAILQ_FOREACH (  var, head, field   )

Value: for((var) = STAILQ_FIRST((head)); \ (var); \ (var) = STAILQ_NEXT((var), field)) Definition at line 236 of file queue.h. Referenced by ath_desc_free(), ath_init(), ath_startrecv(), and ath_stoprecv().

#define STAILQ_HEAD (  name, type   )

Value: struct name { \ struct type *stqh_first;/* first element */ \ struct type **stqh_last;/* addr of last next element */ \ } Definition at line 207 of file queue.h.

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

Definition at line 213 of file queue.h.

#define STAILQ_INIT (  head   )

Value: do { \ STAILQ_FIRST((head)) = NULL; \ (head)->stqh_last = &STAILQ_FIRST((head)); \ } while (0) Definition at line 241 of file queue.h. Referenced by ath_desc_alloc(), ath_desc_free(), and ath_tx_setup().

#define STAILQ_INSERT_AFTER (  head, tqelm, elm, field   )

Value: 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) Definition at line 246 of file queue.h.

#define STAILQ_INSERT_HEAD (  head, elm, field   )

Value: do { \ if ((STAILQ_NEXT((elm), field) = STAILQ_FIRST((head))) == NULL) \ (head)->stqh_last = &STAILQ_NEXT((elm), field); \ STAILQ_FIRST((head)) = (elm); \ } while (0) Definition at line 252 of file queue.h.

#define STAILQ_INSERT_TAIL (  head, elm, field   )

Value: do { \ STAILQ_NEXT((elm), field) = NULL; \ *(head)->stqh_last = (elm); \ (head)->stqh_last = &STAILQ_NEXT((elm), field); \ } while (0) Definition at line 258 of file queue.h. Referenced by ath_desc_alloc(), ath_hardstart(), ath_rx_tasklet(), ath_tx_draintxq(), and ath_tx_processq().

#define STAILQ_LAST (  head, type, field   )

Value: (STAILQ_EMPTY((head)) ? \ NULL : \ ((struct type *) \ ((char *)((head)->stqh_last) - __offsetof(struct type, field)))) Definition at line 264 of file queue.h.

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

Definition at line 270 of file queue.h.

#define STAILQ_REMOVE (  head, elm, type, field   )

Value: do { \ if (STAILQ_FIRST((head)) == (elm)) { \ STAILQ_REMOVE_HEAD((head), field); \ } \ else { \ struct type *curelm = STAILQ_FIRST((head)); \ while (STAILQ_NEXT(curelm, field) != (elm)) \ curelm = STAILQ_NEXT(curelm, field); \ if ((STAILQ_NEXT(curelm, field) = \ STAILQ_NEXT(STAILQ_NEXT(curelm, field), field)) == NULL)\ (head)->stqh_last = &STAILQ_NEXT((curelm), field);\ } \ } while (0) Definition at line 272 of file queue.h.

#define STAILQ_REMOVE_HEAD (  head, field   )

Value: do { \ if ((STAILQ_FIRST((head)) = \ STAILQ_NEXT(STAILQ_FIRST((head)), field)) == NULL) \ (head)->stqh_last = &STAILQ_FIRST((head)); \ } while (0) Definition at line 286 of file queue.h. Referenced by ath_hardstart(), and ath_rx_tasklet().

#define STAILQ_REMOVE_HEAD_UNTIL (  head, elm, field   )

Value: do { \ if ((STAILQ_FIRST((head)) = STAILQ_NEXT((elm), field)) == NULL) \ (head)->stqh_last = &STAILQ_FIRST((head)); \ } while (0) Definition at line 292 of file queue.h.

#define TAILQ_CONCAT (  head1, head2, field   )

Value: do { \ if (!TAILQ_EMPTY(head2)) { \ *(head1)->tqh_last = (head2)->tqh_first; \ (head2)->tqh_first->field.tqe_prev = (head1)->tqh_last; \ (head1)->tqh_last = (head2)->tqh_last; \ TAILQ_INIT((head2)); \ QMD_TRACE_HEAD(head); \ QMD_TRACE_HEAD(head2); \ } \ } while (0) Definition at line 385 of file queue.h.

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

Definition at line 396 of file queue.h.

#define TAILQ_ENTRY (  type   )

Value: struct { \ struct type *tqe_next; /* next element */ \ struct type **tqe_prev; /* address of previous next element */ \ TRACEBUF \ } Definition at line 375 of file queue.h.

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

Definition at line 398 of file queue.h.

#define TAILQ_FOREACH (  var, head, field   )

Value: for ((var) = TAILQ_FIRST((head)); \ (var); \ (var) = TAILQ_NEXT((var), field)) Definition at line 400 of file queue.h.

#define TAILQ_FOREACH_REVERSE (  var, head, headname, field   )

Value: for ((var) = TAILQ_LAST((head), headname); \ (var); \ (var) = TAILQ_PREV((var), headname, field)) Definition at line 405 of file queue.h.

#define TAILQ_HEAD (  name, type   )

Value: struct name { \ struct type *tqh_first; /* first element */ \ struct type **tqh_last; /* addr of last next element */ \ TRACEBUF \ } Definition at line 365 of file queue.h.

#define TAILQ_HEAD_INITIALIZER (  head   )     { NULL, &(head).tqh_first }

Definition at line 372 of file queue.h.

#define TAILQ_INIT (  head   )

Value: do { \ TAILQ_FIRST((head)) = NULL; \ (head)->tqh_last = &TAILQ_FIRST((head)); \ QMD_TRACE_HEAD(head); \ } while (0) Definition at line 410 of file queue.h.

#define TAILQ_INSERT_AFTER (  head, listelm, elm, field   )

Value: do { \ if ((TAILQ_NEXT((elm), field) = TAILQ_NEXT((listelm), field)) != NULL)\ TAILQ_NEXT((elm), field)->field.tqe_prev = \ &TAILQ_NEXT((elm), field); \ else { \ (head)->tqh_last = &TAILQ_NEXT((elm), field); \ QMD_TRACE_HEAD(head); \ } \ TAILQ_NEXT((listelm), field) = (elm); \ (elm)->field.tqe_prev = &TAILQ_NEXT((listelm), field); \ QMD_TRACE_ELEM(&(elm)->field); \ QMD_TRACE_ELEM(&listelm->field); \ } while (0) Definition at line 416 of file queue.h.

#define TAILQ_INSERT_BEFORE (  listelm, elm, field   )

Value: do { \ (elm)->field.tqe_prev = (listelm)->field.tqe_prev; \ TAILQ_NEXT((elm), field) = (listelm); \ *(listelm)->field.tqe_prev = (elm); \ (listelm)->field.tqe_prev = &TAILQ_NEXT((elm), field); \ QMD_TRACE_ELEM(&(elm)->field); \ QMD_TRACE_ELEM(&listelm->field); \ } while (0) Definition at line 430 of file queue.h.

#define TAILQ_INSERT_HEAD (  head, elm, field   )

Value: do { \ if ((TAILQ_NEXT((elm), field) = TAILQ_FIRST((head))) != NULL) \ TAILQ_FIRST((head))->field.tqe_prev = \ &TAILQ_NEXT((elm), field); \ else \ (head)->tqh_last = &TAILQ_NEXT((elm), field); \ TAILQ_FIRST((head)) = (elm); \ (elm)->field.tqe_prev = &TAILQ_FIRST((head)); \ QMD_TRACE_HEAD(head); \ QMD_TRACE_ELEM(&(elm)->field); \ } while (0) Definition at line 439 of file queue.h.

#define TAILQ_INSERT_TAIL (  head, elm, field   )

Value: do { \ TAILQ_NEXT((elm), field) = NULL; \ (elm)->field.tqe_prev = (head)->tqh_last; \ *(head)->tqh_last = (elm); \ (head)->tqh_last = &TAILQ_NEXT((elm), field); \ QMD_TRACE_HEAD(head); \ QMD_TRACE_ELEM(&(elm)->field); \ } while (0) Definition at line 451 of file queue.h.

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

Definition at line 460 of file queue.h.

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

Definition at line 463 of file queue.h.

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

Definition at line 465 of file queue.h.

#define TAILQ_REMOVE (  head, elm, field   )

Value: do { \ if ((TAILQ_NEXT((elm), field)) != NULL) \ TAILQ_NEXT((elm), field)->field.tqe_prev = \ (elm)->field.tqe_prev; \ else { \ (head)->tqh_last = (elm)->field.tqe_prev; \ QMD_TRACE_HEAD(head); \ } \ *(elm)->field.tqe_prev = TAILQ_NEXT((elm), field); \ TRASHIT((elm)->field.tqe_next); \ TRASHIT((elm)->field.tqe_prev); \ QMD_TRACE_ELEM(&(elm)->field); \ } while (0) Definition at line 468 of file queue.h.

#define TRACEBUF

Definition at line 134 of file queue.h.

#define TRASHIT (  x   )

Definition at line 135 of file queue.h.

---