TBOX_LIST

T-Box 链表工具 More...

Data Structures
struct	list_node
	双向循环链表节点。 More...
struct	hlist_head
	hlist 链表头。 More...
struct	hlist_node
	hlist 节点。 More...

Macros
#define	LIST_POISON1   ((void*)0x00100100)
	链表删除后的 next poison 值。
#define	LIST_POISON2   ((void*)0x00200200)
	链表删除后的 prev/pprev poison 值。
#define	DLIST_HEAD_IN_STRUCT_INIT(field)
	初始化结构体字段形式的链表头。
#define	DLIST_HEAD_INIT(name)
	静态初始化独立链表头。
#define	DLIST_HEAD(name)
	定义并初始化一个独立链表头变量。
#define	container_of(ptr, type, member)
	根据成员指针取得宿主结构体指针。
#define	list_entry(ptr, type, member)
	根据 list_node 成员指针取得宿主结构体指针。
#define	list_for_each(pos, head)
	遍历双向循环链表节点。
#define	list_for_each_entry(pos, head, member)
	按宿主结构体类型遍历双向循环链表。
#define	list_for_each_entry_safe(pos, n, head, member)
	按宿主结构体类型安全遍历双向循环链表。
#define	HLIST_HEAD_INIT   {.first = NULL}
	静态初始化 hlist 链表头。
#define	HLIST_HEAD(name)
	定义并初始化一个独立 hlist 链表头变量。
#define	INIT_HLIST_HEAD(ptr)
	初始化 hlist 链表头为空。
#define	INIT_HLIST_NODE(ptr)
	初始化 hlist 节点为未挂链状态。
#define	hlist_entry(ptr, type, member)
	根据 hlist_node 成员指针取得宿主结构体指针。
#define	hlist_for_each(pos, head)
	遍历 hlist 节点。
#define	hlist_for_each_safe(pos, n, head)
	安全遍历 hlist 节点。
#define	hlist_for_each_entry(tpos, pos, head, member)
	按宿主结构体类型遍历 hlist。
#define	hlist_for_each_entry_continue(tpos, pos, member)
	从当前 hlist 节点之后继续按宿主结构体类型遍历。
#define	hlist_for_each_entry_from(tpos, pos, member)
	从当前 hlist 节点开始按宿主结构体类型遍历。
#define	hlist_for_each_entry_safe(tpos, pos, n, head, member)
	按宿主结构体类型安全遍历 hlist。

Typedefs
typedef struct list_node	list_node_t
	双向循环链表节点。

Detailed Description

T-Box 链表工具

Macro Definition Documentation

container_of

#define container_of	(		ptr,
			type,
			member )

Value:

    ({                                                                                                                 \
        const tbox_typeof(((type*)0)->member)* __mptr = (ptr);                                                         \
        (type*)((char*)__mptr - offsetof(type, member));                                                               \
    })

根据成员指针取得宿主结构体指针。

Parameters

ptr	成员地址。
type	宿主结构体类型。
member	成员名。

DLIST_HEAD

#define DLIST_HEAD

(

name

)

Value:

struct list_node name = DLIST_HEAD_INIT(name)

定义并初始化一个独立链表头变量。

Parameters

name

链表头变量名。

DLIST_HEAD_IN_STRUCT_INIT

#define DLIST_HEAD_IN_STRUCT_INIT

(

field

)

Value:

    do                                                                                                                 \
    {                                                                                                                  \
        (field).next = &(field);                                                                                       \
        (field).prev = &(field);                                                                                       \
    } while (0)

初始化结构体字段形式的链表头。

Parameters

field

结构体内的链表头字段。

DLIST_HEAD_INIT

#define DLIST_HEAD_INIT

(

name

)

Value:

{&(name), &(name)}

静态初始化独立链表头。

Parameters

name

链表头变量名。

hlist_entry

#define hlist_entry	(		ptr,
			type,
			member )

Value:

container_of(ptr, type, member)

根据 hlist_node 成员指针取得宿主结构体指针。

Parameters

ptr	hlist_node 成员地址。
type	宿主结构体类型。
member	hlist_node 成员名。

hlist_for_each

#define hlist_for_each	(		pos,
			head )

Value:

    for (pos = (head)->first; pos && ({                                                                                \
                                  prefetch(pos->next);                                                                 \
                                  1;                                                                                   \
                              });                                                                                      \
         pos = pos->next)

遍历 hlist 节点。

Parameters

pos	struct hlist_node* 类型游标。
head	hlist 链表头。

不允许在循环体内删除当前节点。

hlist_for_each_entry

#define hlist_for_each_entry	(		tpos,
			pos,
			head,
			member )

Value:

    for (pos = (head)->first; pos && ({                                                                                \
                                  prefetch(pos->next);                                                                 \
                                  1;                                                                                   \
                              }) &&                                                                                    \
                              ({                                                                                       \
                                  tpos = hlist_entry(pos, tbox_typeof(*tpos), member);                                 \
                                  1;                                                                                   \
                              });                                                                                      \
         pos = pos->next)

按宿主结构体类型遍历 hlist。

Parameters

tpos	宿主结构体指针游标。
pos	struct hlist_node* 类型游标。
head	hlist 链表头。
member	宿主结构体内的 hlist_node 成员名。

不允许在循环体内删除当前节点。

hlist_for_each_entry_continue

#define hlist_for_each_entry_continue	(		tpos,
			pos,
			member )

Value:

    for (pos = (pos)->next; pos && ({                                                                                  \
                                prefetch(pos->next);                                                                   \
                                1;                                                                                     \
                            }) &&                                                                                      \
                            ({                                                                                         \
                                tpos = hlist_entry(pos, tbox_typeof(*tpos), member);                                   \
                                1;                                                                                     \
                            });                                                                                        \
         pos = pos->next)

从当前 hlist 节点之后继续按宿主结构体类型遍历。

Parameters

tpos	宿主结构体指针游标。
pos	struct hlist_node* 类型游标。
member	宿主结构体内的 hlist_node 成员名。

hlist_for_each_entry_from

#define hlist_for_each_entry_from	(		tpos,
			pos,
			member )

Value:

    for (; pos && ({                                                                                                   \
               prefetch(pos->next);                                                                                    \
               1;                                                                                                      \
           }) &&                                                                                                       \
           ({                                                                                                          \
               tpos = hlist_entry(pos, tbox_typeof(*tpos), member);                                                    \
               1;                                                                                                      \
           });                                                                                                         \
         pos = pos->next)

从当前 hlist 节点开始按宿主结构体类型遍历。

Parameters

tpos	宿主结构体指针游标。
pos	struct hlist_node* 类型游标。
member	宿主结构体内的 hlist_node 成员名。

hlist_for_each_entry_safe

#define hlist_for_each_entry_safe	(		tpos,
			pos,
			n,
			head,
			member )

Value:

    for (pos = (head)->first; pos && ({                                                                                \
                                  n = pos->next;                                                                       \
                                  1;                                                                                   \
                              }) &&                                                                                    \
                              ({                                                                                       \
                                  tpos = hlist_entry(pos, tbox_typeof(*tpos), member);                                 \
                                  1;                                                                                   \
                              });                                                                                      \
         pos = n)

按宿主结构体类型安全遍历 hlist。

Parameters

tpos	宿主结构体指针游标。
pos	struct hlist_node* 类型游标。
n	struct hlist_node* 类型临时变量。
head	hlist 链表头。
member	宿主结构体内的 hlist_node 成员名。

允许在循环体内删除当前节点。

hlist_for_each_safe

#define hlist_for_each_safe	(		pos,
			n,
			head )

Value:

    for (pos = (head)->first; pos && ({                                                                                \
                                  n = pos->next;                                                                       \
                                  1;                                                                                   \
                              });                                                                                      \
         pos = n)

安全遍历 hlist 节点。

Parameters

pos	struct hlist_node* 类型游标。
n	struct hlist_node* 类型临时变量。
head	hlist 链表头。

允许在循环体内删除当前节点。

HLIST_HEAD

#define HLIST_HEAD

(

name

)

Value:

struct hlist_head name = {.first = NULL}

定义并初始化一个独立 hlist 链表头变量。

Parameters

name	hlist 链表头变量名。

INIT_HLIST_HEAD

#define INIT_HLIST_HEAD

(

ptr

)

Value:

((ptr)->first = NULL)

初始化 hlist 链表头为空。

Parameters

ptr	hlist 链表头指针，不能为 NULL。

INIT_HLIST_NODE

#define INIT_HLIST_NODE

(

ptr

)

Value:

    do                                                                                                                 \
    {                                                                                                                  \
        (ptr)->next  = NULL;                                                                                           \
        (ptr)->pprev = NULL;                                                                                           \
    } while (0)

初始化 hlist 节点为未挂链状态。

Parameters

ptr	hlist 节点指针，不能为 NULL。

list_entry

#define list_entry	(		ptr,
			type,
			member )

Value:

container_of(ptr, type, member)

根据 list_node 成员指针取得宿主结构体指针。

Parameters

ptr	list_node 成员地址。
type	宿主结构体类型。
member	list_node 成员名。

list_for_each

#define list_for_each	(		pos,
			head )

Value:

for (pos = (head)->next; prefetch(pos->next), pos != (head); pos = pos->next)

遍历双向循环链表节点。

Parameters

pos	struct list_node* 类型游标。
head	已初始化链表头。

不允许在循环体内删除当前节点。

list_for_each_entry

#define list_for_each_entry	(		pos,
			head,
			member )

Value:

    for (pos = list_entry((head)->next, tbox_typeof(*pos), member); &pos->member != (head);                            \
         pos = list_entry(pos->member.next, tbox_typeof(*pos), member))

按宿主结构体类型遍历双向循环链表。

Parameters

pos	宿主结构体指针游标。
head	已初始化链表头。
member	宿主结构体内的 list_node 成员名。

不允许在循环体内删除当前节点。

list_for_each_entry_safe

#define list_for_each_entry_safe	(		pos,
			n,
			head,
			member )

Value:

    for (pos                         = list_entry((head)->next, tbox_typeof(*pos), member),                            \
        n                            = list_entry(pos->member.next, tbox_typeof(*pos), member);                        \
         &pos->member != (head); pos = n, n = list_entry(n->member.next, tbox_typeof(*n), member))

按宿主结构体类型安全遍历双向循环链表。

Parameters

pos	宿主结构体指针游标。
n	宿主结构体指针临时变量。
head	已初始化链表头。
member	宿主结构体内的 list_node 成员名。

允许在循环体内删除当前节点。

Typedef Documentation

list_node_t

typedef struct list_node list_node_t

双向循环链表节点。

同一个节点同一时间只能挂入一个链表。插入前由调用方确保节点未挂链，或者已从旧链表摘除。