david/ipxe
david/ipxe
Archived
1
0
Fork 0
Code

[list] Extend list-manipulation assertions to all list-handling functions

Browse Source 
Signed-off-by: Michael Brown <mcb30@ipxe.org>
This commit is contained in:
Michael Brown 2010-11-05 23:49:12 +00:00
parent de1381578b
commit 295ba15bd6
1 changed files with 95 additions and 85 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

180
src/include/ipxe/list.h
View File

@ -14,35 +14,58 @@ FILE_LICENCE ( GPL2_ONLY );
#include <stddef.h> #include <stddef.h>
#include <assert.h> #include <assert.h>
/* /** A doubly-linked list entry (or list head) */
* 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.
*/
struct list_head { struct list_head {
/** Next list entry */
struct list_head *next; struct list_head *next;
/** Previous list entry */
struct list_head *prev; struct list_head *prev;
}; };
#define LIST_HEAD_INIT( name ) { &(name), &(name) } /**
* Initialise a static list head
#define LIST_HEAD( name ) \
struct list_head name = LIST_HEAD_INIT ( name )
#define INIT_LIST_HEAD( ptr ) do { \
(ptr)->next = (ptr); (ptr)->prev = (ptr); \
} while ( 0 )
/*
* Insert a new entry between two known consecutive entries.
* *
* This is only for internal list manipulation where we know * @v list List head
* the prev/next entries already! */
#define LIST_HEAD_INIT( list ) { &(list), &(list) }
/**
* Declare a static list head
*
* @v list List head
*/
#define LIST_HEAD( list ) \
struct list_head list = LIST_HEAD_INIT ( list )
/**
* Initialise a list head
*
* @v list List head
*/
#define INIT_LIST_HEAD( list ) do { \
(list)->next = (list); \
(list)->prev = (list); \
} while ( 0 )
/**
* Check a list entry or list head is valid
*
* @v list List entry or head
*/
#define list_check( list ) ( { \
assert ( (list) != NULL ); \
assert ( (list)->prev != NULL ); \
assert ( (list)->next != NULL ); \
assert ( (list)->next->prev == (list) ); \
assert ( (list)->prev->next == (list) ); \
} )
/**
* Insert a list entry between two known consecutive entries
*
* @v new New list entry
* @v prev Previous list entry
* @v next Next list entry
*/ */
static inline void __list_add ( struct list_head *new, static inline void __list_add ( struct list_head *new,
struct list_head *prev, struct list_head *prev,
@ -56,49 +79,40 @@ static inline void __list_add ( struct list_head *new,
/** /**
* Add a new entry to the head of a list * Add a new entry to the head of a list
* *
* @v new New entry to be added * @v new New entry to be added
* @v head List head to add it after * @v head List head, or entry after which to add the new entry
*
* 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 ) { static inline void list_add ( struct list_head *new, struct list_head *head ) {
__list_add ( new, head, head->next ); __list_add ( new, head, head->next );
} }
#define list_add( new, head ) do { \ #define list_add( new, head ) do { \
assert ( (head)->next->prev == (head) ); \ list_check ( (head) ); \
assert ( (head)->prev->next == (head) ); \
list_add ( (new), (head) ); \ list_add ( (new), (head) ); \
} while ( 0 ) } while ( 0 )
/** /**
* Add a new entry to the tail of a list * Add a new entry to the tail of a list
* *
* @v new New entry to be added * @v new New entry to be added
* @v head List head to add it before * @v head List head, or entry before which to add the new entry
*
* Insert a new entry before the specified head. This is useful for
* implementing queues.
*/ */
static inline void list_add_tail ( struct list_head *new, static inline void list_add_tail ( struct list_head *new,
struct list_head *head ) { struct list_head *head ) {
__list_add ( new, head->prev, head ); __list_add ( new, head->prev, head );
} }
#define list_add_tail( new, head ) do { \ #define list_add_tail( new, head ) do { \
assert ( (head)->next->prev == (head) ); \ list_check ( (head) ); \
assert ( (head)->prev->next == (head) ); \
list_add_tail ( (new), (head) ); \ list_add_tail ( (new), (head) ); \
} while ( 0 ) } while ( 0 )
/* /**
* Delete a list entry by making the prev/next entries * Delete a list entry between two known consecutive entries
* point to each other.
* *
* This is only for internal list manipulation where we know * @v prev Previous list entry
* the prev/next entries already! * @v next Next list entry
*/ */
static inline void __list_del ( struct list_head * prev, static inline void __list_del ( struct list_head *prev,
struct list_head * next ) { struct list_head *next ) {
next->prev = prev; next->prev = prev;
prev->next = next; prev->next = next;
} }
@ -106,84 +120,80 @@ static inline void __list_del ( struct list_head * prev,
/** /**
* Delete an entry from a list * Delete an entry from a list
* *
* @v entry Element to delete from the list * @v list List entry
* *
* Note that list_empty() on entry does not return true after this; * Note that list_empty() on entry does not return true after this;
* the entry is in an undefined state. * the entry is in an undefined state.
*/ */
static inline void list_del ( struct list_head *entry ) { static inline void list_del ( struct list_head *list ) {
__list_del ( entry->prev, entry->next ); __list_del ( list->prev, list->next );
} }
#define list_del( entry ) do { \ #define list_del( list ) do { \
assert ( (entry)->prev != NULL ); \ list_check ( (list) ); \
assert ( (entry)->next != NULL ); \ list_del ( (list) ); \
assert ( (entry)->next->prev == (entry) ); \
assert ( (entry)->prev->next == (entry) ); \
list_del ( (entry) ); \
} while ( 0 ) } while ( 0 )
/** /**
* Test whether a list is empty * Test whether a list is empty
* *
* @v head List to test. * @v list List head
*/ */
static inline int list_empty ( const struct list_head *head ) { static inline int list_empty ( const struct list_head *list ) {
return head->next == head; return ( list->next == list );
} }
#define list_empty( list ) ( { \
list_check ( (list) ); \
list_empty ( (list) ); } )
/** /**
* Get the containing struct for this entry * Get the container of a list entry
* *
* @v ptr The struct list_head pointer * @v list List entry
* @v type The type of the struct this is embedded in * @v type Containing type
* @v member The name of the list_struct within the struct * @v member Name of list field within containing type
* @ret container Containing object
*/ */
#define list_entry( ptr, type, member ) \ #define list_entry( list, type, member ) ( { \
container_of ( ptr, type, member ) list_check ( (list) ); \
container_of ( list, type, member ); } )
/**
* Iterate over a list
*
* @v pos The &struct list_head to use as a loop counter
* @v head The head for your list
*/
#define list_for_each( pos, head ) \
for ( pos = (head)->next; pos != (head); pos = pos->next )
/** /**
* Iterate over entries in a list * Iterate over entries in a list
* *
* @v pos The type * to use as a loop counter * @v pos Iterator
* @v head The head for your list * @v head List head
* @v member The name of the list_struct within the struct * @v member Name of list field within iterator's type
*/ */
#define list_for_each_entry( pos, head, member ) \ #define list_for_each_entry( pos, head, member ) \
for ( pos = list_entry ( (head)->next, typeof ( *pos ), member ); \ for ( list_check ( (head) ), \
pos = list_entry ( (head)->next, typeof ( *pos ), member ); \
&pos->member != (head); \ &pos->member != (head); \
pos = list_entry ( pos->member.next, typeof ( *pos ), member ) ) pos = list_entry ( pos->member.next, typeof ( *pos ), member ) )
/** /**
* Iterate over entries in a list in reverse order * Iterate over entries in a list in reverse order
* *
* @v pos The type * to use as a loop counter * @v pos Iterator
* @v head The head for your list * @v head List head
* @v member The name of the list_struct within the struct * @v member Name of list field within iterator's type
*/ */
#define list_for_each_entry_reverse( pos, head, member ) \ #define list_for_each_entry_reverse( pos, head, member ) \
for ( pos = list_entry ( (head)->prev, typeof ( *pos ), member ); \ for ( list_check ( (head) ), \
pos = list_entry ( (head)->prev, typeof ( *pos ), member ); \
&pos->member != (head); \ &pos->member != (head); \
pos = list_entry ( pos->member.prev, typeof ( *pos ), member ) ) pos = list_entry ( pos->member.prev, typeof ( *pos ), member ) )
/** /**
* Iterate over entries in a list, safe against deletion of entries * Iterate over entries in a list, safe against deletion of the current entry
* *
* @v pos The type * to use as a loop counter * @v pos Iterator
* @v tmp Another type * to use for temporary storage * @v tmp Temporary value (of same type as iterator)
* @v head The head for your list * @v head List head
* @v member The name of the list_struct within the struct * @v member Name of list field within iterator's type
*/ */
#define list_for_each_entry_safe( pos, tmp, head, member ) \ #define list_for_each_entry_safe( pos, tmp, head, member ) \
for ( pos = list_entry ( (head)->next, typeof ( *pos ), member ), \ for ( list_check ( (head) ), \
pos = list_entry ( (head)->next, typeof ( *pos ), member ), \
tmp = list_entry ( pos->member.next, typeof ( *tmp ), member ); \ tmp = list_entry ( pos->member.next, typeof ( *tmp ), member ); \
&pos->member != (head); \ &pos->member != (head); \
pos = tmp, \ pos = tmp, \