2001-10-31 15:47:01 +03:00
/*
2004-03-30 23:35:44 +04:00
* Copyright ( C ) 2001 - 2004 Sistina Software , Inc . All rights reserved .
* Copyright ( C ) 2004 Red Hat , Inc . All rights reserved .
2001-10-31 15:47:01 +03:00
*
2004-03-30 23:35:44 +04:00
* This file is part of LVM2 .
*
* This copyrighted material is made available to anyone wishing to use ,
* modify , copy , or redistribute it subject to the terms and conditions
* of the GNU General Public License v .2 .
*
* You should have received a copy of the GNU General Public License
* along with this program ; if not , write to the Free Software Foundation ,
* Inc . , 59 Temple Place , Suite 330 , Boston , MA 02111 - 1307 USA
2001-10-31 15:47:01 +03:00
*/
2001-09-28 17:19:17 +04:00
2001-10-01 19:14:39 +04:00
# ifndef _LVM_LIST_H
# define _LVM_LIST_H
2001-09-28 17:19:17 +04:00
2003-03-24 21:08:53 +03:00
# include <assert.h>
2005-04-06 18:50:37 +04:00
/*
* A list consists of a list head plus elements .
* Each element has ' next ' and ' previous ' pointers .
* The list head ' s pointers point to the first and the last element .
*/
2001-10-31 15:47:01 +03:00
struct list {
struct list * n , * p ;
2001-09-28 17:19:17 +04:00
} ;
2005-04-06 18:50:37 +04:00
/*
* Initialise a list before use .
* The list head ' s next and previous pointers point back to itself .
*/
2003-07-05 02:34:56 +04:00
# define LIST_INIT(name) struct list name = { &(name), &(name) }
2002-12-12 23:55:49 +03:00
static inline void list_init ( struct list * head )
{
2001-10-31 15:47:01 +03:00
head - > n = head - > p = head ;
}
2001-09-28 17:19:17 +04:00
2005-04-06 18:50:37 +04:00
/*
* Insert an element before ' head ' .
* If ' head ' is the list head , this adds an element to the end of the list .
*/
2002-12-12 23:55:49 +03:00
static inline void list_add ( struct list * head , struct list * elem )
{
2001-10-31 15:47:01 +03:00
assert ( head - > n ) ;
2001-09-28 17:19:17 +04:00
2001-10-31 15:47:01 +03:00
elem - > n = head ;
elem - > p = head - > p ;
2001-09-28 17:19:17 +04:00
2001-10-31 15:47:01 +03:00
head - > p - > n = elem ;
head - > p = elem ;
2001-09-28 17:19:17 +04:00
}
2005-04-06 18:50:37 +04:00
/*
* Insert an element after ' head ' .
* If ' head ' is the list head , this adds an element to the front of the list .
*/
2002-12-12 23:55:49 +03:00
static inline void list_add_h ( struct list * head , struct list * elem )
{
2001-10-31 15:47:01 +03:00
assert ( head - > n ) ;
2001-09-28 17:19:17 +04:00
2001-10-31 15:47:01 +03:00
elem - > n = head - > n ;
elem - > p = head ;
2001-09-28 17:19:17 +04:00
2001-10-31 15:47:01 +03:00
head - > n - > p = elem ;
head - > n = elem ;
2001-09-28 17:19:17 +04:00
}
2005-04-06 18:50:37 +04:00
/*
* Delete an element from its list .
* Note that this doesn ' t change the element itself - it may still be safe
* to follow its pointers .
*/
2002-12-12 23:55:49 +03:00
static inline void list_del ( struct list * elem )
{
2001-10-31 15:47:01 +03:00
elem - > n - > p = elem - > p ;
elem - > p - > n = elem - > n ;
2001-09-28 17:19:17 +04:00
}
2005-04-06 18:50:37 +04:00
/*
* Is the list empty ?
*/
2002-12-12 23:55:49 +03:00
static inline int list_empty ( struct list * head )
{
2001-10-31 15:47:01 +03:00
return head - > n = = head ;
2001-09-28 17:19:17 +04:00
}
2005-04-06 18:50:37 +04:00
/*
* Is this the first element of the list ?
*/
static inline int list_start ( struct list * head , struct list * elem )
{
return elem - > p = = head ;
}
/*
* Is this the last element of the list ?
*/
2002-12-12 23:55:49 +03:00
static inline int list_end ( struct list * head , struct list * elem )
{
return elem - > n = = head ;
}
2005-04-06 18:50:37 +04:00
/*
* Return the previous element of the list , or NULL if we ' ve reached the start .
*/
static inline struct list * list_prev ( struct list * head , struct list * elem )
{
return ( list_start ( head , elem ) ? NULL : elem - > p ) ;
}
/*
* Return the next element of the list , or NULL if we ' ve reached the end .
*/
2003-05-06 16:01:13 +04:00
static inline struct list * list_next ( struct list * head , struct list * elem )
{
return ( list_end ( head , elem ) ? NULL : elem - > n ) ;
}
2005-04-06 18:50:37 +04:00
/*
* Given the address v of an instance of ' struct list h ' contained in
* a structure of type t , return the containing structure .
*/
2003-09-15 22:22:50 +04:00
# define list_struct_base(v, t, h) \
( ( t * ) ( ( uintptr_t ) ( v ) - ( uintptr_t ) & ( ( t * ) 0 ) - > h ) )
2005-04-06 18:50:37 +04:00
/*
* Given the address v of an instance of ' struct list list ' contained in
* a structure of type t , return the containing structure .
*/
# define list_item(v, t) list_struct_base((v), t, list)
/*
* Given the address v of one known element e in a known structure of type t ,
* return another element f .
*/
2003-09-15 22:22:50 +04:00
# define struct_field(v, t, e, f) \
( ( ( t * ) ( ( uintptr_t ) ( v ) - ( uintptr_t ) & ( ( t * ) 0 ) - > e ) ) - > f )
2005-04-06 18:50:37 +04:00
/*
* Given the address v of a known element e in a known structure of type t ,
* return the list head ' list '
*/
2003-09-15 22:22:50 +04:00
# define list_head(v, t, e) struct_field(v, t, e, list)
2005-04-06 18:50:37 +04:00
/*
* Set v to each element of a list in turn .
*/
2001-10-31 15:47:01 +03:00
# define list_iterate(v, head) \
2002-01-29 19:28:52 +03:00
for ( v = ( head ) - > n ; v ! = head ; v = v - > n )
2005-04-06 18:50:37 +04:00
/*
* Set v to each element in a list in turn , starting from the element
* in front of ' start ' .
* You can use this to ' unwind ' a list_iterate and back out actions on
* already - processed elements .
* If ' start ' is ' head ' it walks the list backwards .
*/
2003-07-05 02:34:56 +04:00
# define list_uniterate(v, head, start) \
for ( v = ( start ) - > p ; v ! = head ; v = v - > p )
2005-04-06 18:50:37 +04:00
/*
* A safe way to walk a list and delete and free some elements along
* the way .
* t must be defined as a temporary variable of the same type as v .
*/
2002-01-29 19:28:52 +03:00
# define list_iterate_safe(v, t, head) \
for ( v = ( head ) - > n , t = v - > n ; v ! = head ; v = t , t = v - > n )
2001-09-28 17:19:17 +04:00
2005-04-06 18:50:37 +04:00
/*
* Walk a list , setting ' v ' in turn to the containing structure of each item .
* The containing structure should be the same type as ' v ' .
* The ' struct list ' variable within the containing structure is ' l ' .
*/
# define list_iterate_items_head(v, head, l) \
for ( v = list_struct_base ( ( head ) - > n , typeof ( * v ) , l ) ; & v - > l ! = ( head ) ; \
v = list_struct_base ( v - > l . n , typeof ( * v ) , l ) )
/*
* Walk a list , setting ' v ' in turn to the containing structure of each item .
* The containing structure should be the same type as ' v ' .
* The list should be ' struct list list ' within the containing structure .
*/
# define list_iterate_items(v, head) list_iterate_items_head(v, (head), list)
2003-09-15 22:22:50 +04:00
2005-04-06 18:50:37 +04:00
/*
* Return the number of elements in a list by walking it .
*/
2002-12-20 02:25:55 +03:00
static inline unsigned int list_size ( const struct list * head )
2002-12-12 23:55:49 +03:00
{
2002-12-20 02:25:55 +03:00
unsigned int s = 0 ;
const struct list * v ;
2001-11-28 16:45:50 +03:00
list_iterate ( v , head )
2002-12-12 23:55:49 +03:00
s + + ;
2001-11-28 16:45:50 +03:00
return s ;
}
2001-09-28 17:19:17 +04:00
# endif