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