Go to the documentation of this file. 85 #if defined(__clang_analyzer__) || defined(QUEUE_MACRO_DEBUG) || (defined(_KERNEL) && defined(DIAGNOSTIC)) 86 #define _Q_INVALIDATE(a) ((a) = ((void *)-1)) 88 #define _Q_INVALIDATE(a) 91 #if defined(__clang_analyzer__) 92 #define _Q_ASSERT(a) assert((a)) 107 #define SLIST_HEAD(name, type) \ 109 struct type *slh_first; \ 112 #define SLIST_HEAD_INITIALIZER(head) \ 115 #define SLIST_ENTRY(type) \ 117 struct type *sle_next; \ 123 #define SLIST_FIRST(head) ((head)->slh_first) 124 #define SLIST_END(head) NULL 125 #define SLIST_EMPTY(head) (SLIST_FIRST(head) == SLIST_END(head)) 126 #define SLIST_NEXT(elm, field) ((elm)->field.sle_next) 128 #define SLIST_FOREACH(var, head, field) \ 129 for((var) = SLIST_FIRST(head); \ 130 (var) != SLIST_END(head); \ 131 (var) = SLIST_NEXT(var, field)) 133 #define SLIST_FOREACH_PREVPTR(var, varp, head, field) \ 134 for ((varp) = &SLIST_FIRST((head)); \ 135 ((var) = *(varp)) != SLIST_END(head); \ 136 (varp) = &SLIST_NEXT((var), field)) 141 #define SLIST_INIT(head) { \ 142 SLIST_FIRST(head) = SLIST_END(head); \ 145 #define SLIST_INSERT_AFTER(slistelm, elm, field) do { \ 146 (elm)->field.sle_next = (slistelm)->field.sle_next; \ 147 (slistelm)->field.sle_next = (elm); \ 150 #define SLIST_INSERT_HEAD(head, elm, field) do { \ 151 (elm)->field.sle_next = (head)->slh_first; \ 152 (head)->slh_first = (elm); \ 155 #define SLIST_REMOVE_NEXT(head, elm, field) do { \ 156 (elm)->field.sle_next = (elm)->field.sle_next->field.sle_next; \ 159 #define SLIST_REMOVE_HEAD(head, field) do { \ 160 (head)->slh_first = (head)->slh_first->field.sle_next; \ 163 #define SLIST_REMOVE(head, elm, type, field) do { \ 164 if ((head)->slh_first == (elm)) { \ 165 SLIST_REMOVE_HEAD((head), field); \ 167 struct type *curelm = (head)->slh_first; \ 169 while (curelm->field.sle_next != (elm)) \ 170 curelm = curelm->field.sle_next; \ 171 curelm->field.sle_next = \ 172 curelm->field.sle_next->field.sle_next; \ 173 _Q_INVALIDATE((elm)->field.sle_next); \ 182 #define LIST_HEAD(name, type) \ 184 struct type *lh_first; \ 187 #define LIST_HEAD_INITIALIZER(head) \ 190 #define LIST_ENTRY(type) \ 192 struct type *le_next; \ 193 struct type **le_prev; \ 199 #define LIST_FIRST(head) ((head)->lh_first) 200 #define LIST_END(head) NULL 201 #define LIST_EMPTY(head) (LIST_FIRST(head) == LIST_END(head)) 202 #define LIST_NEXT(elm, field) ((elm)->field.le_next) 204 #define LIST_FOREACH(var, head, field) \ 205 for((var) = LIST_FIRST(head); \ 206 (var)!= LIST_END(head); \ 207 (var) = LIST_NEXT(var, field)) 212 #define LIST_INIT(head) do { \ 213 LIST_FIRST(head) = LIST_END(head); \ 216 #define LIST_INSERT_AFTER(listelm, elm, field) do { \ 217 if (((elm)->field.le_next = (listelm)->field.le_next) != NULL) \ 218 (listelm)->field.le_next->field.le_prev = \ 219 &(elm)->field.le_next; \ 220 (listelm)->field.le_next = (elm); \ 221 (elm)->field.le_prev = &(listelm)->field.le_next; \ 224 #define LIST_INSERT_BEFORE(listelm, elm, field) do { \ 225 (elm)->field.le_prev = (listelm)->field.le_prev; \ 226 (elm)->field.le_next = (listelm); \ 227 *(listelm)->field.le_prev = (elm); \ 228 (listelm)->field.le_prev = &(elm)->field.le_next; \ 231 #define LIST_INSERT_HEAD(head, elm, field) do { \ 232 if (((elm)->field.le_next = (head)->lh_first) != NULL) \ 233 (head)->lh_first->field.le_prev = &(elm)->field.le_next;\ 234 (head)->lh_first = (elm); \ 235 (elm)->field.le_prev = &(head)->lh_first; \ 238 #define LIST_REMOVE(elm, field) do { \ 239 if ((elm)->field.le_next != NULL) \ 240 (elm)->field.le_next->field.le_prev = \ 241 (elm)->field.le_prev; \ 242 *(elm)->field.le_prev = (elm)->field.le_next; \ 243 _Q_INVALIDATE((elm)->field.le_prev); \ 244 _Q_INVALIDATE((elm)->field.le_next); \ 247 #define LIST_REPLACE(elm, elm2, field) do { \ 248 if (((elm2)->field.le_next = (elm)->field.le_next) != NULL) \ 249 (elm2)->field.le_next->field.le_prev = \ 250 &(elm2)->field.le_next; \ 251 (elm2)->field.le_prev = (elm)->field.le_prev; \ 252 *(elm2)->field.le_prev = (elm2); \ 253 _Q_INVALIDATE((elm)->field.le_prev); \ 254 _Q_INVALIDATE((elm)->field.le_next); \ 260 #define SIMPLEQ_HEAD(name, type) \ 262 struct type *sqh_first; \ 263 struct type **sqh_last; \ 266 #define SIMPLEQ_HEAD_INITIALIZER(head) \ 267 { NULL, &(head).sqh_first } 269 #define SIMPLEQ_ENTRY(type) \ 271 struct type *sqe_next; \ 277 #define SIMPLEQ_FIRST(head) ((head)->sqh_first) 278 #define SIMPLEQ_END(head) NULL 279 #define SIMPLEQ_EMPTY(head) (SIMPLEQ_FIRST(head) == SIMPLEQ_END(head)) 280 #define SIMPLEQ_NEXT(elm, field) ((elm)->field.sqe_next) 282 #define SIMPLEQ_FOREACH(var, head, field) \ 283 for((var) = SIMPLEQ_FIRST(head); \ 284 (var) != SIMPLEQ_END(head); \ 285 (var) = SIMPLEQ_NEXT(var, field)) 290 #define SIMPLEQ_INIT(head) do { \ 291 (head)->sqh_first = NULL; \ 292 (head)->sqh_last = &(head)->sqh_first; \ 295 #define SIMPLEQ_INSERT_HEAD(head, elm, field) do { \ 296 if (((elm)->field.sqe_next = (head)->sqh_first) == NULL) \ 297 (head)->sqh_last = &(elm)->field.sqe_next; \ 298 (head)->sqh_first = (elm); \ 301 #define SIMPLEQ_INSERT_TAIL(head, elm, field) do { \ 302 (elm)->field.sqe_next = NULL; \ 303 *(head)->sqh_last = (elm); \ 304 (head)->sqh_last = &(elm)->field.sqe_next; \ 307 #define SIMPLEQ_INSERT_AFTER(head, listelm, elm, field) do { \ 308 if (((elm)->field.sqe_next = (listelm)->field.sqe_next) == NULL)\ 309 (head)->sqh_last = &(elm)->field.sqe_next; \ 310 (listelm)->field.sqe_next = (elm); \ 313 #define SIMPLEQ_REMOVE_HEAD(head, field) do { \ 314 if (((head)->sqh_first = (head)->sqh_first->field.sqe_next) == NULL) \ 315 (head)->sqh_last = &(head)->sqh_first; \ 321 #define TAILQ_HEAD(name, type) \ 323 struct type *tqh_first; \ 324 struct type **tqh_last; \ 327 #define TAILQ_HEAD_INITIALIZER(head) \ 328 { NULL, &(head).tqh_first } 330 #define TAILQ_ENTRY(type) \ 332 struct type *tqe_next; \ 333 struct type **tqe_prev; \ 339 #define TAILQ_FIRST(head) ((head)->tqh_first) 340 #define TAILQ_END(head) NULL 341 #define TAILQ_NEXT(elm, field) ((elm)->field.tqe_next) 342 #define TAILQ_LAST(head, headname) \ 343 (*(((struct headname *)((head)->tqh_last))->tqh_last)) 345 #define TAILQ_PREV(elm, headname, field) \ 346 (*(((struct headname *)((elm)->field.tqe_prev))->tqh_last)) 347 #define TAILQ_EMPTY(head) \ 348 (TAILQ_FIRST(head) == TAILQ_END(head)) 350 #define TAILQ_FOREACH(var, head, field) \ 351 for((var) = TAILQ_FIRST(head); \ 352 (var) != TAILQ_END(head); \ 353 (var) = TAILQ_NEXT(var, field)) 356 #define TAILQ_FOREACH_SAFE(var, head, field, tvar) \ 357 for((var) = TAILQ_FIRST(head), \ 358 (tvar) = TAILQ_FIRST(head) ? TAILQ_NEXT(TAILQ_FIRST(head), field): NULL ; \ 359 (var) != TAILQ_END(head); \ 360 (var = tvar), (tvar) = var ? TAILQ_NEXT(var, field): NULL) 362 #define TAILQ_FOREACH_REVERSE(var, head, headname, field) \ 363 for((var) = TAILQ_LAST(head, headname); \ 364 (var) != TAILQ_END(head); \ 365 (var) = TAILQ_PREV(var, headname, field)) 370 #define TAILQ_INIT(head) do { \ 371 (head)->tqh_first = NULL; \ 372 (head)->tqh_last = &(head)->tqh_first; \ 375 #define TAILQ_INSERT_HEAD(head, elm, field) do { \ 376 if (((elm)->field.tqe_next = (head)->tqh_first) != NULL) \ 377 (head)->tqh_first->field.tqe_prev = \ 378 &(elm)->field.tqe_next; \ 380 (head)->tqh_last = &(elm)->field.tqe_next; \ 381 (head)->tqh_first = (elm); \ 382 (elm)->field.tqe_prev = &(head)->tqh_first; \ 385 #define TAILQ_INSERT_TAIL(head, elm, field) do { \ 388 (elm)->field.tqe_next = NULL; \ 389 (elm)->field.tqe_prev = (head)->tqh_last; \ 390 *(head)->tqh_last = (elm); \ 391 _Q_ASSERT(*(head)->tqh_last); \ 392 (head)->tqh_last = &(elm)->field.tqe_next; \ 395 #define TAILQ_INSERT_AFTER(head, listelm, elm, field) do { \ 396 if (((elm)->field.tqe_next = (listelm)->field.tqe_next) != NULL)\ 397 (elm)->field.tqe_next->field.tqe_prev = \ 398 &(elm)->field.tqe_next; \ 400 (head)->tqh_last = &(elm)->field.tqe_next; \ 401 (listelm)->field.tqe_next = (elm); \ 402 (elm)->field.tqe_prev = &(listelm)->field.tqe_next; \ 405 #define TAILQ_INSERT_BEFORE(listelm, elm, field) do { \ 406 (elm)->field.tqe_prev = (listelm)->field.tqe_prev; \ 407 (elm)->field.tqe_next = (listelm); \ 408 *(listelm)->field.tqe_prev = (elm); \ 409 (listelm)->field.tqe_prev = &(elm)->field.tqe_next; \ 412 #define TAILQ_REMOVE(head, elm, field) do { \ 413 if (((elm)->field.tqe_next) != NULL) \ 414 (elm)->field.tqe_next->field.tqe_prev = \ 415 (elm)->field.tqe_prev; \ 417 (head)->tqh_last = (elm)->field.tqe_prev; \ 418 *(elm)->field.tqe_prev = (elm)->field.tqe_next; \ 419 _Q_ASSERT((head)->tqh_first != (elm)); \ 420 _Q_INVALIDATE((elm)->field.tqe_prev); \ 421 _Q_INVALIDATE((elm)->field.tqe_next); \ 424 #define TAILQ_REPLACE(head, elm, elm2, field) do { \ 425 if (((elm2)->field.tqe_next = (elm)->field.tqe_next) != NULL) \ 426 (elm2)->field.tqe_next->field.tqe_prev = \ 427 &(elm2)->field.tqe_next; \ 429 (head)->tqh_last = &(elm2)->field.tqe_next; \ 430 (elm2)->field.tqe_prev = (elm)->field.tqe_prev; \ 431 *(elm2)->field.tqe_prev = (elm2); \ 432 _Q_INVALIDATE((elm)->field.tqe_prev); \ 433 _Q_INVALIDATE((elm)->field.tqe_next); \ 439 #define CIRCLEQ_HEAD(name, type) \ 441 struct type *cqh_first; \ 442 struct type *cqh_last; \ 445 #define CIRCLEQ_HEAD_INITIALIZER(head) \ 446 { CIRCLEQ_END(&head), CIRCLEQ_END(&head) } 448 #define CIRCLEQ_ENTRY(type) \ 450 struct type *cqe_next; \ 451 struct type *cqe_prev; \ 457 #define CIRCLEQ_FIRST(head) ((head)->cqh_first) 458 #define CIRCLEQ_LAST(head) ((head)->cqh_last) 459 #define CIRCLEQ_END(head) ((void *)(head)) 460 #define CIRCLEQ_NEXT(elm, field) ((elm)->field.cqe_next) 461 #define CIRCLEQ_PREV(elm, field) ((elm)->field.cqe_prev) 462 #define CIRCLEQ_EMPTY(head) \ 463 (CIRCLEQ_FIRST(head) == CIRCLEQ_END(head)) 465 #define CIRCLEQ_FOREACH(var, head, field) \ 466 for((var) = CIRCLEQ_FIRST(head); \ 467 (var) != CIRCLEQ_END(head); \ 468 (var) = CIRCLEQ_NEXT(var, field)) 470 #define CIRCLEQ_FOREACH_REVERSE(var, head, field) \ 471 for((var) = CIRCLEQ_LAST(head); \ 472 (var) != CIRCLEQ_END(head); \ 473 (var) = CIRCLEQ_PREV(var, field)) 478 #define CIRCLEQ_INIT(head) do { \ 479 (head)->cqh_first = CIRCLEQ_END(head); \ 480 (head)->cqh_last = CIRCLEQ_END(head); \ 483 #define CIRCLEQ_INSERT_AFTER(head, listelm, elm, field) do { \ 484 (elm)->field.cqe_next = (listelm)->field.cqe_next; \ 485 (elm)->field.cqe_prev = (listelm); \ 486 if ((listelm)->field.cqe_next == CIRCLEQ_END(head)) \ 487 (head)->cqh_last = (elm); \ 489 (listelm)->field.cqe_next->field.cqe_prev = (elm); \ 490 (listelm)->field.cqe_next = (elm); \ 493 #define CIRCLEQ_INSERT_BEFORE(head, listelm, elm, field) do { \ 494 (elm)->field.cqe_next = (listelm); \ 495 (elm)->field.cqe_prev = (listelm)->field.cqe_prev; \ 496 if ((listelm)->field.cqe_prev == CIRCLEQ_END(head)) \ 497 (head)->cqh_first = (elm); \ 499 (listelm)->field.cqe_prev->field.cqe_next = (elm); \ 500 (listelm)->field.cqe_prev = (elm); \ 503 #define CIRCLEQ_INSERT_HEAD(head, elm, field) do { \ 504 (elm)->field.cqe_next = (head)->cqh_first; \ 505 (elm)->field.cqe_prev = CIRCLEQ_END(head); \ 506 if ((head)->cqh_last == CIRCLEQ_END(head)) \ 507 (head)->cqh_last = (elm); \ 509 (head)->cqh_first->field.cqe_prev = (elm); \ 510 (head)->cqh_first = (elm); \ 513 #define CIRCLEQ_INSERT_TAIL(head, elm, field) do { \ 514 (elm)->field.cqe_next = CIRCLEQ_END(head); \ 515 (elm)->field.cqe_prev = (head)->cqh_last; \ 516 if ((head)->cqh_first == CIRCLEQ_END(head)) \ 517 (head)->cqh_first = (elm); \ 519 (head)->cqh_last->field.cqe_next = (elm); \ 520 (head)->cqh_last = (elm); \ 523 #define CIRCLEQ_REMOVE(head, elm, field) do { \ 524 if ((elm)->field.cqe_next == CIRCLEQ_END(head)) \ 525 (head)->cqh_last = (elm)->field.cqe_prev; \ 527 (elm)->field.cqe_next->field.cqe_prev = \ 528 (elm)->field.cqe_prev; \ 529 if ((elm)->field.cqe_prev == CIRCLEQ_END(head)) \ 530 (head)->cqh_first = (elm)->field.cqe_next; \ 532 (elm)->field.cqe_prev->field.cqe_next = \ 533 (elm)->field.cqe_next; \ 534 _Q_INVALIDATE((elm)->field.cqe_prev); \ 535 _Q_INVALIDATE((elm)->field.cqe_next); \ 538 #define CIRCLEQ_REPLACE(head, elm, elm2, field) do { \ 539 if (((elm2)->field.cqe_next = (elm)->field.cqe_next) == \ 541 (head).cqh_last = (elm2); \ 543 (elm2)->field.cqe_next->field.cqe_prev = (elm2); \ 544 if (((elm2)->field.cqe_prev = (elm)->field.cqe_prev) == \ 546 (head).cqh_first = (elm2); \ 548 (elm2)->field.cqe_prev->field.cqe_next = (elm2); \ 549 _Q_INVALIDATE((elm)->field.cqe_prev); \ 550 _Q_INVALIDATE((elm)->field.cqe_next); \