1,11 → 1,12 |
#ifndef _LINUX_LIST_H |
#define _LINUX_LIST_H |
|
#include <linux/types.h> |
#include <linux/stddef.h> |
//#include <linux/poison.h> |
//#include <linux/prefetch.h> |
//#include <asm/system.h> |
#include <linux/poison.h> |
|
#define prefetch(x) __builtin_prefetch(x) |
|
/* |
* Simple doubly linked list implementation. |
* |
16,15 → 17,6 |
* using the generic single-entry routines. |
*/ |
|
#define LIST_POISON1 ((struct list_head*)0xFFFF0100) |
#define LIST_POISON2 ((struct list_head*)0xFFFF0200) |
|
#define prefetch(x) __builtin_prefetch(x) |
|
struct list_head { |
struct list_head *next, *prev; |
}; |
|
#define LIST_HEAD_INIT(name) { &(name), &(name) } |
|
#define LIST_HEAD(name) \ |
211,6 → 203,20 |
} |
|
/** |
* 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); |
} |
} |
|
/** |
* list_is_singular - tests whether a list has just one entry. |
* @head: the list to test. |
*/ |
489,7 → 495,7 |
pos = n, n = list_entry(n->member.next, typeof(*n), member)) |
|
/** |
* list_for_each_entry_safe_continue |
* list_for_each_entry_safe_continue - continue list iteration safe against removal |
* @pos: the type * to use as a loop cursor. |
* @n: another type * to use as temporary storage |
* @head: the head for your list. |
505,7 → 511,7 |
pos = n, n = list_entry(n->member.next, typeof(*n), member)) |
|
/** |
* list_for_each_entry_safe_from |
* list_for_each_entry_safe_from - iterate over list from current point safe against removal |
* @pos: the type * to use as a loop cursor. |
* @n: another type * to use as temporary storage |
* @head: the head for your list. |
520,7 → 526,7 |
pos = n, n = list_entry(n->member.next, typeof(*n), member)) |
|
/** |
* list_for_each_entry_safe_reverse |
* list_for_each_entry_safe_reverse - iterate backwards over list safe against removal |
* @pos: the type * to use as a loop cursor. |
* @n: another type * to use as temporary storage |
* @head: the head for your list. |
535,6 → 541,21 |
&pos->member != (head); \ |
pos = n, n = list_entry(n->member.prev, typeof(*n), member)) |
|
/** |
* 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) |
|
/* |
* Double linked lists with a single pointer list head. |
* Mostly useful for hash tables where the two pointer list head is |
542,14 → 563,6 |
* You lose the ability to access the tail in O(1). |
*/ |
|
struct hlist_head { |
struct hlist_node *first; |
}; |
|
struct hlist_node { |
struct hlist_node *next, **pprev; |
}; |
|
#define HLIST_HEAD_INIT { .first = NULL } |
#define HLIST_HEAD(name) struct hlist_head name = { .first = NULL } |
#define INIT_HLIST_HEAD(ptr) ((ptr)->first = NULL) |
581,8 → 594,8 |
static inline void hlist_del(struct hlist_node *n) |
{ |
__hlist_del(n); |
n->next = (struct hlist_node*)LIST_POISON1; |
n->pprev = (struct hlist_node**)LIST_POISON2; |
n->next = LIST_POISON1; |
n->pprev = LIST_POISON2; |
} |
|
static inline void hlist_del_init(struct hlist_node *n) |
624,6 → 637,12 |
next->next->pprev = &next->next; |
} |
|
/* 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; |
} |
|
/* |
* Move a list from one list head to another. Fixup the pprev |
* reference of the first entry if it exists. |