[linux-2.6-block.git] / io_uring / slist.h

#ifndef INTERNAL_IO_SLIST_H
#define INTERNAL_IO_SLIST_H

#include <linux/io_uring_types.h>

#define wq_list_for_each(pos, prv, head)			\
	for (pos = (head)->first, prv = NULL; pos; prv = pos, pos = (pos)->next)

#define wq_list_for_each_resume(pos, prv)			\
	for (; pos; prv = pos, pos = (pos)->next)

#define wq_list_empty(list)	(READ_ONCE((list)->first) == NULL)

#define INIT_WQ_LIST(list)	do {				\
	(list)->first = NULL;					\
} while (0)

static inline void wq_list_add_after(struct io_wq_work_node *node,
				     struct io_wq_work_node *pos,
				     struct io_wq_work_list *list)
{
	struct io_wq_work_node *next = pos->next;

	pos->next = node;
	node->next = next;
	if (!next)
		list->last = node;
}

/**
 * wq_list_merge - merge the second list to the first one.
 * @list0: the first list
 * @list1: the second list
 * Return the first node after mergence.
 */
static inline struct io_wq_work_node *wq_list_merge(struct io_wq_work_list *list0,
						    struct io_wq_work_list *list1)
{
	struct io_wq_work_node *ret;

	if (!list0->first) {
		ret = list1->first;
	} else {
		ret = list0->first;
		list0->last->next = list1->first;
	}
	INIT_WQ_LIST(list0);
	INIT_WQ_LIST(list1);
	return ret;
}

static inline void wq_list_add_tail(struct io_wq_work_node *node,
				    struct io_wq_work_list *list)
{
	node->next = NULL;
	if (!list->first) {
		list->last = node;
		WRITE_ONCE(list->first, node);
	} else {
		list->last->next = node;
		list->last = node;
	}
}

static inline void wq_list_add_head(struct io_wq_work_node *node,
				    struct io_wq_work_list *list)
{
	node->next = list->first;
	if (!node->next)
		list->last = node;
	WRITE_ONCE(list->first, node);
}

static inline void wq_list_cut(struct io_wq_work_list *list,
			       struct io_wq_work_node *last,
			       struct io_wq_work_node *prev)
{
	/* first in the list, if prev==NULL */
	if (!prev)
		WRITE_ONCE(list->first, last->next);
	else
		prev->next = last->next;

	if (last == list->last)
		list->last = prev;
	last->next = NULL;
}

static inline void __wq_list_splice(struct io_wq_work_list *list,
				    struct io_wq_work_node *to)
{
	list->last->next = to->next;
	to->next = list->first;
	INIT_WQ_LIST(list);
}

static inline bool wq_list_splice(struct io_wq_work_list *list,
				  struct io_wq_work_node *to)
{
	if (!wq_list_empty(list)) {
		__wq_list_splice(list, to);
		return true;
	}
	return false;
}

static inline void wq_stack_add_head(struct io_wq_work_node *node,
				     struct io_wq_work_node *stack)
{
	node->next = stack->next;
	stack->next = node;
}

static inline void wq_list_del(struct io_wq_work_list *list,
			       struct io_wq_work_node *node,
			       struct io_wq_work_node *prev)
{
	wq_list_cut(list, node, prev);
}

static inline
struct io_wq_work_node *wq_stack_extract(struct io_wq_work_node *stack)
{
	struct io_wq_work_node *node = stack->next;

	stack->next = node->next;
	return node;
}

static inline struct io_wq_work *wq_next_work(struct io_wq_work *work)
{
	if (!work->list.next)
		return NULL;

	return container_of(work->list.next, struct io_wq_work, list);
}

#endif // INTERNAL_IO_SLIST_H
Commit	Line	Data
a6b21fbb PB	1	#ifndef INTERNAL_IO_SLIST_H
	2	#define INTERNAL_IO_SLIST_H
	3
	4	#include <linux/io_uring_types.h>
	5
	6	#define wq_list_for_each(pos, prv, head) \
	7	for (pos = (head)->first, prv = NULL; pos; prv = pos, pos = (pos)->next)
	8
	9	#define wq_list_for_each_resume(pos, prv) \
	10	for (; pos; prv = pos, pos = (pos)->next)
	11
	12	#define wq_list_empty(list) (READ_ONCE((list)->first) == NULL)
	13
	14	#define INIT_WQ_LIST(list) do { \
	15	(list)->first = NULL; \
	16	} while (0)
	17
	18	static inline void wq_list_add_after(struct io_wq_work_node *node,
	19	struct io_wq_work_node *pos,
	20	struct io_wq_work_list *list)
	21	{
	22	struct io_wq_work_node *next = pos->next;
	23
	24	pos->next = node;
	25	node->next = next;
	26	if (!next)
	27	list->last = node;
	28	}
	29
	30	/**
	31	* wq_list_merge - merge the second list to the first one.
	32	* @list0: the first list
	33	* @list1: the second list
	34	* Return the first node after mergence.
	35	*/
	36	static inline struct io_wq_work_node wq_list_merge(struct io_wq_work_list list0,
	37	struct io_wq_work_list *list1)
	38	{
	39	struct io_wq_work_node *ret;
	40
	41	if (!list0->first) {
	42	ret = list1->first;
	43	} else {
	44	ret = list0->first;
	45	list0->last->next = list1->first;
	46	}
	47	INIT_WQ_LIST(list0);
	48	INIT_WQ_LIST(list1);
	49	return ret;
	50	}
	51
	52	static inline void wq_list_add_tail(struct io_wq_work_node *node,
	53	struct io_wq_work_list *list)
	54	{
	55	node->next = NULL;
	56	if (!list->first) {
	57	list->last = node;
	58	WRITE_ONCE(list->first, node);
	59	} else {
	60	list->last->next = node;
	61	list->last = node;
	62	}
	63	}
	64
65	static inline void wq_list_add_head(struct io_wq_work_node *node,
66	struct io_wq_work_list *list)
67	{
68	node->next = list->first;
69	if (!node->next)
70	list->last = node;
71	WRITE_ONCE(list->first, node);
72	}
73
74	static inline void wq_list_cut(struct io_wq_work_list *list,
75	struct io_wq_work_node *last,
76	struct io_wq_work_node *prev)
77	{
78	/* first in the list, if prev==NULL */
79	if (!prev)
80	WRITE_ONCE(list->first, last->next);
81	else
82	prev->next = last->next;
83
84	if (last == list->last)
85	list->last = prev;
86	last->next = NULL;
87	}
88
89	static inline void __wq_list_splice(struct io_wq_work_list *list,
90	struct io_wq_work_node *to)
91	{
92	list->last->next = to->next;
93	to->next = list->first;
94	INIT_WQ_LIST(list);
95	}
96
97	static inline bool wq_list_splice(struct io_wq_work_list *list,
98	struct io_wq_work_node *to)
99	{
100	if (!wq_list_empty(list)) {
101	__wq_list_splice(list, to);
102	return true;
103	}
104	return false;
105	}
106
107	static inline void wq_stack_add_head(struct io_wq_work_node *node,
108	struct io_wq_work_node *stack)
109	{
110	node->next = stack->next;
111	stack->next = node;
112	}
113
114	static inline void wq_list_del(struct io_wq_work_list *list,
115	struct io_wq_work_node *node,
116	struct io_wq_work_node *prev)
117	{
118	wq_list_cut(list, node, prev);
119	}
120
121	static inline
122	struct io_wq_work_node wq_stack_extract(struct io_wq_work_node stack)
123	{
124	struct io_wq_work_node *node = stack->next;
125
126	stack->next = node->next;
127	return node;
128	}
129
130	static inline struct io_wq_work wq_next_work(struct io_wq_work work)
131	{
132	if (!work->list.next)
133	return NULL;
134
135	return container_of(work->list.next, struct io_wq_work, list);
136	}
137
138	#endif // INTERNAL_IO_SLIST_H