servers/mfs/queue.h

   1
   2 #ifndef _SYS_QUEUE_H_
   3 #define _SYS_QUEUE_H_
   4
   5 #define __offsetof(type, field) ((size_t)(&((type *)0)->field))
   6 #define __rangeof(type, start, end) \
   7         (__offsetof(type, end) - __offsetof(type, start))
   8
   9 #define QMD_TRACE_ELEM(elem)
  10 #define QMD_TRACE_HEAD(head)
  11 #define TRACEBUF
  12 #define TRASHIT(x)
  13
  14 /*
  15  * List declarations.
  16  */
  17 #define LIST_HEAD(name, type)                                           \
  18 struct name {                                                           \
  19         struct type *lh_first;  /* first element */                     \
  20 }
  21
  22 #define LIST_HEAD_INITIALIZER(head)                                     \
  23         { NULL }
  24
  25 #define LIST_ENTRY(type)                                                \
  26 struct {                                                                \
  27         struct type *le_next;   /* next element */                      \
  28         struct type **le_prev;  /* address of previous next element */  \
  29 }
  30
  31 /*
  32  * List functions.
  33  */
  34
  35 #define LIST_EMPTY(head)        ((head)->lh_first == NULL)
  36
  37 #define LIST_FIRST(head)        ((head)->lh_first)
  38
  39 #define LIST_FOREACH(var, head, field)                                  \
  40         for ((var) = LIST_FIRST((head));                                \
  41             (var);                                                      \
  42             (var) = LIST_NEXT((var), field))
  43
  44 #define LIST_FOREACH_SAFE(var, head, field, tvar)                       \
  45         for ((var) = LIST_FIRST((head));                                \
  46             (var) && ((tvar) = LIST_NEXT((var), field), 1);             \
  47             (var) = (tvar))
  48
  49 #define LIST_INIT(head) do {                                            \
  50         LIST_FIRST((head)) = NULL;                                      \
  51 } while (0)
  52
  53 #define LIST_INSERT_AFTER(listelm, elm, field) do {                     \
  54         if ((LIST_NEXT((elm), field) = LIST_NEXT((listelm), field)) != NULL)\
  55                 LIST_NEXT((listelm), field)->field.le_prev =            \
  56                     &LIST_NEXT((elm), field);                           \
  57         LIST_NEXT((listelm), field) = (elm);                            \
  58         (elm)->field.le_prev = &LIST_NEXT((listelm), field);            \
  59 } while (0)
  60
  61 #define LIST_INSERT_BEFORE(listelm, elm, field) do {                    \
  62         (elm)->field.le_prev = (listelm)->field.le_prev;                \
  63         LIST_NEXT((elm), field) = (listelm);                            \
  64         *(listelm)->field.le_prev = (elm);                              \
  65         (listelm)->field.le_prev = &LIST_NEXT((elm), field);            \
  66 } while (0)
  67
  68 #define LIST_INSERT_HEAD(head, elm, field) do {                         \
  69         if ((LIST_NEXT((elm), field) = LIST_FIRST((head))) != NULL)     \
  70                 LIST_FIRST((head))->field.le_prev = &LIST_NEXT((elm), field);\
  71         LIST_FIRST((head)) = (elm);                                     \
  72         (elm)->field.le_prev = &LIST_FIRST((head));                     \
  73 } while (0)
  74
  75 #define LIST_NEXT(elm, field)   ((elm)->field.le_next)
  76
  77 #define LIST_REMOVE(elm, field) do {                                    \
  78         if (LIST_NEXT((elm), field) != NULL)                            \
  79                 LIST_NEXT((elm), field)->field.le_prev =                \
  80                     (elm)->field.le_prev;                               \
  81         *(elm)->field.le_prev = LIST_NEXT((elm), field);                \
  82 } while (0)
  83
  84 /*
  85  * Tail queue declarations.
  86  */
  87 #define TAILQ_HEAD(name, type)                                          \
  88 struct name {                                                           \
  89         struct type *tqh_first; /* first element */                     \
  90         struct type **tqh_last; /* addr of last next element */         \
  91         TRACEBUF                                                        \
  92 }
  93
  94 #define TAILQ_HEAD_INITIALIZER(head)                                    \
  95         { NULL, &(head).tqh_first }
  96
  97 #define TAILQ_ENTRY(type)                                               \
  98 struct {                                                                \
  99         struct type *tqe_next;  /* next element */                      \
 100         struct type **tqe_prev; /* address of previous next element */  \
 101         TRACEBUF                                                        \
 102 }
 103
 104 /*
 105  * Tail queue functions.
 106  */
 107 #define TAILQ_CONCAT(head1, head2, field) do {                          \
 108         if (!TAILQ_EMPTY(head2)) {                                      \
 109                 *(head1)->tqh_last = (head2)->tqh_first;                \
 110                 (head2)->tqh_first->field.tqe_prev = (head1)->tqh_last; \
 111                 (head1)->tqh_last = (head2)->tqh_last;                  \
 112                 TAILQ_INIT((head2));                                    \
 113                 QMD_TRACE_HEAD(head);                                   \
 114                 QMD_TRACE_HEAD(head2);                                  \
 115         }                                                               \
 116 } while (0)
 117
 118 #define TAILQ_EMPTY(head)       ((head)->tqh_first == NULL)
 119
 120 #define TAILQ_FIRST(head)       ((head)->tqh_first)
 121
 122 #define TAILQ_FOREACH(var, head, field)                                 \
 123         for ((var) = TAILQ_FIRST((head));                               \
 124             (var);                                                      \
 125             (var) = TAILQ_NEXT((var), field))
 126
 127 #define TAILQ_FOREACH_SAFE(var, head, field, tvar)                      \
 128         for ((var) = TAILQ_FIRST((head));                               \
 129             (var) && ((tvar) = TAILQ_NEXT((var), field), 1);            \
 130             (var) = (tvar))
 131
 132 #define TAILQ_FOREACH_REVERSE(var, head, headname, field)               \
 133         for ((var) = TAILQ_LAST((head), headname);                      \
 134             (var);                                                      \
 135             (var) = TAILQ_PREV((var), headname, field))
 136
 137 #define TAILQ_FOREACH_REVERSE_SAFE(var, head, headname, field, tvar)    \
 138         for ((var) = TAILQ_LAST((head), headname);                      \
 139             (var) && ((tvar) = TAILQ_PREV((var), headname, field), 1);  \
 140             (var) = (tvar))
 141
 142 #define TAILQ_INIT(head) do {                                           \
 143         TAILQ_FIRST((head)) = NULL;                                     \
 144         (head)->tqh_last = &TAILQ_FIRST((head));                        \
 145         QMD_TRACE_HEAD(head);                                           \
 146 } while (0)
 147
 148 #define TAILQ_INSERT_AFTER(head, listelm, elm, field) do {              \
 149         if ((TAILQ_NEXT((elm), field) = TAILQ_NEXT((listelm), field)) != NULL)\
 150                 TAILQ_NEXT((elm), field)->field.tqe_prev =              \
 151                     &TAILQ_NEXT((elm), field);                          \
 152         else {                                                          \
 153                 (head)->tqh_last = &TAILQ_NEXT((elm), field);           \
 154                 QMD_TRACE_HEAD(head);                                   \
 155         }                                                               \
 156         TAILQ_NEXT((listelm), field) = (elm);                           \
 157         (elm)->field.tqe_prev = &TAILQ_NEXT((listelm), field);          \
 158         QMD_TRACE_ELEM(&(elm)->field);                                  \
 159         QMD_TRACE_ELEM(&listelm->field);                                \
 160 } while (0)
 161
 162 #define TAILQ_INSERT_BEFORE(listelm, elm, field) do {                   \
 163         (elm)->field.tqe_prev = (listelm)->field.tqe_prev;              \
 164         TAILQ_NEXT((elm), field) = (listelm);                           \
 165         *(listelm)->field.tqe_prev = (elm);                             \
 166         (listelm)->field.tqe_prev = &TAILQ_NEXT((elm), field);          \
 167         QMD_TRACE_ELEM(&(elm)->field);                                  \
 168         QMD_TRACE_ELEM(&listelm->field);                                \
 169 } while (0)
 170
 171 #define TAILQ_INSERT_HEAD(head, elm, field) do {                        \
 172         if ((TAILQ_NEXT((elm), field) = TAILQ_FIRST((head))) != NULL)   \
 173                 TAILQ_FIRST((head))->field.tqe_prev =                   \
 174                     &TAILQ_NEXT((elm), field);                          \
 175         else                                                            \
 176                 (head)->tqh_last = &TAILQ_NEXT((elm), field);           \
 177         TAILQ_FIRST((head)) = (elm);                                    \
 178         (elm)->field.tqe_prev = &TAILQ_FIRST((head));                   \
 179         QMD_TRACE_HEAD(head);                                           \
 180         QMD_TRACE_ELEM(&(elm)->field);                                  \
 181 } while (0)
 182
 183 #define TAILQ_INSERT_TAIL(head, elm, field) do {                        \
 184         TAILQ_NEXT((elm), field) = NULL;                                \
 185         (elm)->field.tqe_prev = (head)->tqh_last;                       \
 186         *(head)->tqh_last = (elm);                                      \
 187         (head)->tqh_last = &TAILQ_NEXT((elm), field);                   \
 188         QMD_TRACE_HEAD(head);                                           \
 189         QMD_TRACE_ELEM(&(elm)->field);                                  \
 190 } while (0)
 191
 192 #define TAILQ_LAST(head, headname)                                      \
 193         (*(((struct headname *)((head)->tqh_last))->tqh_last))
 194
 195 #define TAILQ_NEXT(elm, field) ((elm)->field.tqe_next)
 196
 197 #define TAILQ_PREV(elm, headname, field)                                \
 198         (*(((struct headname *)((elm)->field.tqe_prev))->tqh_last))
 199
 200 #define TAILQ_REMOVE(head, elm, field) do {                             \
 201         if ((TAILQ_NEXT((elm), field)) != NULL)                         \
 202                 TAILQ_NEXT((elm), field)->field.tqe_prev =              \
 203                     (elm)->field.tqe_prev;                              \
 204         else {                                                          \
 205                 (head)->tqh_last = (elm)->field.tqe_prev;               \
 206                 QMD_TRACE_HEAD(head);                                   \
 207         }                                                               \
 208         *(elm)->field.tqe_prev = TAILQ_NEXT((elm), field);              \
 209         TRASHIT((elm)->field.tqe_next);                                 \
 210         TRASHIT((elm)->field.tqe_prev);                                 \
 211         QMD_TRACE_ELEM(&(elm)->field);                                  \
 212 } while (0)
 213
 214
 215 #endif /* _SYS_QUEUE_H */