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