1 #ifndef _LINUX_LIST_H 2 #define _LINUX_LIST_H 3 4 #include <linux/types.h> 5 #include <linux/stddef.h> 6 #include <linux/poison.h> 7 #include <linux/const.h> 8 9 /* 10 * Simple doubly linked list implementation. 11 * 12 * Some of the internal functions ("__xxx") are useful when 13 * manipulating whole lists rather than single entries, as 14 * sometimes we already know the next/prev entries and we can 15 * generate better code by using them directly rather than 16 * using the generic single-entry routines. 17 */ 18 19 #define LIST_HEAD_INIT(name) { &(name), &(name) } 20 21 #define LIST_HEAD(name) \ 22 struct list_head name = LIST_HEAD_INIT(name) 23 24 static inline void INIT_LIST_HEAD(struct list_head *list) 25 { 26 list->next = list; 27 list->prev = list; 28 } 29 30 /* 31 * Insert a new entry between two known consecutive entries. 32 * 33 * This is only for internal list manipulation where we know 34 * the prev/next entries already! 35 */ 36 #ifndef CONFIG_DEBUG_LIST 37 static inline void __list_add(struct list_head *new, 38 struct list_head *prev, 39 struct list_head *next) 40 { 41 next->prev = new; 42 new->next = next; 43 new->prev = prev; 44 prev->next = new; 45 } 46 #else 47 extern void __list_add(struct list_head *new, 48 struct list_head *prev, 49 struct list_head *next); 50 #endif 51 52 /** 53 * list_add - add a new entry 54 * @new: new entry to be added 55 * @head: list head to add it after 56 * 57 * Insert a new entry after the specified head. 58 * This is good for implementing stacks. 59 */ 60 static inline void list_add(struct list_head *new, struct list_head *head) 61 { 62 __list_add(new, head, head->next); 63 } 64 65 66 /** 67 * list_add_tail - add a new entry 68 * @new: new entry to be added 69 * @head: list head to add it before 70 * 71 * Insert a new entry before the specified head. 72 * This is useful for implementing queues. 73 */ 74 static inline void list_add_tail(struct list_head *new, struct list_head *head) 75 { 76 __list_add(new, head->prev, head); 77 } 78 79 /* 80 * Delete a list entry by making the prev/next entries 81 * point to each other. 82 * 83 * This is only for internal list manipulation where we know 84 * the prev/next entries already! 85 */ 86 static inline void __list_del(struct list_head * prev, struct list_head * next) 87 { 88 next->prev = prev; 89 prev->next = next; 90 } 91 92 /** 93 * list_del - deletes entry from list. 94 * @entry: the element to delete from the list. 95 * Note: list_empty() on entry does not return true after this, the entry is 96 * in an undefined state. 97 */ 98 #ifndef CONFIG_DEBUG_LIST 99 static inline void __list_del_entry(struct list_head *entry) 100 { 101 __list_del(entry->prev, entry->next); 102 } 103 104 static inline void list_del(struct list_head *entry) 105 { 106 __list_del(entry->prev, entry->next); 107 entry->next = LIST_POISON1; 108 entry->prev = LIST_POISON2; 109 } 110 #else 111 extern void __list_del_entry(struct list_head *entry); 112 extern void list_del(struct list_head *entry); 113 #endif 114 115 /** 116 * list_replace - replace old entry by new one 117 * @old : the element to be replaced 118 * @new : the new element to insert 119 * 120 * If @old was empty, it will be overwritten. 121 */ 122 static inline void list_replace(struct list_head *old, 123 struct list_head *new) 124 { 125 new->next = old->next; 126 new->next->prev = new; 127 new->prev = old->prev; 128 new->prev->next = new; 129 } 130 131 static inline void list_replace_init(struct list_head *old, 132 struct list_head *new) 133 { 134 list_replace(old, new); 135 INIT_LIST_HEAD(old); 136 } 137 138 /** 139 * list_del_init - deletes entry from list and reinitialize it. 140 * @entry: the element to delete from the list. 141 */ 142 static inline void list_del_init(struct list_head *entry) 143 { 144 __list_del_entry(entry); 145 INIT_LIST_HEAD(entry); 146 } 147 148 /** 149 * list_move - delete from one list and add as another's head 150 * @list: the entry to move 151 * @head: the head that will precede our entry 152 */ 153 static inline void list_move(struct list_head *list, struct list_head *head) 154 { 155 __list_del_entry(list); 156 list_add(list, head); 157 } 158 159 /** 160 * list_move_tail - delete from one list and add as another's tail 161 * @list: the entry to move 162 * @head: the head that will follow our entry 163 */ 164 static inline void list_move_tail(struct list_head *list, 165 struct list_head *head) 166 { 167 __list_del_entry(list); 168 list_add_tail(list, head); 169 } 170 171 /** 172 * list_is_last - tests whether @list is the last entry in list @head 173 * @list: the entry to test 174 * @head: the head of the list 175 */ 176 static inline int list_is_last(const struct list_head *list, 177 const struct list_head *head) 178 { 179 return list->next == head; 180 } 181 182 /** 183 * list_empty - tests whether a list is empty 184 * @head: the list to test. 185 */ 186 static inline int list_empty(const struct list_head *head) 187 { 188 return head->next == head; 189 } 190 191 /** 192 * list_empty_careful - tests whether a list is empty and not being modified 193 * @head: the list to test 194 * 195 * Description: 196 * tests whether a list is empty _and_ checks that no other CPU might be 197 * in the process of modifying either member (next or prev) 198 * 199 * NOTE: using list_empty_careful() without synchronization 200 * can only be safe if the only activity that can happen 201 * to the list entry is list_del_init(). Eg. it cannot be used 202 * if another CPU could re-list_add() it. 203 */ 204 static inline int list_empty_careful(const struct list_head *head) 205 { 206 struct list_head *next = head->next; 207 return (next == head) && (next == head->prev); 208 } 209 210 /** 211 * list_rotate_left - rotate the list to the left 212 * @head: the head of the list 213 */ 214 static inline void list_rotate_left(struct list_head *head) 215 { 216 struct list_head *first; 217 218 if (!list_empty(head)) { 219 first = head->next; 220 list_move_tail(first, head); 221 } 222 } 223 224 /** 225 * list_is_singular - tests whether a list has just one entry. 226 * @head: the list to test. 227 */ 228 static inline int list_is_singular(const struct list_head *head) 229 { 230 return !list_empty(head) && (head->next == head->prev); 231 } 232 233 static inline void __list_cut_position(struct list_head *list, 234 struct list_head *head, struct list_head *entry) 235 { 236 struct list_head *new_first = entry->next; 237 list->next = head->next; 238 list->next->prev = list; 239 list->prev = entry; 240 entry->next = list; 241 head->next = new_first; 242 new_first->prev = head; 243 } 244 245 /** 246 * list_cut_position - cut a list into two 247 * @list: a new list to add all removed entries 248 * @head: a list with entries 249 * @entry: an entry within head, could be the head itself 250 * and if so we won't cut the list 251 * 252 * This helper moves the initial part of @head, up to and 253 * including @entry, from @head to @list. You should 254 * pass on @entry an element you know is on @head. @list 255 * should be an empty list or a list you do not care about 256 * losing its data. 257 * 258 */ 259 static inline void list_cut_position(struct list_head *list, 260 struct list_head *head, struct list_head *entry) 261 { 262 if (list_empty(head)) 263 return; 264 if (list_is_singular(head) && 265 (head->next != entry && head != entry)) 266 return; 267 if (entry == head) 268 INIT_LIST_HEAD(list); 269 else 270 __list_cut_position(list, head, entry); 271 } 272 273 static inline void __list_splice(const struct list_head *list, 274 struct list_head *prev, 275 struct list_head *next) 276 { 277 struct list_head *first = list->next; 278 struct list_head *last = list->prev; 279 280 first->prev = prev; 281 prev->next = first; 282 283 last->next = next; 284 next->prev = last; 285 } 286 287 /** 288 * list_splice - join two lists, this is designed for stacks 289 * @list: the new list to add. 290 * @head: the place to add it in the first list. 291 */ 292 static inline void list_splice(const struct list_head *list, 293 struct list_head *head) 294 { 295 if (!list_empty(list)) 296 __list_splice(list, head, head->next); 297 } 298 299 /** 300 * list_splice_tail - join two lists, each list being a queue 301 * @list: the new list to add. 302 * @head: the place to add it in the first list. 303 */ 304 static inline void list_splice_tail(struct list_head *list, 305 struct list_head *head) 306 { 307 if (!list_empty(list)) 308 __list_splice(list, head->prev, head); 309 } 310 311 /** 312 * list_splice_init - join two lists and reinitialise the emptied list. 313 * @list: the new list to add. 314 * @head: the place to add it in the first list. 315 * 316 * The list at @list is reinitialised 317 */ 318 static inline void list_splice_init(struct list_head *list, 319 struct list_head *head) 320 { 321 if (!list_empty(list)) { 322 __list_splice(list, head, head->next); 323 INIT_LIST_HEAD(list); 324 } 325 } 326 327 /** 328 * list_splice_tail_init - join two lists and reinitialise the emptied list 329 * @list: the new list to add. 330 * @head: the place to add it in the first list. 331 * 332 * Each of the lists is a queue. 333 * The list at @list is reinitialised 334 */ 335 static inline void list_splice_tail_init(struct list_head *list, 336 struct list_head *head) 337 { 338 if (!list_empty(list)) { 339 __list_splice(list, head->prev, head); 340 INIT_LIST_HEAD(list); 341 } 342 } 343 344 /** 345 * list_entry - get the struct for this entry 346 * @ptr: the &struct list_head pointer. 347 * @type: the type of the struct this is embedded in. 348 * @member: the name of the list_struct within the struct. 349 */ 350 #define list_entry(ptr, type, member) \ 351 container_of(ptr, type, member) 352 353 /** 354 * list_first_entry - get the first element from a list 355 * @ptr: the list head to take the element from. 356 * @type: the type of the struct this is embedded in. 357 * @member: the name of the list_struct within the struct. 358 * 359 * Note, that list is expected to be not empty. 360 */ 361 #define list_first_entry(ptr, type, member) \ 362 list_entry((ptr)->next, type, member) 363 364 /** 365 * list_first_entry_or_null - get the first element from a list 366 * @ptr: the list head to take the element from. 367 * @type: the type of the struct this is embedded in. 368 * @member: the name of the list_struct within the struct. 369 * 370 * Note that if the list is empty, it returns NULL. 371 */ 372 #define list_first_entry_or_null(ptr, type, member) \ 373 (!list_empty(ptr) ? list_first_entry(ptr, type, member) : NULL) 374 375 /** 376 * list_for_each - iterate over a list 377 * @pos: the &struct list_head to use as a loop cursor. 378 * @head: the head for your list. 379 */ 380 #define list_for_each(pos, head) \ 381 for (pos = (head)->next; pos != (head); pos = pos->next) 382 383 /** 384 * list_for_each_prev - iterate over a list backwards 385 * @pos: the &struct list_head to use as a loop cursor. 386 * @head: the head for your list. 387 */ 388 #define list_for_each_prev(pos, head) \ 389 for (pos = (head)->prev; pos != (head); pos = pos->prev) 390 391 /** 392 * list_for_each_safe - iterate over a list safe against removal of list entry 393 * @pos: the &struct list_head to use as a loop cursor. 394 * @n: another &struct list_head to use as temporary storage 395 * @head: the head for your list. 396 */ 397 #define list_for_each_safe(pos, n, head) \ 398 for (pos = (head)->next, n = pos->next; pos != (head); \ 399 pos = n, n = pos->next) 400 401 /** 402 * list_for_each_prev_safe - iterate over a list backwards safe against removal of list entry 403 * @pos: the &struct list_head to use as a loop cursor. 404 * @n: another &struct list_head to use as temporary storage 405 * @head: the head for your list. 406 */ 407 #define list_for_each_prev_safe(pos, n, head) \ 408 for (pos = (head)->prev, n = pos->prev; \ 409 pos != (head); \ 410 pos = n, n = pos->prev) 411 412 /** 413 * list_for_each_entry - iterate over list of given type 414 * @pos: the type * to use as a loop cursor. 415 * @head: the head for your list. 416 * @member: the name of the list_struct within the struct. 417 */ 418 #define list_for_each_entry(pos, head, member) \ 419 for (pos = list_entry((head)->next, typeof(*pos), member); \ 420 &pos->member != (head); \ 421 pos = list_entry(pos->member.next, typeof(*pos), member)) 422 423 /** 424 * list_for_each_entry_reverse - iterate backwards over list of given type. 425 * @pos: the type * to use as a loop cursor. 426 * @head: the head for your list. 427 * @member: the name of the list_struct within the struct. 428 */ 429 #define list_for_each_entry_reverse(pos, head, member) \ 430 for (pos = list_entry((head)->prev, typeof(*pos), member); \ 431 &pos->member != (head); \ 432 pos = list_entry(pos->member.prev, typeof(*pos), member)) 433 434 /** 435 * list_prepare_entry - prepare a pos entry for use in list_for_each_entry_continue() 436 * @pos: the type * to use as a start point 437 * @head: the head of the list 438 * @member: the name of the list_struct within the struct. 439 * 440 * Prepares a pos entry for use as a start point in list_for_each_entry_continue(). 441 */ 442 #define list_prepare_entry(pos, head, member) \ 443 ((pos) ? : list_entry(head, typeof(*pos), member)) 444 445 /** 446 * list_for_each_entry_continue - continue iteration over list of given type 447 * @pos: the type * to use as a loop cursor. 448 * @head: the head for your list. 449 * @member: the name of the list_struct within the struct. 450 * 451 * Continue to iterate over list of given type, continuing after 452 * the current position. 453 */ 454 #define list_for_each_entry_continue(pos, head, member) \ 455 for (pos = list_entry(pos->member.next, typeof(*pos), member); \ 456 &pos->member != (head); \ 457 pos = list_entry(pos->member.next, typeof(*pos), member)) 458 459 /** 460 * list_for_each_entry_continue_reverse - iterate backwards from the given point 461 * @pos: the type * to use as a loop cursor. 462 * @head: the head for your list. 463 * @member: the name of the list_struct within the struct. 464 * 465 * Start to iterate over list of given type backwards, continuing after 466 * the current position. 467 */ 468 #define list_for_each_entry_continue_reverse(pos, head, member) \ 469 for (pos = list_entry(pos->member.prev, typeof(*pos), member); \ 470 &pos->member != (head); \ 471 pos = list_entry(pos->member.prev, typeof(*pos), member)) 472 473 /** 474 * list_for_each_entry_from - iterate over list of given type from the current point 475 * @pos: the type * to use as a loop cursor. 476 * @head: the head for your list. 477 * @member: the name of the list_struct within the struct. 478 * 479 * Iterate over list of given type, continuing from current position. 480 */ 481 #define list_for_each_entry_from(pos, head, member) \ 482 for (; &pos->member != (head); \ 483 pos = list_entry(pos->member.next, typeof(*pos), member)) 484 485 /** 486 * list_for_each_entry_safe - iterate over list of given type safe against removal of list entry 487 * @pos: the type * to use as a loop cursor. 488 * @n: another type * to use as temporary storage 489 * @head: the head for your list. 490 * @member: the name of the list_struct within the struct. 491 */ 492 #define list_for_each_entry_safe(pos, n, head, member) \ 493 for (pos = list_entry((head)->next, typeof(*pos), member), \ 494 n = list_entry(pos->member.next, typeof(*pos), member); \ 495 &pos->member != (head); \ 496 pos = n, n = list_entry(n->member.next, typeof(*n), member)) 497 498 /** 499 * list_for_each_entry_safe_continue - continue list iteration safe against removal 500 * @pos: the type * to use as a loop cursor. 501 * @n: another type * to use as temporary storage 502 * @head: the head for your list. 503 * @member: the name of the list_struct within the struct. 504 * 505 * Iterate over list of given type, continuing after current point, 506 * safe against removal of list entry. 507 */ 508 #define list_for_each_entry_safe_continue(pos, n, head, member) \ 509 for (pos = list_entry(pos->member.next, typeof(*pos), member), \ 510 n = list_entry(pos->member.next, typeof(*pos), member); \ 511 &pos->member != (head); \ 512 pos = n, n = list_entry(n->member.next, typeof(*n), member)) 513 514 /** 515 * list_for_each_entry_safe_from - iterate over list from current point safe against removal 516 * @pos: the type * to use as a loop cursor. 517 * @n: another type * to use as temporary storage 518 * @head: the head for your list. 519 * @member: the name of the list_struct within the struct. 520 * 521 * Iterate over list of given type from current point, safe against 522 * removal of list entry. 523 */ 524 #define list_for_each_entry_safe_from(pos, n, head, member) \ 525 for (n = list_entry(pos->member.next, typeof(*pos), member); \ 526 &pos->member != (head); \ 527 pos = n, n = list_entry(n->member.next, typeof(*n), member)) 528 529 /** 530 * list_for_each_entry_safe_reverse - iterate backwards over list safe against removal 531 * @pos: the type * to use as a loop cursor. 532 * @n: another type * to use as temporary storage 533 * @head: the head for your list. 534 * @member: the name of the list_struct within the struct. 535 * 536 * Iterate backwards over list of given type, safe against removal 537 * of list entry. 538 */ 539 #define list_for_each_entry_safe_reverse(pos, n, head, member) \ 540 for (pos = list_entry((head)->prev, typeof(*pos), member), \ 541 n = list_entry(pos->member.prev, typeof(*pos), member); \ 542 &pos->member != (head); \ 543 pos = n, n = list_entry(n->member.prev, typeof(*n), member)) 544 545 /** 546 * list_safe_reset_next - reset a stale list_for_each_entry_safe loop 547 * @pos: the loop cursor used in the list_for_each_entry_safe loop 548 * @n: temporary storage used in list_for_each_entry_safe 549 * @member: the name of the list_struct within the struct. 550 * 551 * list_safe_reset_next is not safe to use in general if the list may be 552 * modified concurrently (eg. the lock is dropped in the loop body). An 553 * exception to this is if the cursor element (pos) is pinned in the list, 554 * and list_safe_reset_next is called after re-taking the lock and before 555 * completing the current iteration of the loop body. 556 */ 557 #define list_safe_reset_next(pos, n, member) \ 558 n = list_entry(pos->member.next, typeof(*pos), member) 559 560 /* 561 * Double linked lists with a single pointer list head. 562 * Mostly useful for hash tables where the two pointer list head is 563 * too wasteful. 564 * You lose the ability to access the tail in O(1). 565 */ 566 567 #define HLIST_HEAD_INIT { .first = NULL } 568 #define HLIST_HEAD(name) struct hlist_head name = { .first = NULL } 569 #define INIT_HLIST_HEAD(ptr) ((ptr)->first = NULL) 570 static inline void INIT_HLIST_NODE(struct hlist_node *h) 571 { 572 h->next = NULL; 573 h->pprev = NULL; 574 } 575 576 static inline int hlist_unhashed(const struct hlist_node *h) 577 { 578 return !h->pprev; 579 } 580 581 static inline int hlist_empty(const struct hlist_head *h) 582 { 583 return !h->first; 584 } 585 586 static inline void __hlist_del(struct hlist_node *n) 587 { 588 struct hlist_node *next = n->next; 589 struct hlist_node **pprev = n->pprev; 590 *pprev = next; 591 if (next) 592 next->pprev = pprev; 593 } 594 595 static inline void hlist_del(struct hlist_node *n) 596 { 597 __hlist_del(n); 598 n->next = LIST_POISON1; 599 n->pprev = LIST_POISON2; 600 } 601 602 static inline void hlist_del_init(struct hlist_node *n) 603 { 604 if (!hlist_unhashed(n)) { 605 __hlist_del(n); 606 INIT_HLIST_NODE(n); 607 } 608 } 609 610 static inline void hlist_add_head(struct hlist_node *n, struct hlist_head *h) 611 { 612 struct hlist_node *first = h->first; 613 n->next = first; 614 if (first) 615 first->pprev = &n->next; 616 h->first = n; 617 n->pprev = &h->first; 618 } 619 620 /* next must be != NULL */ 621 static inline void hlist_add_before(struct hlist_node *n, 622 struct hlist_node *next) 623 { 624 n->pprev = next->pprev; 625 n->next = next; 626 next->pprev = &n->next; 627 *(n->pprev) = n; 628 } 629 630 static inline void hlist_add_after(struct hlist_node *n, 631 struct hlist_node *next) 632 { 633 next->next = n->next; 634 n->next = next; 635 next->pprev = &n->next; 636 637 if(next->next) 638 next->next->pprev = &next->next; 639 } 640 641 /* after that we'll appear to be on some hlist and hlist_del will work */ 642 static inline void hlist_add_fake(struct hlist_node *n) 643 { 644 n->pprev = &n->next; 645 } 646 647 /* 648 * Move a list from one list head to another. Fixup the pprev 649 * reference of the first entry if it exists. 650 */ 651 static inline void hlist_move_list(struct hlist_head *old, 652 struct hlist_head *new) 653 { 654 new->first = old->first; 655 if (new->first) 656 new->first->pprev = &new->first; 657 old->first = NULL; 658 } 659 660 #define hlist_entry(ptr, type, member) container_of(ptr,type,member) 661 662 #define hlist_for_each(pos, head) \ 663 for (pos = (head)->first; pos ; pos = pos->next) 664 665 #define hlist_for_each_safe(pos, n, head) \ 666 for (pos = (head)->first; pos && ({ n = pos->next; 1; }); \ 667 pos = n) 668 669 #define hlist_entry_safe(ptr, type, member) \ 670 ({ typeof(ptr) ____ptr = (ptr); \ 671 ____ptr ? hlist_entry(____ptr, type, member) : NULL; \ 672 }) 673 674 /** 675 * hlist_for_each_entry - iterate over list of given type 676 * @pos: the type * to use as a loop cursor. 677 * @head: the head for your list. 678 * @member: the name of the hlist_node within the struct. 679 */ 680 #define hlist_for_each_entry(pos, head, member) \ 681 for (pos = hlist_entry_safe((head)->first, typeof(*(pos)), member);\ 682 pos; \ 683 pos = hlist_entry_safe((pos)->member.next, typeof(*(pos)), member)) 684 685 /** 686 * hlist_for_each_entry_continue - iterate over a hlist continuing after current point 687 * @pos: the type * to use as a loop cursor. 688 * @member: the name of the hlist_node within the struct. 689 */ 690 #define hlist_for_each_entry_continue(pos, member) \ 691 for (pos = hlist_entry_safe((pos)->member.next, typeof(*(pos)), member);\ 692 pos; \ 693 pos = hlist_entry_safe((pos)->member.next, typeof(*(pos)), member)) 694 695 /** 696 * hlist_for_each_entry_from - iterate over a hlist continuing from current point 697 * @pos: the type * to use as a loop cursor. 698 * @member: the name of the hlist_node within the struct. 699 */ 700 #define hlist_for_each_entry_from(pos, member) \ 701 for (; pos; \ 702 pos = hlist_entry_safe((pos)->member.next, typeof(*(pos)), member)) 703 704 /** 705 * hlist_for_each_entry_safe - iterate over list of given type safe against removal of list entry 706 * @pos: the type * to use as a loop cursor. 707 * @n: another &struct hlist_node to use as temporary storage 708 * @head: the head for your list. 709 * @member: the name of the hlist_node within the struct. 710 */ 711 #define hlist_for_each_entry_safe(pos, n, head, member) \ 712 for (pos = hlist_entry_safe((head)->first, typeof(*pos), member);\ 713 pos && ({ n = pos->member.next; 1; }); \ 714 pos = hlist_entry_safe(n, typeof(*pos), member)) 715 716 #endif 717
