Blame view
include/linux/list.h
20.7 KB
1da177e4c Linux-2.6.12-rc2 |
1 2 |
#ifndef _LINUX_LIST_H #define _LINUX_LIST_H |
de5d9bf65 Move list types f... |
3 |
#include <linux/types.h> |
1da177e4c Linux-2.6.12-rc2 |
4 |
#include <linux/stddef.h> |
c9cf55285 [PATCH] add poiso... |
5 |
#include <linux/poison.h> |
e66eed651 list: remove pref... |
6 |
#include <linux/const.h> |
1da177e4c Linux-2.6.12-rc2 |
7 8 |
/* |
1da177e4c Linux-2.6.12-rc2 |
9 10 11 12 13 14 15 16 |
* 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 Linux-2.6.12-rc2 |
17 18 19 20 |
#define LIST_HEAD_INIT(name) { &(name), &(name) } #define LIST_HEAD(name) \ struct list_head name = LIST_HEAD_INIT(name) |
490d6ab17 [PATCH] list.h: d... |
21 22 23 24 25 |
static inline void INIT_LIST_HEAD(struct list_head *list) { list->next = list; list->prev = list; } |
1da177e4c Linux-2.6.12-rc2 |
26 27 28 29 30 31 32 |
/* * 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 [PATCH] Debug var... |
33 |
#ifndef CONFIG_DEBUG_LIST |
1da177e4c Linux-2.6.12-rc2 |
34 35 36 37 38 39 40 41 42 |
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 [PATCH] Debug var... |
43 44 45 46 47 |
#else extern void __list_add(struct list_head *new, struct list_head *prev, struct list_head *next); #endif |
1da177e4c Linux-2.6.12-rc2 |
48 49 50 51 52 53 54 55 56 57 58 59 60 |
/** * 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 [PATCH] Debug var... |
61 |
|
1da177e4c Linux-2.6.12-rc2 |
62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 |
/** * 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 Linux-2.6.12-rc2 |
77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 |
* 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 [PATCH] Numerous ... |
92 |
* Note: list_empty() on entry does not return true after this, the entry is |
1da177e4c Linux-2.6.12-rc2 |
93 94 |
* in an undefined state. */ |
199a9afc3 [PATCH] Debug var... |
95 |
#ifndef CONFIG_DEBUG_LIST |
3c18d4de8 Expand CONFIG_DEB... |
96 97 98 99 |
static inline void __list_del_entry(struct list_head *entry) { __list_del(entry->prev, entry->next); } |
1da177e4c Linux-2.6.12-rc2 |
100 101 102 103 104 105 |
static inline void list_del(struct list_head *entry) { __list_del(entry->prev, entry->next); entry->next = LIST_POISON1; entry->prev = LIST_POISON2; } |
199a9afc3 [PATCH] Debug var... |
106 |
#else |
3c18d4de8 Expand CONFIG_DEB... |
107 |
extern void __list_del_entry(struct list_head *entry); |
199a9afc3 [PATCH] Debug var... |
108 109 |
extern void list_del(struct list_head *entry); #endif |
1da177e4c Linux-2.6.12-rc2 |
110 111 |
/** |
54e737703 [PATCH] list: int... |
112 113 114 |
* list_replace - replace old entry by new one * @old : the element to be replaced * @new : the new element to insert |
72fd4a35a [PATCH] Numerous ... |
115 116 |
* * If @old was empty, it will be overwritten. |
54e737703 [PATCH] list: int... |
117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 |
*/ 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 [PATCH] fix vario... |
133 |
/** |
1da177e4c Linux-2.6.12-rc2 |
134 135 136 137 138 |
* 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) { |
3c18d4de8 Expand CONFIG_DEB... |
139 |
__list_del_entry(entry); |
1da177e4c Linux-2.6.12-rc2 |
140 141 142 143 144 145 146 147 148 149 |
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) { |
3c18d4de8 Expand CONFIG_DEB... |
150 |
__list_del_entry(list); |
78db2ad6f include/linux: tr... |
151 |
list_add(list, head); |
1da177e4c Linux-2.6.12-rc2 |
152 153 154 155 156 157 158 159 160 161 |
} /** * 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) { |
3c18d4de8 Expand CONFIG_DEB... |
162 |
__list_del_entry(list); |
78db2ad6f include/linux: tr... |
163 |
list_add_tail(list, head); |
1da177e4c Linux-2.6.12-rc2 |
164 165 166 |
} /** |
e8f4d97e1 [PATCH] list_is_l... |
167 168 169 170 171 172 173 174 175 176 177 |
* 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 Linux-2.6.12-rc2 |
178 179 180 181 182 183 184 185 186 |
* 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 [PATCH] fix list.... |
187 188 189 190 191 192 |
* 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 Linux-2.6.12-rc2 |
193 194 195 196 197 |
* * 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 Linux-2.6.12-rc2 |
198 199 200 201 202 |
*/ static inline int list_empty_careful(const struct list_head *head) { struct list_head *next = head->next; return (next == head) && (next == head->prev); |
996025728 list.h: add list_... |
203 204 205 |
} /** |
5908cdc85 list: Introduce l... |
206 207 208 209 210 211 212 213 214 215 216 217 218 219 |
* 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 list.h: add list_... |
220 221 222 223 224 225 |
* 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 Linux-2.6.12-rc2 |
226 |
} |
00e8a4da8 list.h: add list_... |
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 262 263 264 265 |
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 lists: add "const... |
266 |
static inline void __list_splice(const struct list_head *list, |
7d283aee5 list.h: Add list_... |
267 268 |
struct list_head *prev, struct list_head *next) |
1da177e4c Linux-2.6.12-rc2 |
269 270 271 |
{ struct list_head *first = list->next; struct list_head *last = list->prev; |
1da177e4c Linux-2.6.12-rc2 |
272 |
|
7d283aee5 list.h: Add list_... |
273 274 |
first->prev = prev; prev->next = first; |
1da177e4c Linux-2.6.12-rc2 |
275 |
|
7d283aee5 list.h: Add list_... |
276 277 |
last->next = next; next->prev = last; |
1da177e4c Linux-2.6.12-rc2 |
278 279 280 |
} /** |
7d283aee5 list.h: Add list_... |
281 |
* list_splice - join two lists, this is designed for stacks |
1da177e4c Linux-2.6.12-rc2 |
282 283 284 |
* @list: the new list to add. * @head: the place to add it in the first list. */ |
95d8c365b lists: add "const... |
285 286 |
static inline void list_splice(const struct list_head *list, struct list_head *head) |
1da177e4c Linux-2.6.12-rc2 |
287 288 |
{ if (!list_empty(list)) |
7d283aee5 list.h: Add list_... |
289 290 291 292 293 294 295 296 297 298 299 300 301 |
__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 Linux-2.6.12-rc2 |
302 303 304 305 306 307 308 309 310 311 312 313 314 |
} /** * 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 list.h: Add list_... |
315 316 317 318 319 320 |
__list_splice(list, head, head->next); INIT_LIST_HEAD(list); } } /** |
6724cce8f list.h: fix fatal... |
321 |
* list_splice_tail_init - join two lists and reinitialise the emptied list |
7d283aee5 list.h: Add list_... |
322 323 324 |
* @list: the new list to add. * @head: the place to add it in the first list. * |
6724cce8f list.h: fix fatal... |
325 |
* Each of the lists is a queue. |
7d283aee5 list.h: Add list_... |
326 327 328 329 330 331 332 |
* 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 Linux-2.6.12-rc2 |
333 334 335 336 337 338 339 340 341 342 343 344 345 346 |
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 Introduce a handy... |
347 348 349 350 351 352 353 354 355 356 357 |
* 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 Linux-2.6.12-rc2 |
358 |
* list_for_each - iterate over a list |
8e3a67a99 [PATCH] list.h do... |
359 |
* @pos: the &struct list_head to use as a loop cursor. |
1da177e4c Linux-2.6.12-rc2 |
360 361 362 |
* @head: the head for your list. */ #define list_for_each(pos, head) \ |
e66eed651 list: remove pref... |
363 |
for (pos = (head)->next; pos != (head); pos = pos->next) |
1da177e4c Linux-2.6.12-rc2 |
364 365 366 |
/** * __list_for_each - iterate over a list |
8e3a67a99 [PATCH] list.h do... |
367 |
* @pos: the &struct list_head to use as a loop cursor. |
1da177e4c Linux-2.6.12-rc2 |
368 369 |
* @head: the head for your list. * |
e66eed651 list: remove pref... |
370 371 |
* This variant doesn't differ from list_for_each() any more. * We don't do prefetching in either case. |
1da177e4c Linux-2.6.12-rc2 |
372 373 374 375 376 377 |
*/ #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 [PATCH] list.h do... |
378 |
* @pos: the &struct list_head to use as a loop cursor. |
1da177e4c Linux-2.6.12-rc2 |
379 380 381 |
* @head: the head for your list. */ #define list_for_each_prev(pos, head) \ |
e66eed651 list: remove pref... |
382 |
for (pos = (head)->prev; pos != (head); pos = pos->prev) |
1da177e4c Linux-2.6.12-rc2 |
383 384 |
/** |
fe96e57d7 [PATCH] fix list.... |
385 |
* list_for_each_safe - iterate over a list safe against removal of list entry |
8e3a67a99 [PATCH] list.h do... |
386 |
* @pos: the &struct list_head to use as a loop cursor. |
1da177e4c Linux-2.6.12-rc2 |
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 kernel-api docboo... |
395 |
* list_for_each_prev_safe - iterate over a list backwards safe against removal of list entry |
37c42524d shrink_dcache_sb ... |
396 397 398 399 400 401 |
* @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; \ |
e66eed651 list: remove pref... |
402 |
pos != (head); \ |
37c42524d shrink_dcache_sb ... |
403 404 405 |
pos = n, n = pos->prev) /** |
1da177e4c Linux-2.6.12-rc2 |
406 |
* list_for_each_entry - iterate over list of given type |
8e3a67a99 [PATCH] list.h do... |
407 |
* @pos: the type * to use as a loop cursor. |
1da177e4c Linux-2.6.12-rc2 |
408 409 410 411 412 |
* @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); \ |
e66eed651 list: remove pref... |
413 |
&pos->member != (head); \ |
1da177e4c Linux-2.6.12-rc2 |
414 415 416 417 |
pos = list_entry(pos->member.next, typeof(*pos), member)) /** * list_for_each_entry_reverse - iterate backwards over list of given type. |
8e3a67a99 [PATCH] list.h do... |
418 |
* @pos: the type * to use as a loop cursor. |
1da177e4c Linux-2.6.12-rc2 |
419 420 421 422 423 |
* @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); \ |
e66eed651 list: remove pref... |
424 |
&pos->member != (head); \ |
1da177e4c Linux-2.6.12-rc2 |
425 426 427 |
pos = list_entry(pos->member.prev, typeof(*pos), member)) /** |
72fd4a35a [PATCH] Numerous ... |
428 |
* list_prepare_entry - prepare a pos entry for use in list_for_each_entry_continue() |
1da177e4c Linux-2.6.12-rc2 |
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 [PATCH] fix list.... |
432 |
* |
72fd4a35a [PATCH] Numerous ... |
433 |
* Prepares a pos entry for use as a start point in list_for_each_entry_continue(). |
1da177e4c Linux-2.6.12-rc2 |
434 435 436 437 438 |
*/ #define list_prepare_entry(pos, head, member) \ ((pos) ? : list_entry(head, typeof(*pos), member)) /** |
fe96e57d7 [PATCH] fix list.... |
439 |
* list_for_each_entry_continue - continue iteration over list of given type |
8e3a67a99 [PATCH] list.h do... |
440 |
* @pos: the type * to use as a loop cursor. |
1da177e4c Linux-2.6.12-rc2 |
441 442 |
* @head: the head for your list. * @member: the name of the list_struct within the struct. |
fe96e57d7 [PATCH] fix list.... |
443 444 445 |
* * Continue to iterate over list of given type, continuing after * the current position. |
1da177e4c Linux-2.6.12-rc2 |
446 447 448 |
*/ #define list_for_each_entry_continue(pos, head, member) \ for (pos = list_entry(pos->member.next, typeof(*pos), member); \ |
e66eed651 list: remove pref... |
449 |
&pos->member != (head); \ |
1da177e4c Linux-2.6.12-rc2 |
450 451 452 |
pos = list_entry(pos->member.next, typeof(*pos), member)) /** |
768f3591e [NETNS]: Cleanup ... |
453 454 455 456 457 458 459 460 461 462 |
* 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); \ |
e66eed651 list: remove pref... |
463 |
&pos->member != (head); \ |
768f3591e [NETNS]: Cleanup ... |
464 465 466 |
pos = list_entry(pos->member.prev, typeof(*pos), member)) /** |
fe96e57d7 [PATCH] fix list.... |
467 |
* list_for_each_entry_from - iterate over list of given type from the current point |
8e3a67a99 [PATCH] list.h do... |
468 |
* @pos: the type * to use as a loop cursor. |
e229c2fb3 [LIST]: Introduce... |
469 470 |
* @head: the head for your list. * @member: the name of the list_struct within the struct. |
fe96e57d7 [PATCH] fix list.... |
471 472 |
* * Iterate over list of given type, continuing from current position. |
e229c2fb3 [LIST]: Introduce... |
473 474 |
*/ #define list_for_each_entry_from(pos, head, member) \ |
e66eed651 list: remove pref... |
475 |
for (; &pos->member != (head); \ |
e229c2fb3 [LIST]: Introduce... |
476 477 478 |
pos = list_entry(pos->member.next, typeof(*pos), member)) /** |
1da177e4c Linux-2.6.12-rc2 |
479 |
* list_for_each_entry_safe - iterate over list of given type safe against removal of list entry |
8e3a67a99 [PATCH] list.h do... |
480 |
* @pos: the type * to use as a loop cursor. |
1da177e4c Linux-2.6.12-rc2 |
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 lib: fix first li... |
492 |
* list_for_each_entry_safe_continue - continue list iteration safe against removal |
8e3a67a99 [PATCH] list.h do... |
493 |
* @pos: the type * to use as a loop cursor. |
74459dc7b [LIST]: Introduce... |
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 [PATCH] fix list.... |
497 498 499 |
* * Iterate over list of given type, continuing after current point, * safe against removal of list entry. |
74459dc7b [LIST]: Introduce... |
500 501 |
*/ #define list_for_each_entry_safe_continue(pos, n, head, member) \ |
8c60f3fab [CCID3]: Separate... |
502 503 |
for (pos = list_entry(pos->member.next, typeof(*pos), member), \ n = list_entry(pos->member.next, typeof(*pos), member); \ |
d8dcffee8 [LIST]: Introduce... |
504 505 506 507 |
&pos->member != (head); \ pos = n, n = list_entry(n->member.next, typeof(*n), member)) /** |
9a86e2bad lib: fix first li... |
508 |
* list_for_each_entry_safe_from - iterate over list from current point safe against removal |
8e3a67a99 [PATCH] list.h do... |
509 |
* @pos: the type * to use as a loop cursor. |
d8dcffee8 [LIST]: Introduce... |
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 [PATCH] fix list.... |
513 514 515 |
* * Iterate over list of given type from current point, safe against * removal of list entry. |
d8dcffee8 [LIST]: Introduce... |
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 [LIST]: Introduce... |
519 520 521 522 |
&pos->member != (head); \ pos = n, n = list_entry(n->member.next, typeof(*n), member)) /** |
9a86e2bad lib: fix first li... |
523 |
* list_for_each_entry_safe_reverse - iterate backwards over list safe against removal |
8e3a67a99 [PATCH] list.h do... |
524 |
* @pos: the type * to use as a loop cursor. |
0ad42352c [PATCH] Add list_... |
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 [PATCH] fix list.... |
528 529 530 |
* * Iterate backwards over list of given type, safe against removal * of list entry. |
0ad42352c [PATCH] Add list_... |
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 fs: fix superbloc... |
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 Linux-2.6.12-rc2 |
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 Linux-2.6.12-rc2 |
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 [PATCH] list.h: d... |
560 561 562 563 564 |
static inline void INIT_HLIST_NODE(struct hlist_node *h) { h->next = NULL; h->pprev = NULL; } |
1da177e4c Linux-2.6.12-rc2 |
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 Linux-2.6.12-rc2 |
591 592 |
static inline void hlist_del_init(struct hlist_node *n) { |
da753beae [NET]: use hlist_... |
593 |
if (!hlist_unhashed(n)) { |
1da177e4c Linux-2.6.12-rc2 |
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 Linux-2.6.12-rc2 |
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; } |
756acc2d6 list.h: new helpe... |
628 629 630 631 632 |
/* after that we'll appear to be on some hlist and hlist_del will work */ static inline void hlist_add_fake(struct hlist_node *n) { n->pprev = &n->next; } |
673d62cc5 debugobjects: fix... |
633 634 635 636 637 638 639 640 641 642 643 644 |
/* * 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 Linux-2.6.12-rc2 |
645 646 647 |
#define hlist_entry(ptr, type, member) container_of(ptr,type,member) #define hlist_for_each(pos, head) \ |
75d65a425 hlist: remove sof... |
648 |
for (pos = (head)->first; pos ; pos = pos->next) |
1da177e4c Linux-2.6.12-rc2 |
649 650 651 652 |
#define hlist_for_each_safe(pos, n, head) \ for (pos = (head)->first; pos && ({ n = pos->next; 1; }); \ pos = n) |
1da177e4c Linux-2.6.12-rc2 |
653 654 |
/** * hlist_for_each_entry - iterate over list of given type |
8e3a67a99 [PATCH] list.h do... |
655 656 |
* @tpos: the type * to use as a loop cursor. * @pos: the &struct hlist_node to use as a loop cursor. |
1da177e4c Linux-2.6.12-rc2 |
657 658 659 660 661 |
* @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; \ |
75d65a425 hlist: remove sof... |
662 |
pos && \ |
1da177e4c Linux-2.6.12-rc2 |
663 664 665 666 |
({ tpos = hlist_entry(pos, typeof(*tpos), member); 1;}); \ pos = pos->next) /** |
fe96e57d7 [PATCH] fix list.... |
667 |
* hlist_for_each_entry_continue - iterate over a hlist continuing after current point |
8e3a67a99 [PATCH] list.h do... |
668 669 |
* @tpos: the type * to use as a loop cursor. * @pos: the &struct hlist_node to use as a loop cursor. |
1da177e4c Linux-2.6.12-rc2 |
670 671 672 673 |
* @member: the name of the hlist_node within the struct. */ #define hlist_for_each_entry_continue(tpos, pos, member) \ for (pos = (pos)->next; \ |
75d65a425 hlist: remove sof... |
674 |
pos && \ |
1da177e4c Linux-2.6.12-rc2 |
675 676 677 678 |
({ tpos = hlist_entry(pos, typeof(*tpos), member); 1;}); \ pos = pos->next) /** |
fe96e57d7 [PATCH] fix list.... |
679 |
* hlist_for_each_entry_from - iterate over a hlist continuing from current point |
8e3a67a99 [PATCH] list.h do... |
680 681 |
* @tpos: the type * to use as a loop cursor. * @pos: the &struct hlist_node to use as a loop cursor. |
1da177e4c Linux-2.6.12-rc2 |
682 683 684 |
* @member: the name of the hlist_node within the struct. */ #define hlist_for_each_entry_from(tpos, pos, member) \ |
75d65a425 hlist: remove sof... |
685 |
for (; pos && \ |
1da177e4c Linux-2.6.12-rc2 |
686 687 688 689 690 |
({ 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 [PATCH] list.h do... |
691 692 |
* @tpos: the type * to use as a loop cursor. * @pos: the &struct hlist_node to use as a loop cursor. |
1da177e4c Linux-2.6.12-rc2 |
693 694 695 696 697 698 699 700 701 |
* @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 Linux-2.6.12-rc2 |
702 |
#endif |