xref: /openbmc/linux/scripts/kconfig/list.h (revision 6774def6)
1 #ifndef LIST_H
2 #define LIST_H
3 
4 /*
5  * Copied from include/linux/...
6  */
7 
8 #undef offsetof
9 #define offsetof(TYPE, MEMBER) ((size_t) &((TYPE *)0)->MEMBER)
10 
11 /**
12  * container_of - cast a member of a structure out to the containing structure
13  * @ptr:        the pointer to the member.
14  * @type:       the type of the container struct this is embedded in.
15  * @member:     the name of the member within the struct.
16  *
17  */
18 #define container_of(ptr, type, member) ({                      \
19 	const typeof( ((type *)0)->member ) *__mptr = (ptr);    \
20 	(type *)( (char *)__mptr - offsetof(type,member) );})
21 
22 
23 struct list_head {
24 	struct list_head *next, *prev;
25 };
26 
27 
28 #define LIST_HEAD_INIT(name) { &(name), &(name) }
29 
30 #define LIST_HEAD(name) \
31 	struct list_head name = LIST_HEAD_INIT(name)
32 
33 /**
34  * list_entry - get the struct for this entry
35  * @ptr:	the &struct list_head pointer.
36  * @type:	the type of the struct this is embedded in.
37  * @member:	the name of the list_head within the struct.
38  */
39 #define list_entry(ptr, type, member) \
40 	container_of(ptr, type, member)
41 
42 /**
43  * list_for_each_entry	-	iterate over list of given type
44  * @pos:	the type * to use as a loop cursor.
45  * @head:	the head for your list.
46  * @member:	the name of the list_head within the struct.
47  */
48 #define list_for_each_entry(pos, head, member)				\
49 	for (pos = list_entry((head)->next, typeof(*pos), member);	\
50 	     &pos->member != (head); 	\
51 	     pos = list_entry(pos->member.next, typeof(*pos), member))
52 
53 /**
54  * list_for_each_entry_safe - iterate over list of given type safe against removal of list entry
55  * @pos:	the type * to use as a loop cursor.
56  * @n:		another type * to use as temporary storage
57  * @head:	the head for your list.
58  * @member:	the name of the list_head within the struct.
59  */
60 #define list_for_each_entry_safe(pos, n, head, member)			\
61 	for (pos = list_entry((head)->next, typeof(*pos), member),	\
62 		n = list_entry(pos->member.next, typeof(*pos), member);	\
63 	     &pos->member != (head);					\
64 	     pos = n, n = list_entry(n->member.next, typeof(*n), member))
65 
66 /**
67  * list_empty - tests whether a list is empty
68  * @head: the list to test.
69  */
70 static inline int list_empty(const struct list_head *head)
71 {
72 	return head->next == head;
73 }
74 
75 /*
76  * Insert a new entry between two known consecutive entries.
77  *
78  * This is only for internal list manipulation where we know
79  * the prev/next entries already!
80  */
81 static inline void __list_add(struct list_head *_new,
82 			      struct list_head *prev,
83 			      struct list_head *next)
84 {
85 	next->prev = _new;
86 	_new->next = next;
87 	_new->prev = prev;
88 	prev->next = _new;
89 }
90 
91 /**
92  * list_add_tail - add a new entry
93  * @new: new entry to be added
94  * @head: list head to add it before
95  *
96  * Insert a new entry before the specified head.
97  * This is useful for implementing queues.
98  */
99 static inline void list_add_tail(struct list_head *_new, struct list_head *head)
100 {
101 	__list_add(_new, head->prev, head);
102 }
103 
104 /*
105  * Delete a list entry by making the prev/next entries
106  * point to each other.
107  *
108  * This is only for internal list manipulation where we know
109  * the prev/next entries already!
110  */
111 static inline void __list_del(struct list_head *prev, struct list_head *next)
112 {
113 	next->prev = prev;
114 	prev->next = next;
115 }
116 
117 #define LIST_POISON1  ((void *) 0x00100100)
118 #define LIST_POISON2  ((void *) 0x00200200)
119 /**
120  * list_del - deletes entry from list.
121  * @entry: the element to delete from the list.
122  * Note: list_empty() on entry does not return true after this, the entry is
123  * in an undefined state.
124  */
125 static inline void list_del(struct list_head *entry)
126 {
127 	__list_del(entry->prev, entry->next);
128 	entry->next = (struct list_head*)LIST_POISON1;
129 	entry->prev = (struct list_head*)LIST_POISON2;
130 }
131 #endif
132