diff options
author | H. Peter Anvin <hpa@zytor.com> | 2008-03-26 16:25:35 -0700 |
---|---|---|
committer | H. Peter Anvin <hpa@zytor.com> | 2008-03-26 16:25:35 -0700 |
commit | 9eddd22a7b53b1d02fbae0d987df8af122924248 (patch) | |
tree | 882f5152880b0b1aa2d7a0619d30065acc69fb16 /gpxe/src/include/gpxe/list.h | |
parent | bbb8f15936b851e6a0ef6f7bb2c95197bff35994 (diff) | |
download | syslinux-9eddd22a7b53b1d02fbae0d987df8af122924248.tar.gz |
Add gPXE into the source tree; build unified imagesyslinux-3.70-pre7
Diffstat (limited to 'gpxe/src/include/gpxe/list.h')
-rw-r--r-- | gpxe/src/include/gpxe/list.h | 178 |
1 files changed, 178 insertions, 0 deletions
diff --git a/gpxe/src/include/gpxe/list.h b/gpxe/src/include/gpxe/list.h new file mode 100644 index 00000000..602382be --- /dev/null +++ b/gpxe/src/include/gpxe/list.h @@ -0,0 +1,178 @@ +#ifndef _GPXE_LIST_H +#define _GPXE_LIST_H + +/** @file + * + * Linked lists + * + * This linked list handling code is based on the Linux kernel's + * list.h. + */ + +#include <stddef.h> +#include <assert.h> + +/* + * 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; + struct list_head *prev; +}; + +#define LIST_HEAD_INIT( name ) { &(name), &(name) } + +#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 + * the prev/next entries already! + */ +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; +} + +/** + * Add a new entry to the head of a list + * + * @v new New entry to be added + * @v 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 ); +} +#define list_add( new, head ) do { \ + assert ( (head)->next->prev == (head) ); \ + assert ( (head)->prev->next == (head) ); \ + list_add ( (new), (head) ); \ + } while ( 0 ) + +/** + * Add a new entry to the tail of a list + * + * @v new New entry to be added + * @v 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 ); +} +#define list_add_tail( new, head ) do { \ + assert ( (head)->next->prev == (head) ); \ + assert ( (head)->prev->next == (head) ); \ + list_add_tail ( (new), (head) ); \ + } while ( 0 ) + +/* + * 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; +} + +/** + * Delete an entry from a list + * + * @v entry Element to delete from the list + * + * Note that list_empty() on entry does not return true after this; + * the entry is in an undefined state. + */ +static inline void list_del ( struct list_head *entry ) { + __list_del ( entry->prev, entry->next ); +} +#define list_del( entry ) do { \ + assert ( (entry)->prev != NULL ); \ + assert ( (entry)->next != NULL ); \ + assert ( (entry)->next->prev == (entry) ); \ + assert ( (entry)->prev->next == (entry) ); \ + list_del ( (entry) ); \ + } while ( 0 ) + +/** + * Test whether a list is empty + * + * @v head List to test. + */ +static inline int list_empty ( const struct list_head *head ) { + return head->next == head; +} + +/** + * Get the containing struct for this entry + * + * @v ptr The struct list_head pointer + * @v type The type of the struct this is embedded in + * @v member The name of the list_struct within the struct + */ +#define list_entry( ptr, type, member ) \ + container_of ( ptr, 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 + * + * @v pos The type * to use as a loop counter + * @v head The head for your list + * @v 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 ); \ + &pos->member != (head); \ + pos = list_entry ( pos->member.next, typeof ( *pos ), member ) ) + +/** + * Iterate over entries in a list, safe against deletion of entries + * + * @v pos The type * to use as a loop counter + * @v tmp Another type * to use for temporary storage + * @v head The head for your list + * @v member The name of the list_struct within the struct + */ +#define list_for_each_entry_safe( pos, tmp, head, member ) \ + for ( pos = list_entry ( (head)->next, typeof ( *pos ), member ), \ + tmp = list_entry ( pos->member.next, typeof ( *tmp ), member ); \ + &pos->member != (head); \ + pos = tmp, \ + tmp = list_entry ( tmp->member.next, typeof ( *tmp ), member ) ) + +#endif /* _GPXE_LIST_H */ |