list: Replace uses of list.h with qblist.h

Signed-off-by: Michael Jones <jonesmz@jonesmz.com>
Reviewed-by: Jan Friesse <jfriesse@redhat.com>

cts/agents/cpg_test_agent.c

@@ -47,7 +47,7 @@
 #include <unistd.h>
 #include <fcntl.h>
 
-#include <corosync/list.h>
+#include <qb/qblist.h>
 #include <qb/qbdefs.h>
 #include <qb/qbutil.h>
 #include <qb/qbloop.h>
@@ -80,7 +80,7 @@ typedef struct {
 #define LOG_STR_SIZE 80
 typedef struct {
 	char log[LOG_STR_SIZE];
-	struct list_head list;
+	struct qb_list_head list;
 } log_entry_t;
 
 static char big_and_buf[HOW_BIG_AND_BUF];
@@ -90,8 +90,8 @@ static cpg_handle_t cpg_handle = 0;
 static corosync_cfg_handle_t cfg_handle = 0;
 static int32_t cpg_fd = -1;
 static int32_t cfg_fd = -1;
-static struct list_head config_chg_log_head;
-static struct list_head msg_log_head;
+static struct qb_list_head config_chg_log_head;
+static struct qb_list_head msg_log_head;
 static pid_t my_pid;
 static uint32_t my_nodeid;
 static int32_t my_seq;
@@ -176,12 +176,12 @@ static void delivery_callback (
 	}
 
 	log_pt = malloc (sizeof(log_entry_t));
-	list_init (&log_pt->list);
+	qb_list_init (&log_pt->list);
 
 	snprintf (log_pt->log, LOG_STR_SIZE, "%u:%d:%d:%s;",
 		msg_pt->nodeid, msg_pt->seq, my_seq,
 		err_status_string (status_buf, 20, status));
-	list_add_tail (&log_pt->list, &msg_log_head);
+	qb_list_add_tail (&log_pt->list, &msg_log_head);
 	total_stored_msgs++;
 	total_msgs_revd++;
 	my_seq++;
@@ -211,20 +211,20 @@ static void config_change_callback (
 	for (i = 0; i < left_list_entries; i++) {
 		if (record_config_events_g > 0) {
 			log_pt = malloc (sizeof(log_entry_t));
-			list_init (&log_pt->list);
+			qb_list_init (&log_pt->list);
 			snprintf (log_pt->log, LOG_STR_SIZE, "%s,%u,%u,left",
 				groupName->value, left_list[i].nodeid,left_list[i].pid);
-			list_add_tail(&log_pt->list, &config_chg_log_head);
+			qb_list_add_tail(&log_pt->list, &config_chg_log_head);
 			qb_log (LOG_INFO, "cpg event %s", log_pt->log);
 		}
 	}
 	for (i = 0; i < joined_list_entries; i++) {
 		if (record_config_events_g > 0) {
 			log_pt = malloc (sizeof(log_entry_t));
-			list_init (&log_pt->list);
+			qb_list_init (&log_pt->list);
 			snprintf (log_pt->log, LOG_STR_SIZE, "%s,%u,%u,join",
 				groupName->value, joined_list[i].nodeid,joined_list[i].pid);
-			list_add_tail (&log_pt->list, &config_chg_log_head);
+			qb_list_add_tail (&log_pt->list, &config_chg_log_head);
 			qb_log (LOG_INFO, "cpg event %s", log_pt->log);
 		}
 	}
@@ -277,16 +277,16 @@ static void record_config_events (int sock)
 static void read_config_event (int sock)
 {
 	const char *empty = "None";
-	struct list_head * list = config_chg_log_head.next;
+	struct qb_list_head * list = config_chg_log_head.next;
 	log_entry_t *entry;
 	ssize_t rc;
 	size_t send_len;
 
 	if (list != &config_chg_log_head) {
-		entry = list_entry (list, log_entry_t, list);
+		entry = qb_list_entry (list, log_entry_t, list);
 		send_len = strlen (entry->log);
 		rc = send (sock, entry->log, send_len, 0);
-		list_del (&entry->list);
+		qb_list_del (&entry->list);
 		free (entry);
 	} else {
 		qb_log (LOG_DEBUG, "no events in list");
@@ -298,7 +298,7 @@ static void read_config_event (int sock)
 
 static void read_messages (int sock, char* atmost_str)
 {
-	struct list_head * list;
+	struct qb_list_head * list;
 	log_entry_t *entry;
 	int atmost = atoi (atmost_str);
 	int packed = 0;
@@ -312,15 +312,15 @@ static void read_messages (int sock, char* atmost_str)
 	big_and_buf[0] = '\0';
 
 	for (list = msg_log_head.next;
-		(!list_empty (&msg_log_head) && packed < atmost); ) {
+		(!qb_list_empty (&msg_log_head) && packed < atmost); ) {
 
-		entry = list_entry (list, log_entry_t, list);
+		entry = qb_list_entry (list, log_entry_t, list);
 
 		strcat (big_and_buf, entry->log);
 		packed++;
 
 		list = list->next;
-		list_del (&entry->list);
+		qb_list_del (&entry->list);
 		free (entry);
 
 		total_stored_msgs--;
@@ -786,8 +786,8 @@ static void my_pre_exit(void)
 int
 main(int argc, char *argv[])
 {
-	list_init (&msg_log_head);
-	list_init (&config_chg_log_head);
+	qb_list_init (&msg_log_head);
+	qb_list_init (&config_chg_log_head);
 
 	if (NSS_NoDB_Init(".") != SECSuccess) {
 		qb_log(LOG_ERR, "Couldn't initialize nss");

exec/cfg.c

@@ -53,7 +53,7 @@
 #include <corosync/corotypes.h>
 #include <qb/qbipc_common.h>
 #include <corosync/cfg.h>
-#include <corosync/list.h>
+#include <qb/qblist.h>
 #include <corosync/mar_gen.h>
 #include <corosync/totem/totemip.h>
 #include <corosync/totem/totem.h>
@@ -77,7 +77,7 @@ enum cfg_message_req_types {
 
 #define DEFAULT_SHUTDOWN_TIMEOUT 5
 
-static struct list_head trackers_list;
+static struct qb_list_head trackers_list;
 
 /*
  * Variables controlling a requested shutdown
@@ -91,7 +91,7 @@ static int shutdown_expected;
 
 struct cfg_info
 {
-	struct list_head list;
+	struct qb_list_head list;
 	void *conn;
 	void *tracker_conn;
 	enum {SHUTDOWN_REPLY_UNKNOWN, SHUTDOWN_REPLY_YES, SHUTDOWN_REPLY_NO} shutdown_reply;
@@ -270,7 +270,7 @@ static char *cfg_exec_init_fn (
 {
 	api = corosync_api_v1;
 
-	list_init(&trackers_list);
+	qb_list_init(&trackers_list);
 	return (NULL);
 }
 
@@ -309,7 +309,7 @@ static int send_shutdown(void)
 static void send_test_shutdown(void *only_conn, void *exclude_conn, int status)
 {
 	struct res_lib_cfg_testshutdown res_lib_cfg_testshutdown;
-	struct list_head *iter;
+	struct qb_list_head *iter;
 
 	ENTER();
 	res_lib_cfg_testshutdown.header.size = sizeof(struct res_lib_cfg_testshutdown);
@@ -322,8 +322,8 @@ static void send_test_shutdown(void *only_conn, void *exclude_conn, int status)
 		api->ipc_dispatch_send(only_conn, &res_lib_cfg_testshutdown,
 				       sizeof(res_lib_cfg_testshutdown));
 	} else {
-		for (iter = trackers_list.next; iter != &trackers_list; iter = iter->next) {
-			struct cfg_info *ci = list_entry(iter, struct cfg_info, list);
+		qb_list_for_each(iter, &trackers_list) {
+			struct cfg_info *ci = qb_list_entry(iter, struct cfg_info, list);
 
 			if (ci->conn != exclude_conn) {
 				TRACE1("sending testshutdown to %p", ci->tracker_conn);
@@ -428,9 +428,9 @@ static void remove_ci_from_shutdown(struct cfg_info *ci)
 		api->timer_delete(shutdown_timer);
 	}
 
-	if (!list_empty(&ci->list)) {
-		list_del(&ci->list);
-		list_init(&ci->list);
+	if (!qb_list_empty(&ci->list)) {
+		qb_list_del(&ci->list);
+		qb_list_init(&ci->list);
 
 		/*
 		 * Remove our option
@@ -469,7 +469,7 @@ static int cfg_lib_init_fn (void *conn)
 	struct cfg_info *ci = (struct cfg_info *)api->ipc_private_data_get (conn);
 
 	ENTER();
-	list_init(&ci->list);
+	qb_list_init(&ci->list);
 	LEAVE();
 
         return (0);
@@ -864,7 +864,7 @@ static void message_handler_req_lib_cfg_tryshutdown (
 {
 	struct cfg_info *ci = (struct cfg_info *)api->ipc_private_data_get (conn);
 	const struct req_lib_cfg_tryshutdown *req_lib_cfg_tryshutdown = msg;
-	struct list_head *iter;
+	struct qb_list_head *iter;
 
 	ENTER();
 
@@ -916,8 +916,8 @@ static void message_handler_req_lib_cfg_tryshutdown (
 	 */
 	shutdown_expected = 0;
 
-	for (iter = trackers_list.next; iter != &trackers_list; iter = iter->next) {
-		struct cfg_info *testci = list_entry(iter, struct cfg_info, list);
+        qb_list_for_each(iter, &trackers_list) {
+		struct cfg_info *testci = qb_list_entry(iter, struct cfg_info, list);
 		/*
 		 * It is assumed that we will allow shutdown
 		 */

exec/cmap.c

@@ -48,7 +48,6 @@
 
 #include <corosync/corotypes.h>
 #include <corosync/corodefs.h>
-#include <corosync/list.h>
 #include <corosync/mar_gen.h>
 #include <corosync/ipc_cmap.h>
 #include <corosync/logsys.h>

exec/coroparse.c

@@ -54,7 +54,7 @@
 #include <grp.h>
 #include <pwd.h>
 
-#include <corosync/list.h>
+#include <qb/qblist.h>
 #include <qb/qbutil.h>
 #define LOGSYS_UTILS_ONLY 1
 #include <corosync/logsys.h>
@@ -104,7 +104,7 @@ typedef int (*parser_cb_f)(const char *path,
 struct key_value_list_item {
 	char *key;
 	char *value;
-	struct list_head list;
+	struct qb_list_head list;
 };
 
 struct main_cp_cb_data {
@@ -119,10 +119,10 @@ struct main_cp_cb_data {
 	int knet_ping_timeout;
 	int knet_ping_precision;
 
-	struct list_head logger_subsys_items_head;
+	struct qb_list_head logger_subsys_items_head;
 	char *subsys;
 	char *logging_daemon_name;
-	struct list_head member_items_head;
+	struct qb_list_head member_items_head;
 
 	int node_number;
 	int ring0_addr_added;
@@ -514,7 +514,7 @@ static int main_config_parser_cb(const char *path,
 	static char formated_err[256];
 	struct main_cp_cb_data *data = (struct main_cp_cb_data *)user_data;
 	struct key_value_list_item *kv_item;
-	struct list_head *iter, *iter_next;
+        struct qb_list_head *iter;
 	int uid, gid;
 
 	switch (type) {
@@ -781,8 +781,8 @@ static int main_config_parser_cb(const char *path,
 
 					return (0);
 				}
-				list_init(&kv_item->list);
-				list_add(&kv_item->list, &data->logger_subsys_items_head);
+				qb_list_init(&kv_item->list);
+				qb_list_add(&kv_item->list, &data->logger_subsys_items_head);
 			}
 			add_as_string = 0;
 			break;
@@ -818,8 +818,8 @@ static int main_config_parser_cb(const char *path,
 
 					return (0);
 				}
-				list_init(&kv_item->list);
-				list_add(&kv_item->list, &data->logger_subsys_items_head);
+				qb_list_init(&kv_item->list);
+				qb_list_add(&kv_item->list, &data->logger_subsys_items_head);
 			}
 			add_as_string = 0;
 			break;
@@ -872,8 +872,8 @@ static int main_config_parser_cb(const char *path,
 
 				return (0);
 			}
-			list_init(&kv_item->list);
-			list_add(&kv_item->list, &data->member_items_head);
+			qb_list_init(&kv_item->list);
+			qb_list_add(&kv_item->list, &data->member_items_head);
 			add_as_string = 0;
 			break;
 		case MAIN_CP_CB_DATA_STATE_NODELIST:
@@ -946,7 +946,7 @@ static int main_config_parser_cb(const char *path,
 			data->knet_ping_interval = -1;
 			data->knet_ping_timeout = -1;
 			data->knet_ping_precision = -1;
-			list_init(&data->member_items_head);
+			qb_list_init(&data->member_items_head);
 		};
 		if (strcmp(path, "totem") == 0) {
 			*state = MAIN_CP_CB_DATA_STATE_TOTEM;
@@ -956,12 +956,12 @@ static int main_config_parser_cb(const char *path,
 		}
 		if (strcmp(path, "logging.logger_subsys") == 0) {
 			*state = MAIN_CP_CB_DATA_STATE_LOGGER_SUBSYS;
-			list_init(&data->logger_subsys_items_head);
+			qb_list_init(&data->logger_subsys_items_head);
 			data->subsys = NULL;
 		}
 		if (strcmp(path, "logging.logging_daemon") == 0) {
 			*state = MAIN_CP_CB_DATA_STATE_LOGGING_DAEMON;
-			list_init(&data->logger_subsys_items_head);
+			qb_list_init(&data->logger_subsys_items_head);
 			data->subsys = NULL;
 			data->logging_daemon_name = NULL;
 		}
@@ -1067,16 +1067,14 @@ static int main_config_parser_cb(const char *path,
 			}
 
 			ii = 0;
-			for (iter = data->member_items_head.next;
-			     iter != &data->member_items_head; iter = iter_next) {
-				kv_item = list_entry(iter, struct key_value_list_item, list);
+
+                        qb_list_for_each(iter, &(data->member_items_head)) {
+				kv_item = qb_list_entry(iter, struct key_value_list_item, list);
 
 				snprintf(key_name, ICMAP_KEYNAME_MAXLEN, "totem.interface.%u.member.%u",
 						data->linknumber, ii);
 				icmap_set_string_r(config_map, key_name, kv_item->value);
 
-				iter_next = iter->next;
-
 				free(kv_item->value);
 				free(kv_item->key);
 				free(kv_item);
@@ -1091,15 +1089,12 @@ static int main_config_parser_cb(const char *path,
 				return (0);
 			}
 
-			for (iter = data->logger_subsys_items_head.next;
-			     iter != &data->logger_subsys_items_head; iter = iter_next) {
-				kv_item = list_entry(iter, struct key_value_list_item, list);
+                        qb_list_for_each(iter, &(data->logger_subsys_items_head)) {
+				kv_item = qb_list_entry(iter, struct key_value_list_item, list);
 
 				snprintf(key_name, ICMAP_KEYNAME_MAXLEN, "logging.logger_subsys.%s.%s",
 					 data->subsys, kv_item->key);
-				icmap_set_string_r(config_map, key_name, kv_item->value);
-
-				iter_next = iter->next;
+                                icmap_set_string_r(config_map, key_name, kv_item->value);
 
 				free(kv_item->value);
 				free(kv_item->key);
@@ -1120,9 +1115,8 @@ static int main_config_parser_cb(const char *path,
 				return (0);
 			}
 
-			for (iter = data->logger_subsys_items_head.next;
-			     iter != &data->logger_subsys_items_head; iter = iter_next) {
-				kv_item = list_entry(iter, struct key_value_list_item, list);
+                        qb_list_for_each(iter, &(data->logger_subsys_items_head)) {
+				kv_item = qb_list_entry(iter, struct key_value_list_item, list);
 
 				if (data->subsys == NULL) {
 					if (strcmp(data->logging_daemon_name, "corosync") == 0) {
@@ -1149,8 +1143,6 @@ static int main_config_parser_cb(const char *path,
 				}
 				icmap_set_string_r(config_map, key_name, kv_item->value);
 
-				iter_next = iter->next;
-
 				free(kv_item->value);
 				free(kv_item->key);
 				free(kv_item);

exec/cpg.c

@@ -55,12 +55,13 @@
 #include <netinet/in.h>
 #include <arpa/inet.h>
 #include <sys/mman.h>
+
+#include <qb/qblist.h>
 #include <qb/qbmap.h>
 
 #include <corosync/corotypes.h>
 #include <qb/qbipc_common.h>
 #include <corosync/corodefs.h>
-#include <corosync/list.h>
 #include <corosync/logsys.h>
 #include <corosync/coroapi.h>
 
@@ -88,7 +89,7 @@ enum cpg_message_req_types {
 };
 
 struct zcb_mapped {
-	struct list_head list;
+	struct qb_list_head list;
 	void *addr;
 	size_t size;
 };
@@ -147,8 +148,8 @@ enum cpg_downlist_state_e {
        CPG_DOWNLIST_APPLYING,
 };
 static enum cpg_downlist_state_e downlist_state;
-static struct list_head downlist_messages_head;
-static struct list_head joinlist_messages_head;
+static struct qb_list_head downlist_messages_head;
+static struct qb_list_head joinlist_messages_head;
 
 struct cpg_pd {
 	void *conn;
@@ -159,21 +160,21 @@ struct cpg_pd {
 	int initial_totem_conf_sent;
 	uint64_t transition_counter; /* These two are used when sending fragmented messages */
 	uint64_t initial_transition_counter;
-	struct list_head list;
-	struct list_head iteration_instance_list_head;
-	struct list_head zcb_mapped_list_head;
+	struct qb_list_head list;
+	struct qb_list_head iteration_instance_list_head;
+	struct qb_list_head zcb_mapped_list_head;
 };
 
 struct cpg_iteration_instance {
 	hdb_handle_t handle;
-	struct list_head list;
-	struct list_head items_list_head; /* List of process_info */
-	struct list_head *current_pointer;
+	struct qb_list_head list;
+	struct qb_list_head items_list_head; /* List of process_info */
+	struct qb_list_head *current_pointer;
 };
 
 DECLARE_HDB_DATABASE(cpg_iteration_handle_t_db,NULL);
 
-DECLARE_LIST_INIT(cpg_pd_list_head);
+QB_LIST_DECLARE (cpg_pd_list_head);
 
 static unsigned int my_member_list[PROCESSOR_COUNT_MAX];
 
@@ -193,9 +194,9 @@ struct process_info {
 	unsigned int nodeid;
 	uint32_t pid;
 	mar_cpg_name_t group;
-	struct list_head list; /* on the group_info members list */
+	struct qb_list_head list; /* on the group_info members list */
 };
-DECLARE_LIST_INIT(process_info_list_head);
+QB_LIST_DECLARE (process_info_list_head);
 
 struct join_list_entry {
 	uint32_t pid;
@@ -506,14 +507,14 @@ struct downlist_msg {
 	mar_uint32_t old_members __attribute__((aligned(8)));
 	mar_uint32_t left_nodes __attribute__((aligned(8)));
 	mar_uint32_t nodeids[PROCESSOR_COUNT_MAX]  __attribute__((aligned(8)));
-	struct list_head list;
+	struct qb_list_head list;
 };
 
 struct joinlist_msg {
 	mar_uint32_t sender_nodeid;
 	uint32_t pid;
 	mar_cpg_name_t group_name;
-	struct list_head list;
+	struct qb_list_head list;
 };
 
 static struct req_exec_cpg_downlist g_req_exec_cpg_downlist;
@@ -638,7 +639,7 @@ static int notify_lib_totem_membership (
 	int member_list_entries,
 	const unsigned int *member_list)
 {
-	struct list_head *iter;
+	struct qb_list_head *iter;
 	char *buf;
 	int size;
 	struct res_lib_cpg_totem_confchg_callback *res;
@@ -659,8 +660,8 @@ static int notify_lib_totem_membership (
 	memcpy (res->member_list, member_list, res->member_list_entries * sizeof (mar_uint32_t));
 
 	if (conn == NULL) {
-		for (iter = cpg_pd_list_head.next; iter != &cpg_pd_list_head; iter = iter->next) {
-			struct cpg_pd *cpg_pd = list_entry (iter, struct cpg_pd, list);
+                qb_list_for_each(iter, &cpg_pd_list_head) {
+			struct cpg_pd *cpg_pd = qb_list_entry (iter, struct cpg_pd, list);
 			api->ipc_dispatch_send (cpg_pd->conn, buf, size);
 		}
 	} else {
@@ -681,15 +682,15 @@ static int notify_lib_joinlist(
 {
 	int size;
 	char *buf;
-	struct list_head *iter;
+	struct qb_list_head *iter;
 	int count;
 	struct res_lib_cpg_confchg_callback *res;
 	mar_cpg_address_t *retgi;
 
 	count = 0;
 
-	for (iter = process_info_list_head.next; iter != &process_info_list_head; iter = iter->next) {
-		struct process_info *pi = list_entry (iter, struct process_info, list);
+        qb_list_for_each(iter, &process_info_list_head) {
+		struct process_info *pi = qb_list_entry (iter, struct process_info, list);
 		if (mar_name_compare (&pi->group, group_name) == 0) {
 			int i;
 			int founded = 0;
@@ -721,8 +722,8 @@ static int notify_lib_joinlist(
 	res->header.error = CS_OK;
 	memcpy(&res->group_name, group_name, sizeof(mar_cpg_name_t));
 
-	for (iter = process_info_list_head.next; iter != &process_info_list_head; iter = iter->next) {
-		struct process_info *pi=list_entry (iter, struct process_info, list);
+        qb_list_for_each(iter, &process_info_list_head) {
+		struct process_info *pi=qb_list_entry (iter, struct process_info, list);
 
 		if (mar_name_compare (&pi->group, group_name) == 0) {
 			int i;
@@ -755,8 +756,8 @@ static int notify_lib_joinlist(
 	if (conn) {
 		api->ipc_dispatch_send (conn, buf, size);
 	} else {
-		for (iter = cpg_pd_list_head.next; iter != &cpg_pd_list_head; iter = iter->next) {
-			struct cpg_pd *cpd = list_entry (iter, struct cpg_pd, list);
+                qb_list_for_each(iter, &cpg_pd_list_head) {
+			struct cpg_pd *cpd = qb_list_entry (iter, struct cpg_pd, list);
 			if (mar_name_compare (&cpd->group_name, group_name) == 0) {
 				assert (joined_list_entries <= 1);
 				if (joined_list_entries) {
@@ -789,8 +790,8 @@ static int notify_lib_joinlist(
 	/*
 	 * Traverse thru cpds and send totem membership for cpd, where it is not send yet
 	 */
-	for (iter = cpg_pd_list_head.next; iter != &cpg_pd_list_head; iter = iter->next) {
-		struct cpg_pd *cpd = list_entry (iter, struct cpg_pd, list);
+        qb_list_for_each(iter, &cpg_pd_list_head) {
+		struct cpg_pd *cpd = qb_list_entry (iter, struct cpg_pd, list);
 
 		if ((cpd->flags & CPG_MODEL_V1_DELIVER_INITIAL_TOTEM_CONF) && (cpd->initial_totem_conf_sent == 0)) {
 			cpd->initial_totem_conf_sent = 1;
@@ -816,17 +817,14 @@ static struct downlist_msg* downlist_master_choose (void)
 {
 	struct downlist_msg *cmp;
 	struct downlist_msg *best = NULL;
-	struct list_head *iter;
+	struct qb_list_head *iter;
 	uint32_t cmp_members;
 	uint32_t best_members;
 	uint32_t i;
 	int ignore_msg;
 
-	for (iter = downlist_messages_head.next;
-		iter != &downlist_messages_head;
-		iter = iter->next) {
-
-		cmp = list_entry(iter, struct downlist_msg, list);
+        qb_list_for_each(iter, &downlist_messages_head) {
+		cmp = qb_list_entry(iter, struct downlist_msg, list);
 		downlist_log("comparing", cmp);
 
 		ignore_msg = 0;
@@ -872,7 +870,7 @@ static struct downlist_msg* downlist_master_choose (void)
 static void downlist_master_choose_and_send (void)
 {
 	struct downlist_msg *stored_msg;
-	struct list_head *iter;
+	struct qb_list_head *iter;
 	struct process_info *left_pi;
 	qb_map_t *group_map;
 	struct cpg_name cpg_group;
@@ -881,7 +879,7 @@ static void downlist_master_choose_and_send (void)
 		struct cpg_name cpg_group;
 		mar_cpg_address_t left_list[CPG_MEMBERS_MAX];
 		int left_list_entries;
-		struct list_head  list;
+		struct qb_list_head  list;
 	} *pcd;
 	qb_map_iter_t *miter;
 	int i, size;
@@ -902,9 +900,8 @@ static void downlist_master_choose_and_send (void)
 	 * confchg event, so we will collect these cpg groups and
 	 * relative left_lists here.
 	 */
-	for (iter = process_info_list_head.next; iter != &process_info_list_head; ) {
-		struct process_info *pi = list_entry(iter, struct process_info, list);
-		iter = iter->next;
+        qb_list_for_each(iter, &process_info_list_head) {
+                struct process_info *pi = qb_list_entry(iter, struct process_info, list);
 
 		left_pi = NULL;
 		for (i = 0; i < stored_msg->left_nodes; i++) {
@@ -930,7 +927,7 @@ static void downlist_master_choose_and_send (void)
 			pcd->left_list[size].pid = left_pi->pid;
 			pcd->left_list[size].reason = CONFCHG_CPG_REASON_NODEDOWN;
 			pcd->left_list_entries++;
-			list_del (&left_pi->list);
+			qb_list_del (&left_pi->list);
 			free (left_pi);
 		}
 	}
@@ -966,15 +963,14 @@ static void downlist_master_choose_and_send (void)
  */
 static void joinlist_remove_zombie_pi_entries (void)
 {
-	struct list_head *pi_iter;
-	struct list_head *jl_iter;
+	struct qb_list_head *pi_iter;
+	struct qb_list_head *jl_iter;
 	struct process_info *pi;
 	struct joinlist_msg *stored_msg;
 	int found;
 
-	for (pi_iter = process_info_list_head.next; pi_iter != &process_info_list_head; ) {
-		pi = list_entry (pi_iter, struct process_info, list);
-		pi_iter = pi_iter->next;
+        qb_list_for_each(pi_iter, &process_info_list_head) {
+                pi = qb_list_entry (pi_iter, struct process_info, list);
 
 		/*
 		 * Ignore local node
@@ -987,11 +983,8 @@ static void joinlist_remove_zombie_pi_entries (void)
 		 * Try to find message in joinlist messages
 		 */
 		found = 0;
-		for (jl_iter = joinlist_messages_head.next;
-			jl_iter != &joinlist_messages_head;
-			jl_iter = jl_iter->next) {
-
-			stored_msg = list_entry(jl_iter, struct joinlist_msg, list);
+                qb_list_for_each(jl_iter, &joinlist_messages_head) {
+			stored_msg = qb_list_entry(jl_iter, struct joinlist_msg, list);
 
 			if (stored_msg->sender_nodeid == api->totem_nodeid_get()) {
 				continue ;
@@ -1014,15 +1007,12 @@ static void joinlist_remove_zombie_pi_entries (void)
 static void joinlist_inform_clients (void)
 {
 	struct joinlist_msg *stored_msg;
-	struct list_head *iter;
+	struct qb_list_head *iter;
 	unsigned int i;
 
 	i = 0;
-	for (iter = joinlist_messages_head.next;
-		iter != &joinlist_messages_head;
-		iter = iter->next) {
-
-		stored_msg = list_entry(iter, struct joinlist_msg, list);
+        qb_list_for_each(iter, &joinlist_messages_head) {
+		stored_msg = qb_list_entry(iter, struct joinlist_msg, list);
 
 		log_printf (LOG_DEBUG, "joinlist_messages[%u] group:%s, ip:%s, pid:%d",
 			i++, cpg_print_group_name(&stored_msg->group_name),
@@ -1044,16 +1034,11 @@ static void joinlist_inform_clients (void)
 static void downlist_messages_delete (void)
 {
 	struct downlist_msg *stored_msg;
-	struct list_head *iter, *iter_next;
-
-	for (iter = downlist_messages_head.next;
-		iter != &downlist_messages_head;
-		iter = iter_next) {
-
-		iter_next = iter->next;
+        struct qb_list_head *iter;
 
-		stored_msg = list_entry(iter, struct downlist_msg, list);
-		list_del (&stored_msg->list);
+        qb_list_for_each(iter, &downlist_messages_head) {
+		stored_msg = qb_list_entry(iter, struct downlist_msg, list);
+		qb_list_del (&stored_msg->list);
 		free (stored_msg);
 	}
 }
@@ -1061,67 +1046,52 @@ static void downlist_messages_delete (void)
 static void joinlist_messages_delete (void)
 {
 	struct joinlist_msg *stored_msg;
-	struct list_head *iter, *iter_next;
+        struct qb_list_head *iter;
 
-	for (iter = joinlist_messages_head.next;
-		iter != &joinlist_messages_head;
-		iter = iter_next) {
-
-		iter_next = iter->next;
-
-		stored_msg = list_entry(iter, struct joinlist_msg, list);
-		list_del (&stored_msg->list);
+        qb_list_for_each(iter, &joinlist_messages_head) {
+		stored_msg = qb_list_entry(iter, struct joinlist_msg, list);
+		qb_list_del (&stored_msg->list);
 		free (stored_msg);
 	}
-	list_init (&joinlist_messages_head);
+	qb_list_init (&joinlist_messages_head);
 }
 
 static char *cpg_exec_init_fn (struct corosync_api_v1 *corosync_api)
 {
-	list_init (&downlist_messages_head);
-	list_init (&joinlist_messages_head);
+	qb_list_init (&downlist_messages_head);
+	qb_list_init (&joinlist_messages_head);
 	api = corosync_api;
 	return (NULL);
 }
 
 static void cpg_iteration_instance_finalize (struct cpg_iteration_instance *cpg_iteration_instance)
 {
-	struct list_head *iter, *iter_next;
+        struct qb_list_head *iter;
 	struct process_info *pi;
 
-	for (iter = cpg_iteration_instance->items_list_head.next;
-		iter != &cpg_iteration_instance->items_list_head;
-		iter = iter_next) {
-
-		iter_next = iter->next;
-
-		pi = list_entry (iter, struct process_info, list);
-		list_del (&pi->list);
+        qb_list_for_each(iter, &(cpg_iteration_instance->items_list_head)) {
+		pi = qb_list_entry (iter, struct process_info, list);
+		qb_list_del (&pi->list);
 		free (pi);
 	}
 
-	list_del (&cpg_iteration_instance->list);
+	qb_list_del (&cpg_iteration_instance->list);
 	hdb_handle_destroy (&cpg_iteration_handle_t_db, cpg_iteration_instance->handle);
 }
 
 static void cpg_pd_finalize (struct cpg_pd *cpd)
 {
-	struct list_head *iter, *iter_next;
+        struct qb_list_head *iter;
 	struct cpg_iteration_instance *cpii;
 
-	zcb_all_free(cpd);
-	for (iter = cpd->iteration_instance_list_head.next;
-		iter != &cpd->iteration_instance_list_head;
-		iter = iter_next) {
-
-		iter_next = iter->next;
-
-		cpii = list_entry (iter, struct cpg_iteration_instance, list);
+        zcb_all_free(cpd);
+        qb_list_for_each(iter, &(cpd->iteration_instance_list_head)) {
+		cpii = qb_list_entry (iter, struct cpg_iteration_instance, list);
 
 		cpg_iteration_instance_finalize (cpii);
 	}
 
-	list_del (&cpd->list);
+	qb_list_del (&cpd->list);
 }
 
 static int cpg_lib_exit_fn (void *conn)
@@ -1230,12 +1200,10 @@ static void exec_cpg_partial_mcast_endian_convert (void *msg)
 }
 
 static struct process_info *process_info_find(const mar_cpg_name_t *group_name, uint32_t pid, unsigned int nodeid) {
-	struct list_head *iter;
-
-	for (iter = process_info_list_head.next; iter != &process_info_list_head; ) {
-		struct process_info *pi = list_entry (iter, struct process_info, list);
-		iter = iter->next;
+	struct qb_list_head *iter;
 
+        qb_list_for_each(iter, &process_info_list_head) {
+                struct process_info *pi = qb_list_entry (iter, struct process_info, list);
 		if (pi->pid == pid && pi->nodeid == nodeid &&
 			mar_name_compare (&pi->group, group_name) == 0) {
 				return pi;
@@ -1254,8 +1222,8 @@ static void do_proc_join(
 	struct process_info *pi;
 	struct process_info *pi_entry;
 	mar_cpg_address_t notify_info;
-	struct list_head *list;
-	struct list_head *list_to_add = NULL;
+	struct qb_list_head *list;
+	struct qb_list_head *list_to_add = NULL;
 
 	if (process_info_find (name, pid, nodeid) != NULL) {
 		return ;
@@ -1268,15 +1236,14 @@ static void do_proc_join(
 	pi->nodeid = nodeid;
 	pi->pid = pid;
 	memcpy(&pi->group, name, sizeof(*name));
-	list_init(&pi->list);
+	qb_list_init(&pi->list);
 
 	/*
 	 * Insert new process in sorted order so synchronization works properly
 	 */
 	list_to_add = &process_info_list_head;
-	for (list = process_info_list_head.next; list != &process_info_list_head; list = list->next) {
-
-		pi_entry = list_entry(list, struct process_info, list);
+        qb_list_for_each(list, &process_info_list_head) {
+		pi_entry = qb_list_entry(list, struct process_info, list);
 		if (pi_entry->nodeid > pi->nodeid ||
 			(pi_entry->nodeid == pi->nodeid && pi_entry->pid > pi->pid)) {
 
@@ -1284,7 +1251,7 @@ static void do_proc_join(
 		}
 		list_to_add = list;
 	}
-	list_add (&pi->list, list_to_add);
+	qb_list_add (&pi->list, list_to_add);
 
 	notify_info.pid = pi->pid;
 	notify_info.nodeid = nodeid;
@@ -1303,7 +1270,7 @@ static void do_proc_leave(
 	int reason)
 {
 	struct process_info *pi;
-	struct list_head *iter;
+	struct qb_list_head *iter;
 	mar_cpg_address_t notify_info;
 
 	notify_info.pid = pid;
@@ -1315,13 +1282,13 @@ static void do_proc_leave(
 		1, &notify_info,
 		MESSAGE_RES_CPG_CONFCHG_CALLBACK);
 
-	for (iter = process_info_list_head.next; iter != &process_info_list_head; ) {
-		pi = list_entry(iter, struct process_info, list);
+        qb_list_for_each(iter, &process_info_list_head) {
+		pi = qb_list_entry(iter, struct process_info, list);
 		iter = iter->next;
 
 		if (pi->pid == pid && pi->nodeid == nodeid &&
 			mar_name_compare (&pi->group, name)==0) {
-			list_del (&pi->list);
+			qb_list_del (&pi->list);
 			free (pi);
 		}
 	}
@@ -1341,7 +1308,7 @@ static void message_handler_req_exec_cpg_downlist(
 {
 	const struct req_exec_cpg_downlist *req_exec_cpg_downlist = message;
 	int i;
-	struct list_head *iter;
+	struct qb_list_head *iter;
 	struct downlist_msg *stored_msg;
 	int found;
 
@@ -1357,16 +1324,14 @@ static void message_handler_req_exec_cpg_downlist(
 	stored_msg->left_nodes = req_exec_cpg_downlist->left_nodes;
 	memcpy (stored_msg->nodeids, req_exec_cpg_downlist->nodeids,
 		req_exec_cpg_downlist->left_nodes * sizeof (mar_uint32_t));
-	list_init (&stored_msg->list);
-	list_add (&stored_msg->list, &downlist_messages_head);
+	qb_list_init (&stored_msg->list);
+	qb_list_add (&stored_msg->list, &downlist_messages_head);
 
 	for (i = 0; i < my_member_list_entries; i++) {
 		found = 0;
-		for (iter = downlist_messages_head.next;
-			iter != &downlist_messages_head;
-			iter = iter->next) {
+                qb_list_for_each(iter, &downlist_messages_head) {
 
-			stored_msg = list_entry(iter, struct downlist_msg, list);
+			stored_msg = qb_list_entry(iter, struct downlist_msg, list);
 			if (my_member_list[i] == stored_msg->sender_nodeid) {
 				found = 1;
 			}
@@ -1432,8 +1397,8 @@ static void message_handler_req_exec_cpg_joinlist (
 		stored_msg->sender_nodeid = nodeid;
 		stored_msg->pid = jle->pid;
 		memcpy(&stored_msg->group_name, &jle->group_name, sizeof(mar_cpg_name_t));
-		list_init (&stored_msg->list);
-		list_add (&stored_msg->list, &joinlist_messages_head);
+		qb_list_init (&stored_msg->list);
+		qb_list_add (&stored_msg->list, &joinlist_messages_head);
 		jle++;
 	}
 }
@@ -1445,7 +1410,7 @@ static void message_handler_req_exec_cpg_mcast (
 	const struct req_exec_cpg_mcast *req_exec_cpg_mcast = message;
 	struct res_lib_cpg_deliver_callback res_lib_cpg_mcast;
 	int msglen = req_exec_cpg_mcast->msglen;
-	struct list_head *iter, *pi_iter;
+	struct qb_list_head *iter, *pi_iter;
 	struct cpg_pd *cpd;
 	struct iovec iovec[2];
 	int known_node = 0;
@@ -1464,19 +1429,15 @@ static void message_handler_req_exec_cpg_mcast (
 	iovec[1].iov_base = (char*)message+sizeof(*req_exec_cpg_mcast);
 	iovec[1].iov_len = msglen;
 
-	for (iter = cpg_pd_list_head.next; iter != &cpg_pd_list_head; ) {
-		cpd = list_entry(iter, struct cpg_pd, list);
-		iter = iter->next;
-
+        qb_list_for_each(iter, &cpg_pd_list_head) {
+		cpd = qb_list_entry(iter, struct cpg_pd, list);
 		if ((cpd->cpd_state == CPD_STATE_LEAVE_STARTED || cpd->cpd_state == CPD_STATE_JOIN_COMPLETED)
 			&& (mar_name_compare (&cpd->group_name, &req_exec_cpg_mcast->group_name) == 0)) {
 
 			if (!known_node) {
 				/* Try to find, if we know the node */
-				for (pi_iter = process_info_list_head.next;
-					pi_iter != &process_info_list_head; pi_iter = pi_iter->next) {
-
-					struct process_info *pi = list_entry (pi_iter, struct process_info, list);
+                                qb_list_for_each(pi_iter, &process_info_list_head) {
+					struct process_info *pi = qb_list_entry (pi_iter, struct process_info, list);
 
 					if (pi->nodeid == nodeid &&
 						mar_name_compare (&pi->group, &req_exec_cpg_mcast->group_name) == 0) {
@@ -1503,7 +1464,7 @@ static void message_handler_req_exec_cpg_partial_mcast (
 	const struct req_exec_cpg_partial_mcast *req_exec_cpg_mcast = message;
 	struct res_lib_cpg_partial_deliver_callback res_lib_cpg_mcast;
 	int msglen = req_exec_cpg_mcast->fraglen;
-	struct list_head *iter, *pi_iter;
+	struct qb_list_head *iter, *pi_iter;
 	struct cpg_pd *cpd;
 	struct iovec iovec[2];
 	int known_node = 0;
@@ -1526,19 +1487,15 @@ static void message_handler_req_exec_cpg_partial_mcast (
 	iovec[1].iov_base = (char*)message+sizeof(*req_exec_cpg_mcast);
 	iovec[1].iov_len = msglen;
 
-	for (iter = cpg_pd_list_head.next; iter != &cpg_pd_list_head; ) {
-		cpd = list_entry(iter, struct cpg_pd, list);
-		iter = iter->next;
-
+        qb_list_for_each(iter, &cpg_pd_list_head) {
+                cpd = qb_list_entry(iter, struct cpg_pd, list);
 		if ((cpd->cpd_state == CPD_STATE_LEAVE_STARTED || cpd->cpd_state == CPD_STATE_JOIN_COMPLETED)
 		    && (mar_name_compare (&cpd->group_name, &req_exec_cpg_mcast->group_name) == 0)) {
 
 			if (!known_node) {
 				/* Try to find, if we know the node */
-				for (pi_iter = process_info_list_head.next;
-				     pi_iter != &process_info_list_head; pi_iter = pi_iter->next) {
-
-					struct process_info *pi = list_entry (pi_iter, struct process_info, list);
+                                qb_list_for_each(pi_iter, &process_info_list_head) {
+					struct process_info *pi = qb_list_entry (pi_iter, struct process_info, list);
 
 					if (pi->nodeid == nodeid &&
 					    mar_name_compare (&pi->group, &req_exec_cpg_mcast->group_name) == 0) {
@@ -1577,14 +1534,14 @@ static int cpg_exec_send_downlist(void)
 static int cpg_exec_send_joinlist(void)
 {
 	int count = 0;
-	struct list_head *iter;
+	struct qb_list_head *iter;
 	struct qb_ipc_response_header *res;
  	char *buf;
 	struct join_list_entry *jle;
 	struct iovec req_exec_cpg_iovec;
 
- 	for (iter = process_info_list_head.next; iter != &process_info_list_head; iter = iter->next) {
- 		struct process_info *pi = list_entry (iter, struct process_info, list);
+        qb_list_for_each(iter, &process_info_list_head) {
+		struct process_info *pi = qb_list_entry (iter, struct process_info, list);
 
  		if (pi->nodeid == api->totem_nodeid_get ()) {
  			count++;
@@ -1604,8 +1561,8 @@ static int cpg_exec_send_joinlist(void)
 	jle = (struct join_list_entry *)(buf + sizeof(struct qb_ipc_response_header));
 	res = (struct qb_ipc_response_header *)buf;
 
- 	for (iter = process_info_list_head.next; iter != &process_info_list_head; iter = iter->next) {
- 		struct process_info *pi = list_entry (iter, struct process_info, list);
+        qb_list_for_each(iter, &process_info_list_head) {
+		struct process_info *pi = qb_list_entry (iter, struct process_info, list);
 
 		if (pi->nodeid == api->totem_nodeid_get ()) {
 			memcpy (&jle->group_name, &pi->group, sizeof (mar_cpg_name_t));
@@ -1628,10 +1585,10 @@ static int cpg_lib_init_fn (void *conn)
 	struct cpg_pd *cpd = (struct cpg_pd *)api->ipc_private_data_get (conn);
 	memset (cpd, 0, sizeof(struct cpg_pd));
 	cpd->conn = conn;
-	list_add (&cpd->list, &cpg_pd_list_head);
+	qb_list_add (&cpd->list, &cpg_pd_list_head);
 
-	list_init (&cpd->iteration_instance_list_head);
-	list_init (&cpd->zcb_mapped_list_head);
+	qb_list_init (&cpd->iteration_instance_list_head);
+	qb_list_init (&cpd->zcb_mapped_list_head);
 
 	api->ipc_refcnt_inc (conn);
 	log_printf(LOGSYS_LEVEL_DEBUG, "lib_init_fn: conn=%p, cpd=%p", conn, cpd);
@@ -1645,11 +1602,11 @@ static void message_handler_req_lib_cpg_join (void *conn, const void *message)
 	struct cpg_pd *cpd = (struct cpg_pd *)api->ipc_private_data_get (conn);
 	struct res_lib_cpg_join res_lib_cpg_join;
 	cs_error_t error = CS_OK;
-	struct list_head *iter;
+	struct qb_list_head *iter;
 
 	/* Test, if we don't have same pid and group name joined */
-	for (iter = cpg_pd_list_head.next; iter != &cpg_pd_list_head; iter = iter->next) {
-		struct cpg_pd *cpd_item = list_entry (iter, struct cpg_pd, list);
+        qb_list_for_each(iter, &cpg_pd_list_head) {
+		struct cpg_pd *cpd_item = qb_list_entry (iter, struct cpg_pd, list);
 
 		if (cpd_item->pid == req_lib_cpg_join->pid &&
 			mar_name_compare(&req_lib_cpg_join->group_name, &cpd_item->group_name) == 0) {
@@ -1664,8 +1621,8 @@ static void message_handler_req_lib_cpg_join (void *conn, const void *message)
 	 * Same check must be done in process info list, because there may be not yet delivered
 	 * leave of client.
 	 */
-	for (iter = process_info_list_head.next; iter != &process_info_list_head; iter = iter->next) {
-		struct process_info *pi = list_entry (iter, struct process_info, list);
+        qb_list_for_each(iter, &process_info_list_head) {
+		struct process_info *pi = qb_list_entry (iter, struct process_info, list);
 
 		if (pi->nodeid == api->totem_nodeid_get () && pi->pid == req_lib_cpg_join->pid &&
 		    mar_name_compare(&req_lib_cpg_join->group_name, &pi->group) == 0) {
@@ -1763,8 +1720,8 @@ static void message_handler_req_lib_cpg_finalize (
 	 * We will just remove cpd from list. After this call, connection will be
 	 * closed on lib side, and cpg_lib_exit_fn will be called
 	 */
-	list_del (&cpd->list);
-	list_init (&cpd->list);
+	qb_list_del (&cpd->list);
+	qb_list_init (&cpd->list);
 
 	res_lib_cpg_finalize.header.size = sizeof (res_lib_cpg_finalize);
 	res_lib_cpg_finalize.header.id = MESSAGE_RES_CPG_FINALIZE;
@@ -1844,10 +1801,10 @@ static inline int zcb_alloc (
 		return (-1);
 	}
 
-	list_init (&zcb_mapped->list);
+	qb_list_init (&zcb_mapped->list);
 	zcb_mapped->addr = *addr;
 	zcb_mapped->size = size;
-	list_add_tail (&zcb_mapped->list, &cpd->zcb_mapped_list_head);
+	qb_list_add_tail (&zcb_mapped->list, &cpd->zcb_mapped_list_head);
 	return (0);
 }
 
@@ -1857,21 +1814,19 @@ static inline int zcb_free (struct zcb_mapped *zcb_mapped)
 	unsigned int res;
 
 	res = munmap (zcb_mapped->addr, zcb_mapped->size);
-	list_del (&zcb_mapped->list);
+	qb_list_del (&zcb_mapped->list);
 	free (zcb_mapped);
 	return (res);
 }
 
 static inline int zcb_by_addr_free (struct cpg_pd *cpd, void *addr)
 {
-	struct list_head *list;
+	struct qb_list_head *list;
 	struct zcb_mapped *zcb_mapped;
 	unsigned int res = 0;
 
-	for (list = cpd->zcb_mapped_list_head.next;
-		list != &cpd->zcb_mapped_list_head; list = list->next) {
-
-		zcb_mapped = list_entry (list, struct zcb_mapped, list);
+        qb_list_for_each(list, &(cpd->zcb_mapped_list_head)) {
+		zcb_mapped = qb_list_entry (list, struct zcb_mapped, list);
 
 		if (zcb_mapped->addr == addr) {
 			res = zcb_free (zcb_mapped);
@@ -1885,13 +1840,11 @@ static inline int zcb_by_addr_free (struct cpg_pd *cpd, void *addr)
 static inline int zcb_all_free (
 	struct cpg_pd *cpd)
 {
-	struct list_head *list;
+	struct qb_list_head *list;
 	struct zcb_mapped *zcb_mapped;
 
-	for (list = cpd->zcb_mapped_list_head.next;
-		list != &cpd->zcb_mapped_list_head;) {
-
-		zcb_mapped = list_entry (list, struct zcb_mapped, list);
+        qb_list_for_each(list, &(cpd->zcb_mapped_list_head)) {
+		zcb_mapped = qb_list_entry (list, struct zcb_mapped, list);
 
 		list = list->next;
 
@@ -2166,7 +2119,7 @@ static void message_handler_req_lib_cpg_membership (void *conn,
 	struct req_lib_cpg_membership_get *req_lib_cpg_membership_get =
 		(struct req_lib_cpg_membership_get *)message;
 	struct res_lib_cpg_membership_get res_lib_cpg_membership_get;
-	struct list_head *iter;
+	struct qb_list_head *iter;
 	int member_count = 0;
 
 	res_lib_cpg_membership_get.header.id = MESSAGE_RES_CPG_MEMBERSHIP;
@@ -2174,10 +2127,8 @@ static void message_handler_req_lib_cpg_membership (void *conn,
 	res_lib_cpg_membership_get.header.size =
 		sizeof (struct res_lib_cpg_membership_get);
 
-	for (iter = process_info_list_head.next;
-		iter != &process_info_list_head; iter = iter->next) {
-
-		struct process_info *pi = list_entry (iter, struct process_info, list);
+        qb_list_for_each(iter, &process_info_list_head) {
+		struct process_info *pi = qb_list_entry (iter, struct process_info, list);
 		if (mar_name_compare (&pi->group, &req_lib_cpg_membership_get->group_name) == 0) {
 			res_lib_cpg_membership_get.member_list[member_count].nodeid = pi->nodeid;
 			res_lib_cpg_membership_get.member_list[member_count].pid = pi->pid;
@@ -2212,7 +2163,7 @@ static void message_handler_req_lib_cpg_iteration_initialize (
 	struct cpg_pd *cpd = (struct cpg_pd *)api->ipc_private_data_get (conn);
 	hdb_handle_t cpg_iteration_handle = 0;
 	struct res_lib_cpg_iterationinitialize res_lib_cpg_iterationinitialize;
-	struct list_head *iter, *iter2;
+	struct qb_list_head *iter, *iter2;
 	struct cpg_iteration_instance *cpg_iteration_instance;
 	cs_error_t error = CS_OK;
 	int res;
@@ -2241,14 +2192,14 @@ static void message_handler_req_lib_cpg_iteration_initialize (
 		goto error_destroy;
 	}
 
-	list_init (&cpg_iteration_instance->items_list_head);
+	qb_list_init (&cpg_iteration_instance->items_list_head);
 	cpg_iteration_instance->handle = cpg_iteration_handle;
 
 	/*
 	 * Create copy of process_info list "grouped by" group name
 	 */
-	for (iter = process_info_list_head.next; iter != &process_info_list_head; iter = iter->next) {
-		struct process_info *pi = list_entry (iter, struct process_info, list);
+        qb_list_for_each(iter, &process_info_list_head) {
+		struct process_info *pi = qb_list_entry (iter, struct process_info, list);
 		struct process_info *new_pi;
 
 		if (req_lib_cpg_iterationinitialize->iteration_type == CPG_ITERATION_NAME_ONLY) {
@@ -2257,10 +2208,8 @@ static void message_handler_req_lib_cpg_iteration_initialize (
 			 */
 			int found = 0;
 
-			for (iter2 = cpg_iteration_instance->items_list_head.next;
-			     iter2 != &cpg_iteration_instance->items_list_head;
-			     iter2 = iter2->next) {
-				 struct process_info *pi2 = list_entry (iter2, struct process_info, list);
+                        qb_list_for_each(iter2, &(cpg_iteration_instance->items_list_head)) {
+				 struct process_info *pi2 = qb_list_entry (iter2, struct process_info, list);
 
 				 if (mar_name_compare (&pi2->group, &pi->group) == 0) {
 					found = 1;
@@ -2295,7 +2244,7 @@ static void message_handler_req_lib_cpg_iteration_initialize (
 		}
 
 		memcpy (new_pi, pi, sizeof (struct process_info));
-		list_init (&new_pi->list);
+		qb_list_init (&new_pi->list);
 
 		if (req_lib_cpg_iterationinitialize->iteration_type == CPG_ITERATION_NAME_ONLY) {
 			/*
@@ -2307,17 +2256,15 @@ static void message_handler_req_lib_cpg_iteration_initialize (
 		/*
 		 * We will return list "grouped" by "group name", so try to find right place to add
 		 */
-		for (iter2 = cpg_iteration_instance->items_list_head.next;
-		     iter2 != &cpg_iteration_instance->items_list_head;
-		     iter2 = iter2->next) {
-			 struct process_info *pi2 = list_entry (iter2, struct process_info, list);
+                qb_list_for_each(iter2, &(cpg_iteration_instance->items_list_head)) {
+			 struct process_info *pi2 = qb_list_entry (iter2, struct process_info, list);
 
 			 if (mar_name_compare (&pi2->group, &pi->group) == 0) {
 				break;
 			 }
 		}
 
-		list_add (&new_pi->list, iter2);
+		qb_list_add (&new_pi->list, iter2);
 	}
 
 	/*
@@ -2327,8 +2274,8 @@ static void message_handler_req_lib_cpg_iteration_initialize (
 	/*
 	 * Add instance to current cpd list
 	 */
-	list_init (&cpg_iteration_instance->list);
-	list_add (&cpg_iteration_instance->list, &cpd->iteration_instance_list_head);
+	qb_list_init (&cpg_iteration_instance->list);
+	qb_list_add (&cpg_iteration_instance->list, &cpd->iteration_instance_list_head);
 
 	cpg_iteration_instance->current_pointer = &cpg_iteration_instance->items_list_head;
 
@@ -2380,7 +2327,7 @@ static void message_handler_req_lib_cpg_iteration_next (
 		goto error_put;
 	}
 
-	pi = list_entry (cpg_iteration_instance->current_pointer, struct process_info, list);
+	pi = qb_list_entry (cpg_iteration_instance->current_pointer, struct process_info, list);
 
 	/*
 	 * Copy iteration data

exec/icmap.c

@@ -40,7 +40,7 @@
 #include <corosync/corotypes.h>
 
 #include <qb/qbdefs.h>
-#include <corosync/list.h>
+#include <qb/qblist.h>
 #include <corosync/icmap.h>
 
 #define ICMAP_MAX_VALUE_LEN	(16*1024)
@@ -63,17 +63,17 @@ struct icmap_track {
 	int32_t track_type;
 	icmap_notify_fn_t notify_fn;
 	void *user_data;
-	struct list_head list;
+	struct qb_list_head list;
 };
 
 struct icmap_ro_access_item {
 	char *key_name;
 	int prefix;
-	struct list_head list;
+	struct qb_list_head list;
 };
 
-DECLARE_LIST_INIT(icmap_ro_access_item_list_head);
-DECLARE_LIST_INIT(icmap_track_list_head);
+QB_LIST_DECLARE (icmap_ro_access_item_list_head);
+QB_LIST_DECLARE (icmap_track_list_head);
 
 /*
  * Static functions declarations
@@ -225,27 +225,24 @@ cs_error_t icmap_init(void)
 
 static void icmap_set_ro_access_free(void)
 {
-	struct list_head *iter = icmap_ro_access_item_list_head.next;
+        struct qb_list_head *iter;
 	struct icmap_ro_access_item *icmap_ro_ai;
 
-	while (iter != &icmap_ro_access_item_list_head) {
-		icmap_ro_ai = list_entry(iter, struct icmap_ro_access_item, list);
-		list_del(&icmap_ro_ai->list);
+        qb_list_for_each(iter, &icmap_ro_access_item_list_head) {
+		icmap_ro_ai = qb_list_entry(iter, struct icmap_ro_access_item, list);
+		qb_list_del(&icmap_ro_ai->list);
 		free(icmap_ro_ai->key_name);
-		free(icmap_ro_ai);
-		iter = icmap_ro_access_item_list_head.next;
+                free(icmap_ro_ai);
 	}
 }
 
 static void icmap_del_all_track(void)
 {
-	struct list_head *iter = icmap_track_list_head.next;
+        struct qb_list_head *iter;
 	struct icmap_track *icmap_track;
-
-	while (iter != &icmap_track_list_head) {
-		icmap_track = list_entry(iter, struct icmap_track, list);
-		icmap_track_delete(icmap_track);
-		iter = icmap_track_list_head.next;
+        qb_list_for_each(iter, &icmap_track_list_head) {
+		icmap_track = qb_list_entry(iter, struct icmap_track, list);
+                icmap_track_delete(icmap_track);
 	}
 }
 
@@ -1203,8 +1200,8 @@ cs_error_t icmap_track_add(
 		return (qb_to_cs_error(err));
 	}
 
-	list_init(&(*icmap_track)->list);
-	list_add (&(*icmap_track)->list, &icmap_track_list_head);
+	qb_list_init(&(*icmap_track)->list);
+	qb_list_add (&(*icmap_track)->list, &icmap_track_list_head);
 
 	return (CS_OK);
 }
@@ -1218,7 +1215,7 @@ cs_error_t icmap_track_delete(icmap_track_t icmap_track)
 		return (qb_to_cs_error(err));
 	}
 
-	list_del(&icmap_track->list);
+	qb_list_del(&icmap_track->list);
 	free(icmap_track->key_name);
 	free(icmap_track);
 
@@ -1232,11 +1229,11 @@ void *icmap_track_get_user_data(icmap_track_t icmap_track)
 
 cs_error_t icmap_set_ro_access(const char *key_name, int prefix, int ro_access)
 {
-	struct list_head *iter;
+	struct qb_list_head *iter;
 	struct icmap_ro_access_item *icmap_ro_ai;
 
-	for (iter = icmap_ro_access_item_list_head.next; iter != &icmap_ro_access_item_list_head; iter = iter->next) {
-		icmap_ro_ai = list_entry(iter, struct icmap_ro_access_item, list);
+        qb_list_for_each(iter, &icmap_ro_access_item_list_head) {
+		icmap_ro_ai = qb_list_entry(iter, struct icmap_ro_access_item, list);
 
 		if (icmap_ro_ai->prefix == prefix && strcmp(key_name, icmap_ro_ai->key_name) == 0) {
 			/*
@@ -1245,7 +1242,7 @@ cs_error_t icmap_set_ro_access(const char *key_name, int prefix, int ro_access)
 			if (ro_access) {
 				return (CS_ERR_EXIST);
 			} else {
-				list_del(&icmap_ro_ai->list);
+				qb_list_del(&icmap_ro_ai->list);
 				free(icmap_ro_ai->key_name);
 				free(icmap_ro_ai);
 
@@ -1271,19 +1268,19 @@ cs_error_t icmap_set_ro_access(const char *key_name, int prefix, int ro_access)
 	}
 
 	icmap_ro_ai->prefix = prefix;
-	list_init(&icmap_ro_ai->list);
-	list_add (&icmap_ro_ai->list, &icmap_ro_access_item_list_head);
+	qb_list_init(&icmap_ro_ai->list);
+	qb_list_add (&icmap_ro_ai->list, &icmap_ro_access_item_list_head);
 
 	return (CS_OK);
 }
 
 int icmap_is_key_ro(const char *key_name)
 {
-	struct list_head *iter;
+	struct qb_list_head *iter;
 	struct icmap_ro_access_item *icmap_ro_ai;
 
-	for (iter = icmap_ro_access_item_list_head.next; iter != &icmap_ro_access_item_list_head; iter = iter->next) {
-		icmap_ro_ai = list_entry(iter, struct icmap_ro_access_item, list);
+        qb_list_for_each(iter, &icmap_ro_access_item_list_head) {
+		icmap_ro_ai = qb_list_entry(iter, struct icmap_ro_access_item, list);
 
 		if (icmap_ro_ai->prefix) {
 			if (strlen(icmap_ro_ai->key_name) > strlen(key_name))

exec/ipc_glue.c

@@ -81,7 +81,7 @@ struct cs_ipcs_mapper {
 struct outq_item {
 	void *msg;
 	size_t mlen;
-	struct list_head list;
+	struct qb_list_head list;
 };
 
 static struct cs_ipcs_mapper ipcs_mapper[SERVICES_COUNT_MAX];
@@ -257,7 +257,7 @@ static char * pid_to_name (pid_t pid, char *out_name, size_t name_len)
 
 struct cs_ipcs_conn_context {
 	char *icmap_path;
-	struct list_head outq_head;
+	struct qb_list_head outq_head;
 	int32_t queuing;
 	uint32_t queued;
 	uint64_t invalid_request;
@@ -288,7 +288,7 @@ static void cs_ipcs_connection_created(qb_ipcs_connection_t *c)
 		return;
 	}
 
-	list_init(&context->outq_head);
+	qb_list_init(&context->outq_head);
 	context->queuing = QB_FALSE;
 	context->queued = 0;
 	context->sent = 0;
@@ -392,20 +392,17 @@ void *cs_ipcs_private_data_get(void *conn)
 static void cs_ipcs_connection_destroyed (qb_ipcs_connection_t *c)
 {
 	struct cs_ipcs_conn_context *context;
-	struct list_head *list, *list_next;
+        struct qb_list_head *list;
 	struct outq_item *outq_item;
 
 	log_printf(LOG_DEBUG, "%s() ", __func__);
 
 	context = qb_ipcs_context_get(c);
 	if (context) {
-		for (list = context->outq_head.next;
-			list != &context->outq_head; list = list_next) {
+            qb_list_for_each(list, &(context->outq_head)) {
+			outq_item = qb_list_entry (list, struct outq_item, list);
 
-			list_next = list->next;
-			outq_item = list_entry (list, struct outq_item, list);
-
-			list_del (list);
+			qb_list_del (list);
 			free (outq_item->msg);
 			free (outq_item);
 		}
@@ -469,16 +466,13 @@ int cs_ipcs_response_send(void *conn, const void *msg, size_t mlen)
 static void outq_flush (void *data)
 {
 	qb_ipcs_connection_t *conn = data;
-	struct list_head *list, *list_next;
+        struct qb_list_head *list;
 	struct outq_item *outq_item;
 	int32_t rc;
 	struct cs_ipcs_conn_context *context = qb_ipcs_context_get(conn);
 
-	for (list = context->outq_head.next;
-		list != &context->outq_head; list = list_next) {
-
-		list_next = list->next;
-		outq_item = list_entry (list, struct outq_item, list);
+        qb_list_for_each(list, &(context->outq_head)) {
+		outq_item = qb_list_entry (list, struct outq_item, list);
 
 		rc = qb_ipcs_event_send(conn, outq_item->msg, outq_item->mlen);
 		if (rc < 0 && rc != -EAGAIN) {
@@ -492,11 +486,11 @@ static void outq_flush (void *data)
 		context->sent++;
 		context->queued--;
 
-		list_del (list);
+		qb_list_del (list);
 		free (outq_item->msg);
 		free (outq_item);
 	}
-	if (list_empty (&context->outq_head)) {
+	if (qb_list_empty (&context->outq_head)) {
 		context->queuing = QB_FALSE;
 		log_printf(LOGSYS_LEVEL_INFO, "Q empty, queued:%d sent:%d.",
 			context->queued, context->sent);
@@ -521,7 +515,7 @@ static void msg_send_or_queue(qb_ipcs_connection_t *conn, const struct iovec *io
 	}
 
 	if (!context->queuing) {
-		assert(list_empty (&context->outq_head));
+		assert(qb_list_empty (&context->outq_head));
 		rc = qb_ipcs_event_sendv(conn, iov, iov_len);
 		if (rc == bytes_msg) {
 			context->sent++;
@@ -555,8 +549,8 @@ static void msg_send_or_queue(qb_ipcs_connection_t *conn, const struct iovec *io
 		write_buf += iov[i].iov_len;
 	}
 	outq_item->mlen = bytes_msg;
-	list_init (&outq_item->list);
-	list_add_tail (&outq_item->list, &context->outq_head);
+	qb_list_init (&outq_item->list);
+	qb_list_add_tail (&outq_item->list, &context->outq_head);
 	context->queued++;
 }
 

exec/logconfig.h

@@ -36,7 +36,6 @@
 #define LOGCONFIG_H_DEFINED
 
 #include <corosync/logsys.h>
-#include <corosync/list.h>
 #include <corosync/coroapi.h>
 #include <corosync/cmap.h>
 

exec/logsys.c

@@ -47,7 +47,6 @@
 #include <qb/qbutil.h>
 #include <qb/qblog.h>
 
-#include <corosync/list.h>
 #include <corosync/logsys.h>
 
 /*

exec/main.c

@@ -105,7 +105,6 @@
 #include <corosync/swab.h>
 #include <corosync/corotypes.h>
 #include <corosync/corodefs.h>
-#include <corosync/list.h>
 #include <corosync/totem/totempg.h>
 #include <corosync/logsys.h>
 #include <corosync/icmap.h>

exec/mon.c

@@ -40,7 +40,7 @@
 #include <corosync/corotypes.h>
 #include <corosync/corodefs.h>
 #include <corosync/coroapi.h>
-#include <corosync/list.h>
+#include <qb/qblist.h>
 #include <corosync/logsys.h>
 #include <corosync/icmap.h>
 #include "fsm.h"
@@ -76,7 +76,7 @@ struct corosync_service_engine mon_service_engine = {
 	.exec_dump_fn		= NULL
 };
 
-static DECLARE_LIST_INIT (confchg_notify);
+static QB_LIST_DECLARE (confchg_notify);
 
 
 struct resource_instance {

exec/totemconfig.c

@@ -50,7 +50,7 @@
 #include <sys/param.h>
 
 #include <corosync/swab.h>
-#include <corosync/list.h>
+#include <qb/qblist.h>
 #include <qb/qbdefs.h>
 #include <corosync/totem/totem.h>
 #include <corosync/config.h>
@@ -800,11 +800,11 @@ static void nodelist_dynamic_notify(
  */
 int totem_config_find_local_addr_in_nodelist(const char *ipaddr_key_prefix, unsigned int *node_pos)
 {
-	struct list_head addrs;
+	struct qb_list_head addrs;
 	struct totem_ip_if_address *if_addr;
 	icmap_iter_t iter, iter2;
 	const char *iter_key, *iter_key2;
-	struct list_head *list;
+	struct qb_list_head *list;
 	const char *ipaddr_key;
 	int ip_version;
 	struct totem_ip_address node_addr;
@@ -863,8 +863,8 @@ int totem_config_find_local_addr_in_nodelist(const char *ipaddr_key_prefix, unsi
 			 * Try to match ip with if_addrs
 			 */
 			node_found = 0;
-			for (list = addrs.next; list != &addrs; list = list->next) {
-				if_addr = list_entry(list, struct totem_ip_if_address, list);
+                        qb_list_for_each(list, &(addrs)) {
+				if_addr = qb_list_entry(list, struct totem_ip_if_address, list);
 
 				if (totemip_equal(&node_addr, &if_addr->ip_addr)) {
 					node_found = 1;

exec/totemconfig.h

@@ -37,7 +37,6 @@
 
 #include <netinet/in.h>
 #include <corosync/corotypes.h>
-#include <corosync/list.h>
 #include <qb/qbloop.h>
 #include <corosync/totem/totempg.h>
 

exec/totemip.c

@@ -318,7 +318,7 @@ int totemip_sockaddr_to_totemip_convert(const struct sockaddr_storage *saddr,
 	return ret;
 }
 
-int totemip_getifaddrs(struct list_head *addrs)
+int totemip_getifaddrs(struct qb_list_head *addrs)
 {
 	struct ifaddrs *ifap, *ifa;
 	struct totem_ip_if_address *if_addr;
@@ -326,7 +326,7 @@ int totemip_getifaddrs(struct list_head *addrs)
 	if (getifaddrs(&ifap) != 0)
 		return (-1);
 
-	list_init(addrs);
+	qb_list_init(addrs);
 
 	for (ifa = ifap; ifa; ifa = ifa->ifa_next) {
 		if (ifa->ifa_addr == NULL || ifa->ifa_netmask == NULL)
@@ -346,7 +346,7 @@ int totemip_getifaddrs(struct list_head *addrs)
 			goto error_free_ifaddrs;
 		}
 
-		list_init(&if_addr->list);
+		qb_list_init(&if_addr->list);
 
 		memset(if_addr, 0, sizeof(struct totem_ip_if_address));
 
@@ -367,7 +367,7 @@ int totemip_getifaddrs(struct list_head *addrs)
 			goto error_free_addr_name;
 		}
 
-		list_add_tail(&if_addr->list, addrs);
+		qb_list_add_tail(&if_addr->list, addrs);
 	}
 
 	freeifaddrs(ifap);
@@ -386,20 +386,19 @@ error_free_ifaddrs:
 	return (-1);
 }
 
-void totemip_freeifaddrs(struct list_head *addrs)
+void totemip_freeifaddrs(struct qb_list_head *addrs)
 {
 	struct totem_ip_if_address *if_addr;
-	struct list_head *list;
+	struct qb_list_head *list;
 
-	for (list = addrs->next; list != addrs;) {
-		if_addr = list_entry(list, struct totem_ip_if_address, list);
-		list = list->next;
+        qb_list_for_each(list, addrs) {
+		if_addr = qb_list_entry(list, struct totem_ip_if_address, list);
 
 		free(if_addr->name);
-		list_del(&if_addr->list);
+		qb_list_del(&if_addr->list);
 	        free(if_addr);
 	}
-	list_init(addrs);
+	qb_list_init(addrs);
 }
 
 int totemip_iface_check(struct totem_ip_address *bindnet,
@@ -408,8 +407,8 @@ int totemip_iface_check(struct totem_ip_address *bindnet,
 			int *interface_num,
 			int mask_high_bit)
 {
-	struct list_head addrs;
-	struct list_head *list;
+	struct qb_list_head addrs;
+	struct qb_list_head *list;
 	struct totem_ip_if_address *if_addr;
 	struct totem_ip_address bn_netaddr, if_netaddr;
 	socklen_t addr_len;
@@ -425,8 +424,8 @@ int totemip_iface_check(struct totem_ip_address *bindnet,
 		return (-1);
 	}
 
-	for (list = addrs.next; list != &addrs; list = list->next) {
-		if_addr = list_entry(list, struct totem_ip_if_address, list);
+        qb_list_for_each(list, &addrs) {
+		if_addr = qb_list_entry(list, struct totem_ip_if_address, list);
 
 		if (bindnet->family != if_addr->ip_addr.family)
 			continue ;

exec/totemknet.c

@@ -62,7 +62,6 @@
 #include <qb/qbloop.h>
 
 #include <corosync/sq.h>
-#include <corosync/list.h>
 #include <corosync/swab.h>
 #include <corosync/logsys.h>
 #include <corosync/totem/totemip.h>

exec/totempg.c

@@ -101,7 +101,7 @@
 #include <limits.h>
 
 #include <corosync/swab.h>
-#include <corosync/list.h>
+#include <qb/qblist.h>
 #include <qb/qbloop.h>
 #include <qb/qbipcs.h>
 #include <corosync/totem/totempg.h>
@@ -203,7 +203,7 @@ struct assembly {
 	int index;
 	unsigned char last_frag_num;
 	enum throw_away_mode throw_away_mode;
-	struct list_head list;
+	struct qb_list_head list;
 };
 
 static void assembly_deref (struct assembly *assembly);
@@ -211,16 +211,16 @@ static void assembly_deref (struct assembly *assembly);
 static int callback_token_received_fn (enum totem_callback_token_type type,
 	const void *data);
 
-DECLARE_LIST_INIT(assembly_list_inuse);
+QB_LIST_DECLARE(assembly_list_inuse);
 
 /*
  * Free list is used both for transitional and operational assemblies
  */
-DECLARE_LIST_INIT(assembly_list_free);
+QB_LIST_DECLARE(assembly_list_free);
 
-DECLARE_LIST_INIT(assembly_list_inuse_trans);
+QB_LIST_DECLARE(assembly_list_inuse_trans);
 
-DECLARE_LIST_INIT(totempg_groups_list);
+QB_LIST_DECLARE(totempg_groups_list);
 
 /*
  * Staging buffer for packed messages.  Messages are staged in this buffer
@@ -259,7 +259,7 @@ struct totempg_group_instance {
 	int groups_cnt;
 	int32_t q_level;
 
-	struct list_head list;
+	struct qb_list_head list;
 };
 
 static unsigned char next_fragment = 1;
@@ -291,8 +291,8 @@ static void totempg_waiting_trans_ack_cb (int waiting_trans_ack)
 static struct assembly *assembly_ref (unsigned int nodeid)
 {
 	struct assembly *assembly;
-	struct list_head *list;
-	struct list_head *active_assembly_list_inuse;
+	struct qb_list_head *list;
+	struct qb_list_head *active_assembly_list_inuse;
 
 	if (totempg_waiting_transack) {
 		active_assembly_list_inuse = &assembly_list_inuse_trans;
@@ -303,11 +303,8 @@ static struct assembly *assembly_ref (unsigned int nodeid)
 	/*
 	 * Search inuse list for node id and return assembly buffer if found
 	 */
-	for (list = active_assembly_list_inuse->next;
-		list != active_assembly_list_inuse;
-		list = list->next) {
-
-		assembly = list_entry (list, struct assembly, list);
+        qb_list_for_each(list, active_assembly_list_inuse) {
+		assembly = qb_list_entry (list, struct assembly, list);
 
 		if (nodeid == assembly->nodeid) {
 			return (assembly);
@@ -317,10 +314,10 @@ static struct assembly *assembly_ref (unsigned int nodeid)
 	/*
 	 * Nothing found in inuse list get one from free list if available
 	 */
-	if (list_empty (&assembly_list_free) == 0) {
-		assembly = list_entry (assembly_list_free.next, struct assembly, list);
-		list_del (&assembly->list);
-		list_add (&assembly->list, active_assembly_list_inuse);
+	if (qb_list_empty (&assembly_list_free) == 0) {
+		assembly = qb_list_entry (assembly_list_free.next, struct assembly, list);
+		qb_list_del (&assembly->list);
+		qb_list_add (&assembly->list, active_assembly_list_inuse);
 		assembly->nodeid = nodeid;
 		assembly->index = 0;
 		assembly->last_frag_num = 0;
@@ -341,24 +338,23 @@ static struct assembly *assembly_ref (unsigned int nodeid)
 	assembly->index = 0;
 	assembly->last_frag_num = 0;
 	assembly->throw_away_mode = THROW_AWAY_INACTIVE;
-	list_init (&assembly->list);
-	list_add (&assembly->list, active_assembly_list_inuse);
+	qb_list_init (&assembly->list);
+	qb_list_add (&assembly->list, active_assembly_list_inuse);
 
 	return (assembly);
 }
 
 static void assembly_deref (struct assembly *assembly)
 {
-
-	list_del (&assembly->list);
-	list_add (&assembly->list, &assembly_list_free);
+	qb_list_del (&assembly->list);
+	qb_list_add (&assembly->list, &assembly_list_free);
 }
 
 static void assembly_deref_from_normal_and_trans (int nodeid)
 {
 	int j;
-	struct list_head *list, *list_next;
-	struct list_head *active_assembly_list_inuse;
+        struct qb_list_head *list;
+	struct qb_list_head *active_assembly_list_inuse;
 	struct assembly *assembly;
 
 	for (j = 0; j < 2; j++) {
@@ -368,16 +364,12 @@ static void assembly_deref_from_normal_and_trans (int nodeid)
 			active_assembly_list_inuse = &assembly_list_inuse_trans;
 		}
 
-		for (list = active_assembly_list_inuse->next;
-			list != active_assembly_list_inuse;
-			list = list_next) {
-
-			list_next = list->next;
-			assembly = list_entry (list, struct assembly, list);
+                qb_list_for_each(list, active_assembly_list_inuse) {
+			assembly = qb_list_entry (list, struct assembly, list);
 
 			if (nodeid == assembly->nodeid) {
-				list_del (&assembly->list);
-				list_add (&assembly->list, &assembly_list_free);
+				qb_list_del (&assembly->list);
+				qb_list_add (&assembly->list, &assembly_list_free);
 			}
 		}
 	}
@@ -393,7 +385,7 @@ static inline void app_confchg_fn (
 {
 	int i;
 	struct totempg_group_instance *instance;
-	struct list_head *list;
+	struct qb_list_head *list;
 
 	/*
 	 * For every leaving processor, add to free list
@@ -404,11 +396,8 @@ static inline void app_confchg_fn (
 		assembly_deref_from_normal_and_trans (left_list[i]);
 	}
 
-	for (list = totempg_groups_list.next;
-		list != &totempg_groups_list;
-		list = list->next) {
-
-		instance = list_entry (list, struct totempg_group_instance, list);
+        qb_list_for_each(list, &totempg_groups_list) {
+		instance = qb_list_entry (list, struct totempg_group_instance, list);
 
 		if (instance->confchg_fn) {
 			instance->confchg_fn (
@@ -525,7 +514,7 @@ static inline void app_deliver_fn (
 	struct iovec stripped_iovec;
 	unsigned int adjust_iovec;
 	struct iovec *iovec;
-	struct list_head *list;
+	struct qb_list_head *list;
 
         struct iovec aligned_iovec = { NULL, 0 };
 
@@ -553,11 +542,8 @@ static inline void app_deliver_fn (
 
 	iovec = &aligned_iovec;
 
-	for (list = totempg_groups_list.next;
-		list != &totempg_groups_list;
-		list = list->next) {
-
-		instance = list_entry (list, struct totempg_group_instance, list);
+        qb_list_for_each(list, &totempg_groups_list) {
+		instance = qb_list_entry (list, struct totempg_group_instance, list);
 		if (group_matches (iovec, 1, instance->groups, instance->groups_cnt, &adjust_iovec)) {
 			stripped_iovec.iov_len = iovec->iov_len - adjust_iovec;
 			stripped_iovec.iov_base = (char *)iovec->iov_base + adjust_iovec;
@@ -828,7 +814,7 @@ int totempg_initialize (
 		(totempg_totem_config->net_mtu -
 		sizeof (struct totempg_mcast) - 16);
 
-	list_init (&totempg_groups_list);
+	qb_list_init (&totempg_groups_list);
 
 	return (res);
 }
@@ -1144,8 +1130,8 @@ int totempg_groups_initialize (
 	instance->groups = 0;
 	instance->groups_cnt = 0;
 	instance->q_level = QB_LOOP_MED;
-	list_init (&instance->list);
-	list_add (&instance->list, &totempg_groups_list);
+	qb_list_init (&instance->list);
+	qb_list_add (&instance->list, &totempg_groups_list);
 
 	if (totempg_threaded_mode == 1) {
 		pthread_mutex_unlock (&totempg_mutex);

exec/totemsrp.c

@@ -75,13 +75,13 @@
 #include <sys/uio.h>
 #include <limits.h>
 
+#include <qb/qblist.h>
 #include <qb/qbdefs.h>
 #include <qb/qbutil.h>
 #include <qb/qbloop.h>
 
 #include <corosync/swab.h>
 #include <corosync/sq.h>
-#include <corosync/list.h>
 
 #define LOGSYS_UTILS_ONLY 1
 #include <corosync/logsys.h>
@@ -168,7 +168,7 @@ struct consensus_list_item {
 
 
 struct token_callback_instance {
-	struct list_head list;
+	struct qb_list_head list;
 	int (*callback_fn) (enum totem_callback_token_type type, const void *);
 	enum totem_callback_token_type callback_type;
 	int delete;
@@ -382,9 +382,9 @@ struct totemsrp_instance {
 
 	unsigned int my_high_delivered;
 
-	struct list_head token_callback_received_listhead;
+	struct qb_list_head token_callback_received_listhead;
 
-	struct list_head token_callback_sent_listhead;
+	struct qb_list_head token_callback_sent_listhead;
 
 	char orf_token_retransmit[TOKEN_SIZE_MAX];
 
@@ -712,9 +712,9 @@ static void totemsrp_instance_initialize (struct totemsrp_instance *instance)
 {
 	memset (instance, 0, sizeof (struct totemsrp_instance));
 
-	list_init (&instance->token_callback_received_listhead);
+	qb_list_init (&instance->token_callback_received_listhead);
 
-	list_init (&instance->token_callback_sent_listhead);
+	qb_list_init (&instance->token_callback_sent_listhead);
 
 	instance->my_received_flg = 1;
 
@@ -3405,17 +3405,17 @@ int totemsrp_callback_token_create (
 		return (-1);
 	}
 	*handle_out = (void *)callback_handle;
-	list_init (&callback_handle->list);
+	qb_list_init (&callback_handle->list);
 	callback_handle->callback_fn = callback_fn;
 	callback_handle->data = (void *) data;
 	callback_handle->callback_type = type;
 	callback_handle->delete = delete;
 	switch (type) {
 	case TOTEM_CALLBACK_TOKEN_RECEIVED:
-		list_add (&callback_handle->list, &instance->token_callback_received_listhead);
+		qb_list_add (&callback_handle->list, &instance->token_callback_received_listhead);
 		break;
 	case TOTEM_CALLBACK_TOKEN_SENT:
-		list_add (&callback_handle->list, &instance->token_callback_sent_listhead);
+		qb_list_add (&callback_handle->list, &instance->token_callback_sent_listhead);
 		break;
 	}
 
@@ -3428,7 +3428,7 @@ void totemsrp_callback_token_destroy (void *srp_context, void **handle_out)
 
 	if (*handle_out) {
  		h = (struct token_callback_instance *)*handle_out;
-		list_del (&h->list);
+		qb_list_del (&h->list);
 		free (h);
 		h = NULL;
 		*handle_out = 0;
@@ -3439,9 +3439,8 @@ static void token_callbacks_execute (
 	struct totemsrp_instance *instance,
 	enum totem_callback_token_type type)
 {
-	struct list_head *list;
-	struct list_head *list_next;
-	struct list_head *callback_listhead = 0;
+        struct qb_list_head *list;
+	struct qb_list_head *callback_listhead = 0;
 	struct token_callback_instance *token_callback_instance;
 	int res;
 	int del;
@@ -3457,15 +3456,11 @@ static void token_callbacks_execute (
 		assert (0);
 	}
 
-	for (list = callback_listhead->next; list != callback_listhead;
-		list = list_next) {
-
-		token_callback_instance = list_entry (list, struct token_callback_instance, list);
-
-		list_next = list->next;
+        qb_list_for_each(list, callback_listhead) {
+		token_callback_instance = qb_list_entry (list, struct token_callback_instance, list);
 		del = token_callback_instance->delete;
 		if (del == 1) {
-			list_del (list);
+			qb_list_del (list);
 		}
 
 		res = token_callback_instance->callback_fn (
@@ -3475,7 +3470,7 @@ static void token_callbacks_execute (
 		 * This callback failed to execute, try it again on the next token
 		 */
 		if (res == -1 && del == 1) {
-			list_add (list, callback_listhead);
+			qb_list_add (list, callback_listhead);
 		} else	if (del) {
 			free (token_callback_instance);
 		}

exec/totemudp.c

@@ -61,7 +61,6 @@
 
 #include <corosync/sq.h>
 #include <corosync/swab.h>
-#include <corosync/list.h>
 #include <qb/qbdefs.h>
 #include <qb/qbloop.h>
 #define LOGSYS_UTILS_ONLY 1

exec/totemudpu.c

@@ -58,11 +58,11 @@
 #include <sys/uio.h>
 #include <limits.h>
 
+#include <qb/qblist.h>
 #include <qb/qbdefs.h>
 #include <qb/qbloop.h>
 
 #include <corosync/sq.h>
-#include <corosync/list.h>
 #include <corosync/swab.h>
 #define LOGSYS_UTILS_ONLY 1
 #include <corosync/logsys.h>
@@ -88,7 +88,7 @@
 #define BIND_STATE_LOOPBACK	2
 
 struct totemudpu_member {
-	struct list_head list;
+	struct qb_list_head list;
 	struct totem_ip_address member;
 	int fd;
 	int active;
@@ -147,7 +147,7 @@ struct totemudpu_instance {
 
 	struct iovec totemudpu_iov_recv;
 
-	struct list_head member_list;
+	struct qb_list_head member_list;
 
 	int stats_sent;
 
@@ -225,7 +225,7 @@ static void totemudpu_instance_initialize (struct totemudpu_instance *instance)
 	 */
 	instance->my_memb_entries = 1;
 
-	list_init (&instance->member_list);
+	qb_list_init (&instance->member_list);
 }
 
 #define log_printf(level, format, args...)		\
@@ -319,7 +319,7 @@ static inline void mcast_sendmsg (
 	struct iovec iovec;
 	struct sockaddr_storage sockaddr;
 	int addrlen;
-        struct list_head *list;
+       struct qb_list_head *list;
 	struct totemudpu_member *member;
 
 	iovec.iov_base = (void *)msg;
@@ -329,11 +329,8 @@ static inline void mcast_sendmsg (
 	/*
 	 * Build multicast message
 	 */
-        for (list = instance->member_list.next;
-		list != &instance->member_list;
-		list = list->next) {
-
-                member = list_entry (list,
+        qb_list_for_each(list, &(instance->member_list)) {
+		member = qb_list_entry (list,
 			struct totemudpu_member,
 			list);
 
@@ -1062,8 +1059,8 @@ int totemudpu_member_add (
 
 	log_printf (LOGSYS_LEVEL_NOTICE, "adding new UDPU member {%s}",
 		totemip_print(member));
-	list_init (&new_member->list);
-	list_add_tail (&new_member->list, &instance->member_list);
+	qb_list_init (&new_member->list);
+	qb_list_add_tail (&new_member->list, &instance->member_list);
 	memcpy (&new_member->member, member, sizeof (struct totem_ip_address));
 	new_member->fd = totemudpu_create_sending_socket(udpu_context, member);
 	new_member->active = 1;
@@ -1077,7 +1074,7 @@ int totemudpu_member_remove (
 	int ring_no)
 {
 	int found = 0;
-	struct list_head *list;
+	struct qb_list_head *list;
 	struct totemudpu_member *member;
 
 	struct totemudpu_instance *instance = (struct totemudpu_instance *)udpu_context;
@@ -1085,11 +1082,8 @@ int totemudpu_member_remove (
 	/*
 	 * Find the member to remove and close its socket
 	 */
-	for (list = instance->member_list.next;
-		list != &instance->member_list;
-		list = list->next) {
-
-		member = list_entry (list,
+        qb_list_for_each(list, &(instance->member_list)) {
+		member = qb_list_entry (list,
 			struct totemudpu_member,
 			list);
 
@@ -1115,7 +1109,7 @@ int totemudpu_member_remove (
 	 * Delete the member from the list
 	 */
 	if (found) {
-		list_del (list);
+		qb_list_del (list);
 	}
 
 	instance = NULL;
@@ -1125,16 +1119,13 @@ int totemudpu_member_remove (
 int totemudpu_member_list_rebind_ip (
 	void *udpu_context)
 {
-	struct list_head *list;
+	struct qb_list_head *list;
 	struct totemudpu_member *member;
 
 	struct totemudpu_instance *instance = (struct totemudpu_instance *)udpu_context;
 
-	for (list = instance->member_list.next;
-		list != &instance->member_list;
-		list = list->next) {
-
-		member = list_entry (list,
+        qb_list_for_each(list, &(instance->member_list)) {
+		member = qb_list_entry (list,
 			struct totemudpu_member,
 			list);
 

exec/util.c

@@ -45,7 +45,6 @@
 
 #include <corosync/corotypes.h>
 #include <corosync/corodefs.h>
-#include <corosync/list.h>
 #include <corosync/logsys.h>
 #include "util.h"
 

exec/votequorum.c

@@ -41,11 +41,11 @@
 #include <stdint.h>
 #include <unistd.h>
 
+#include <qb/qblist.h>
 #include <qb/qbipc_common.h>
 
 #include "quorum.h"
 #include <corosync/corodefs.h>
-#include <corosync/list.h>
 #include <corosync/logsys.h>
 #include <corosync/coroapi.h>
 #include <corosync/icmap.h>
@@ -186,7 +186,7 @@ struct cluster_node {
 	uint32_t    votes;
 	uint32_t    expected_votes;
 	uint32_t    flags;
-	struct      list_head list;
+	struct      qb_list_head list;
 };
 
 /*
@@ -201,7 +201,7 @@ static uint8_t cluster_is_quorate;
  */
 
 static struct cluster_node *us;
-static struct list_head cluster_members_list;
+static struct qb_list_head cluster_members_list;
 static unsigned int quorum_members[PROCESSOR_COUNT_MAX];
 static unsigned int previous_quorum_members[PROCESSOR_COUNT_MAX];
 static unsigned int atb_nodelist[PROCESSOR_COUNT_MAX];
@@ -223,11 +223,11 @@ struct quorum_pd {
 	unsigned char track_flags;
 	int tracking_enabled;
 	uint64_t tracking_context;
-	struct list_head list;
+	struct qb_list_head list;
 	void *conn;
 };
 
-static struct list_head trackers_list;
+static struct qb_list_head trackers_list;
 
 /*
  * votequorum timers
@@ -431,26 +431,23 @@ static struct default_service votequorum_service[] = {
 
 #define max(a,b) (((a) > (b)) ? (a) : (b))
 
-#define list_iterate(v, head) \
-	for (v = (head)->next; v != head; v = v->next)
-
 static void node_add_ordered(struct cluster_node *newnode)
 {
 	struct cluster_node *node = NULL;
-	struct list_head *tmp;
-	struct list_head *newlist = &newnode->list;
+	struct qb_list_head *tmp;
+	struct qb_list_head *newlist = &newnode->list;
 
 	ENTER();
 
-	list_iterate(tmp, &cluster_members_list) {
-		node = list_entry(tmp, struct cluster_node, list);
+	qb_list_for_each(tmp, &cluster_members_list) {
+		node = qb_list_entry(tmp, struct cluster_node, list);
 		if (newnode->node_id < node->node_id) {
 			break;
 		}
 	}
 
 	if (!node) {
-		list_add(&newnode->list, &cluster_members_list);
+		qb_list_add(&newnode->list, &cluster_members_list);
 	} else {
 		newlist->prev = tmp->prev;
 		newlist->next = tmp;
@@ -464,7 +461,7 @@ static void node_add_ordered(struct cluster_node *newnode)
 static struct cluster_node *allocate_node(unsigned int nodeid)
 {
 	struct cluster_node *cl = NULL;
-	struct list_head *tmp;
+	struct qb_list_head *tmp;
 
 	ENTER();
 
@@ -472,8 +469,8 @@ static struct cluster_node *allocate_node(unsigned int nodeid)
 		cl = (struct cluster_node *)&cluster_nodes[cluster_nodes_entries];
 		cluster_nodes_entries++;
 	} else {
-		list_iterate(tmp, &cluster_members_list) {
-			cl = list_entry(tmp, struct cluster_node, list);
+		qb_list_for_each(tmp, &cluster_members_list) {
+			cl = qb_list_entry(tmp, struct cluster_node, list);
 			if (cl->state == NODESTATE_DEAD) {
 				break;
 			}
@@ -485,7 +482,7 @@ static struct cluster_node *allocate_node(unsigned int nodeid)
 			log_printf(LOGSYS_LEVEL_CRIT, "Unable to find memory for node %u data!!", nodeid);
 			goto out;
 		}
-		list_del(tmp);
+		qb_list_del(tmp);
 	}
 
 	memset(cl, 0, sizeof(struct cluster_node));
@@ -503,7 +500,7 @@ out:
 static struct cluster_node *find_node_by_nodeid(unsigned int nodeid)
 {
 	struct cluster_node *node;
-	struct list_head *tmp;
+	struct qb_list_head *tmp;
 
 	ENTER();
 
@@ -517,8 +514,8 @@ static struct cluster_node *find_node_by_nodeid(unsigned int nodeid)
 		return qdevice;
 	}
 
-	list_iterate(tmp, &cluster_members_list) {
-		node = list_entry(tmp, struct cluster_node, list);
+	qb_list_for_each(tmp, &cluster_members_list) {
+		node = qb_list_entry(tmp, struct cluster_node, list);
 		if (node->node_id == nodeid) {
 			LEAVE();
 			return node;
@@ -532,14 +529,14 @@ static struct cluster_node *find_node_by_nodeid(unsigned int nodeid)
 static void get_lowest_node_id(void)
 {
 	struct cluster_node *node = NULL;
-	struct list_head *tmp;
+	struct qb_list_head *tmp;
 
 	ENTER();
 
 	lowest_node_id = us->node_id;
 
-	list_iterate(tmp, &cluster_members_list) {
-		node = list_entry(tmp, struct cluster_node, list);
+	qb_list_for_each(tmp, &cluster_members_list) {
+		node = qb_list_entry(tmp, struct cluster_node, list);
 		if ((node->state == NODESTATE_MEMBER) &&
 		    (node->node_id < lowest_node_id)) {
 			lowest_node_id = node->node_id;
@@ -554,14 +551,14 @@ static void get_lowest_node_id(void)
 static void get_highest_node_id(void)
 {
 	struct cluster_node *node = NULL;
-	struct list_head *tmp;
+	struct qb_list_head *tmp;
 
 	ENTER();
 
 	highest_node_id = us->node_id;
 
-	list_iterate(tmp, &cluster_members_list) {
-		node = list_entry(tmp, struct cluster_node, list);
+	qb_list_for_each(tmp, &cluster_members_list) {
+		node = qb_list_entry(tmp, struct cluster_node, list);
 		if ((node->state == NODESTATE_MEMBER) &&
 		    (node->node_id > highest_node_id)) {
 			highest_node_id = node->node_id;
@@ -576,13 +573,13 @@ static void get_highest_node_id(void)
 static int check_low_node_id_partition(void)
 {
 	struct cluster_node *node = NULL;
-	struct list_head *tmp;
+	struct qb_list_head *tmp;
 	int found = 0;
 
 	ENTER();
 
-	list_iterate(tmp, &cluster_members_list) {
-		node = list_entry(tmp, struct cluster_node, list);
+	qb_list_for_each(tmp, &cluster_members_list) {
+		node = qb_list_entry(tmp, struct cluster_node, list);
 		if ((node->state == NODESTATE_MEMBER) &&
 		    (node->node_id == lowest_node_id)) {
 				found = 1;
@@ -596,13 +593,13 @@ static int check_low_node_id_partition(void)
 static int check_high_node_id_partition(void)
 {
 	struct cluster_node *node = NULL;
-	struct list_head *tmp;
+	struct qb_list_head *tmp;
 	int found = 0;
 
 	ENTER();
 
-	list_iterate(tmp, &cluster_members_list) {
-		node = list_entry(tmp, struct cluster_node, list);
+	qb_list_for_each(tmp, &cluster_members_list) {
+		node = qb_list_entry(tmp, struct cluster_node, list);
 		if ((node->state == NODESTATE_MEMBER) &&
 		    (node->node_id == highest_node_id)) {
 				found = 1;
@@ -741,13 +738,13 @@ static void parse_atb_string(char *atb_string)
 static int check_qdevice_master(void)
 {
 	struct cluster_node *node = NULL;
-	struct list_head *tmp;
+	struct qb_list_head *tmp;
 	int found = 0;
 
 	ENTER();
 
-	list_iterate(tmp, &cluster_members_list) {
-		node = list_entry(tmp, struct cluster_node, list);
+	qb_list_for_each(tmp, &cluster_members_list) {
+		node = qb_list_entry(tmp, struct cluster_node, list);
 		if ((node->state == NODESTATE_MEMBER) &&
 		    (node->flags & NODE_FLAGS_QDEVICE_MASTER_WINS) &&
 		    (node->flags & NODE_FLAGS_QDEVICE_CAST_VOTE)) {
@@ -911,7 +908,7 @@ static void update_ev_tracking_barrier(uint32_t ev_t_barrier)
 
 static int calculate_quorum(int allow_decrease, unsigned int max_expected, unsigned int *ret_total_votes)
 {
-	struct list_head *nodelist;
+	struct qb_list_head *nodelist;
 	struct cluster_node *node;
 	unsigned int total_votes = 0;
 	unsigned int highest_expected = 0;
@@ -924,8 +921,8 @@ static int calculate_quorum(int allow_decrease, unsigned int max_expected, unsig
 		max_expected = max(ev_barrier, max_expected);
 	}
 
-	list_iterate(nodelist, &cluster_members_list) {
-		node = list_entry(nodelist, struct cluster_node, list);
+	qb_list_for_each(nodelist, &cluster_members_list) {
+		node = qb_list_entry(nodelist, struct cluster_node, list);
 
 		log_printf(LOGSYS_LEVEL_DEBUG, "node %u state=%d, votes=%u, expected=%u",
 			   node->node_id, node->state, node->votes, node->expected_votes);
@@ -984,12 +981,12 @@ static int calculate_quorum(int allow_decrease, unsigned int max_expected, unsig
 
 static void update_node_expected_votes(int new_expected_votes)
 {
-	struct list_head *nodelist;
+	struct qb_list_head *nodelist;
 	struct cluster_node *node;
 
 	if (new_expected_votes) {
-		list_iterate(nodelist, &cluster_members_list) {
-			node = list_entry(nodelist, struct cluster_node, list);
+		qb_list_for_each(nodelist, &cluster_members_list) {
+			node = qb_list_entry(nodelist, struct cluster_node, list);
 
 			if (node->state == NODESTATE_MEMBER) {
 				node->expected_votes = new_expected_votes;
@@ -1083,13 +1080,13 @@ static void get_total_votes(unsigned int *totalvotes, unsigned int *current_memb
 {
 	unsigned int total_votes = 0;
 	unsigned int cluster_members = 0;
-	struct list_head *nodelist;
+	struct qb_list_head *nodelist;
 	struct cluster_node *node;
 
 	ENTER();
 
-	list_iterate(nodelist, &cluster_members_list) {
-		node = list_entry(nodelist, struct cluster_node, list);
+	qb_list_for_each(nodelist, &cluster_members_list) {
+		node = qb_list_entry(nodelist, struct cluster_node, list);
 		if (node->state == NODESTATE_MEMBER) {
 			cluster_members++;
 			total_votes += node->votes;
@@ -1736,7 +1733,7 @@ static int votequorum_exec_send_qdevice_reg(uint32_t operation, const char *qdev
 static int votequorum_exec_send_quorum_notification(void *conn, uint64_t context)
 {
 	struct res_lib_votequorum_quorum_notification *res_lib_votequorum_notification;
-	struct list_head *tmp;
+	struct qb_list_head *tmp;
 	struct cluster_node *node;
 	int i = 0;
 	int cluster_members = 0;
@@ -1747,8 +1744,8 @@ static int votequorum_exec_send_quorum_notification(void *conn, uint64_t context
 
 	log_printf(LOGSYS_LEVEL_DEBUG, "Sending quorum callback, quorate = %d", cluster_is_quorate);
 
-	list_iterate(tmp, &cluster_members_list) {
-		node = list_entry(tmp, struct cluster_node, list);
+	qb_list_for_each(tmp, &cluster_members_list) {
+		node = qb_list_entry(tmp, struct cluster_node, list);
 		cluster_members++;
         }
 	if (us->flags & NODE_FLAGS_QDEVICE_REGISTERED) {
@@ -1766,8 +1763,8 @@ static int votequorum_exec_send_quorum_notification(void *conn, uint64_t context
 	res_lib_votequorum_notification->header.error = CS_OK;
 
 	/* Send all known nodes and their states */
-	list_iterate(tmp, &cluster_members_list) {
-		node = list_entry(tmp, struct cluster_node, list);
+	qb_list_for_each(tmp, &cluster_members_list) {
+		node = qb_list_entry(tmp, struct cluster_node, list);
 		res_lib_votequorum_notification->node_list[i].nodeid = node->node_id;
 		res_lib_votequorum_notification->node_list[i++].state = node->state;
         }
@@ -1784,8 +1781,8 @@ static int votequorum_exec_send_quorum_notification(void *conn, uint64_t context
 	} else {
 		struct quorum_pd *qpd;
 
-		list_iterate(tmp, &trackers_list) {
-			qpd = list_entry(tmp, struct quorum_pd, list);
+		qb_list_for_each(tmp, &trackers_list) {
+			qpd = qb_list_entry(tmp, struct quorum_pd, list);
 			res_lib_votequorum_notification->context = qpd->tracking_context;
 			corosync_api->ipc_dispatch_send(qpd->conn, &buf, size);
 		}
@@ -1801,7 +1798,7 @@ static int votequorum_exec_send_nodelist_notification(void *conn, uint64_t conte
 	struct res_lib_votequorum_nodelist_notification *res_lib_votequorum_notification;
 	int i = 0;
 	int size;
-	struct list_head *tmp;
+	struct qb_list_head *tmp;
 	char buf[sizeof(struct res_lib_votequorum_nodelist_notification) + sizeof(uint32_t) * quorum_members_entries];
 
 	ENTER();
@@ -1832,8 +1829,8 @@ static int votequorum_exec_send_nodelist_notification(void *conn, uint64_t conte
 	} else {
 		struct quorum_pd *qpd;
 
-		list_iterate(tmp, &trackers_list) {
-			qpd = list_entry(tmp, struct quorum_pd, list);
+		qb_list_for_each(tmp, &trackers_list) {
+			qpd = qb_list_entry(tmp, struct quorum_pd, list);
 			res_lib_votequorum_notification->context = qpd->tracking_context;
 			corosync_api->ipc_dispatch_send(qpd->conn, &buf, size);
 		}
@@ -1848,7 +1845,7 @@ static void votequorum_exec_send_expectedvotes_notification(void)
 {
 	struct res_lib_votequorum_expectedvotes_notification res_lib_votequorum_expectedvotes_notification;
 	struct quorum_pd *qpd;
-	struct list_head *tmp;
+	struct qb_list_head *tmp;
 
 	ENTER();
 
@@ -1859,8 +1856,8 @@ static void votequorum_exec_send_expectedvotes_notification(void)
 	res_lib_votequorum_expectedvotes_notification.header.error = CS_OK;
 	res_lib_votequorum_expectedvotes_notification.expected_votes = us->expected_votes;
 
-	list_iterate(tmp, &trackers_list) {
-		qpd = list_entry(tmp, struct quorum_pd, list);
+	qb_list_for_each(tmp, &trackers_list) {
+		qpd = qb_list_entry(tmp, struct quorum_pd, list);
 		res_lib_votequorum_expectedvotes_notification.context = qpd->tracking_context;
 		corosync_api->ipc_dispatch_send(qpd->conn, &res_lib_votequorum_expectedvotes_notification,
 						sizeof(struct res_lib_votequorum_expectedvotes_notification));
@@ -1922,7 +1919,7 @@ static void message_handler_req_exec_votequorum_qdevice_reg (
 	struct res_lib_votequorum_status res_lib_votequorum_status;
 	int wipe_qdevice_name = 1;
 	struct cluster_node *node = NULL;
-	struct list_head *tmp;
+	struct qb_list_head *tmp;
 	cs_error_t error = CS_OK;
 
 	ENTER();
@@ -1991,8 +1988,8 @@ static void message_handler_req_exec_votequorum_qdevice_reg (
 		qdevice_reg_conn = NULL;
 		break;
 	case VOTEQUORUM_QDEVICE_OPERATION_UNREGISTER:
-		list_iterate(tmp, &cluster_members_list) {
-			node = list_entry(tmp, struct cluster_node, list);
+		qb_list_for_each(tmp, &cluster_members_list) {
+			node = qb_list_entry(tmp, struct cluster_node, list);
 			if ((node->state == NODESTATE_MEMBER) &&
 			    (node->flags & NODE_FLAGS_QDEVICE_REGISTERED)) {
 				wipe_qdevice_name = 0;
@@ -2168,7 +2165,6 @@ static void message_handler_req_exec_votequorum_reconfigure (
 	{
 	case VOTEQUORUM_RECONFIG_PARAM_EXPECTED_VOTES:
 		update_node_expected_votes(req_exec_quorum_reconfigure->value);
-
 		votequorum_exec_send_expectedvotes_notification();
 		update_ev_barrier(req_exec_quorum_reconfigure->value);
 		if (ev_tracking) {
@@ -2244,8 +2240,8 @@ static char *votequorum_exec_init_fn (struct corosync_api_v1 *api)
 	/*
 	 * make sure we start clean
 	 */
-	list_init(&cluster_members_list);
-	list_init(&trackers_list);
+	qb_list_init(&cluster_members_list);
+	qb_list_init(&trackers_list);
 	qdevice = NULL;
 	us = NULL;
 	memset(cluster_nodes, 0, sizeof(cluster_nodes));
@@ -2475,7 +2471,7 @@ static int quorum_lib_init_fn (void *conn)
 
 	ENTER();
 
-	list_init (&pd->list);
+	qb_list_init (&pd->list);
 	pd->conn = conn;
 
 	LEAVE();
@@ -2489,8 +2485,8 @@ static int quorum_lib_exit_fn (void *conn)
 	ENTER();
 
 	if (quorum_pd->tracking_enabled) {
-		list_del (&quorum_pd->list);
-		list_init (&quorum_pd->list);
+		qb_list_del (&quorum_pd->list);
+		qb_list_init (&quorum_pd->list);
 	}
 
 	LEAVE();
@@ -2548,10 +2544,10 @@ static void message_handler_req_lib_votequorum_getinfo (void *conn, const void *
 	node = find_node_by_nodeid(nodeid);
 	if (node) {
 		struct cluster_node *iternode;
-		struct list_head *nodelist;
+		struct qb_list_head *nodelist;
 
-		list_iterate(nodelist, &cluster_members_list) {
-			iternode = list_entry(nodelist, struct cluster_node, list);
+		qb_list_for_each(nodelist, &cluster_members_list) {
+			iternode = qb_list_entry(nodelist, struct cluster_node, list);
 
 			if (iternode->state == NODESTATE_MEMBER) {
 				highest_expected =
@@ -2757,7 +2753,7 @@ static void message_handler_req_lib_votequorum_trackstart (void *conn,
 		quorum_pd->tracking_enabled = 1;
 		quorum_pd->tracking_context = req_lib_votequorum_trackstart->context;
 
-		list_add (&quorum_pd->list, &trackers_list);
+		qb_list_add (&quorum_pd->list, &trackers_list);
 	}
 
 response_send:
@@ -2781,8 +2777,8 @@ static void message_handler_req_lib_votequorum_trackstop (void *conn,
 	if (quorum_pd->tracking_enabled) {
 		error = CS_OK;
 		quorum_pd->tracking_enabled = 0;
-		list_del (&quorum_pd->list);
-		list_init (&quorum_pd->list);
+		qb_list_del (&quorum_pd->list);
+		qb_list_init (&quorum_pd->list);
 	} else {
 		error = CS_ERR_NOT_EXIST;
 	}

exec/votequorum.h

@@ -36,7 +36,6 @@
 
 #include "quorum.h"
 #include <corosync/logsys.h>
-#include <corosync/list.h>
 #include <corosync/coroapi.h>
 
 char *votequorum_init(struct corosync_api_v1 *api,

exec/vsf_quorum.c

@@ -59,7 +59,7 @@
 #include <qb/qbipc_common.h>
 #include <corosync/corodefs.h>
 #include <corosync/swab.h>
-#include <corosync/list.h>
+#include <qb/qblist.h>
 #include <corosync/mar_gen.h>
 #include <corosync/ipc_quorum.h>
 #include <corosync/mar_gen.h>
@@ -76,12 +76,12 @@ LOGSYS_DECLARE_SUBSYS ("QUORUM");
 struct quorum_pd {
 	unsigned char track_flags;
 	int tracking_enabled;
-	struct list_head list;
+	struct qb_list_head list;
 	void *conn;
 };
 
 struct internal_callback_pd {
-	struct list_head list;
+	struct qb_list_head list;
 	quorum_callback_fn_t callback;
 	void *context;
 };
@@ -103,8 +103,8 @@ static int quorum_lib_exit_fn (void *conn);
 static int primary_designated = 0;
 static int quorum_type = 0;
 static struct corosync_api_v1 *corosync_api;
-static struct list_head lib_trackers_list;
-static struct list_head internal_trackers_list;
+static struct qb_list_head lib_trackers_list;
+static struct qb_list_head internal_trackers_list;
 static struct memb_ring_id quorum_ring_id;
 static size_t quorum_view_list_entries = 0;
 static int quorum_view_list[PROCESSOR_COUNT_MAX];
@@ -223,7 +223,7 @@ static int quorum_register_callback(quorum_callback_fn_t function, void *context
 
 	pd->context  = context;
 	pd->callback = function;
-	list_add (&pd->list, &internal_trackers_list);
+	qb_list_add (&pd->list, &internal_trackers_list);
 
 	return 0;
 }
@@ -231,13 +231,12 @@ static int quorum_register_callback(quorum_callback_fn_t function, void *context
 static int quorum_unregister_callback(quorum_callback_fn_t function, void *context)
 {
 	struct internal_callback_pd *pd;
-	struct list_head *tmp;
+	struct qb_list_head *tmp;
 
-	for (tmp = internal_trackers_list.next; tmp != &internal_trackers_list; tmp = tmp->next) {
-
-		pd = list_entry(tmp, struct internal_callback_pd, list);
+        qb_list_for_each(tmp, &internal_trackers_list) {
+		pd = qb_list_entry(tmp, struct internal_callback_pd, list);
 		if (pd->callback == function && pd->context == context) {
-			list_del(&pd->list);
+			qb_list_del(&pd->list);
 			free(pd);
 			return 0;
 		}
@@ -259,8 +258,8 @@ static char *quorum_exec_init_fn (struct corosync_api_v1 *api)
 	char *error;
 
 	corosync_api = api;
-	list_init (&lib_trackers_list);
-	list_init (&internal_trackers_list);
+	qb_list_init (&lib_trackers_list);
+	qb_list_init (&internal_trackers_list);
 
 	/*
 	 * Tell corosync we have a quorum engine.
@@ -316,7 +315,7 @@ static int quorum_lib_init_fn (void *conn)
 
 	log_printf(LOGSYS_LEVEL_DEBUG, "lib_init_fn: conn=%p", conn);
 
-	list_init (&pd->list);
+	qb_list_init (&pd->list);
 	pd->conn = conn;
 
 	return (0);
@@ -329,8 +328,8 @@ static int quorum_lib_exit_fn (void *conn)
 	log_printf(LOGSYS_LEVEL_DEBUG, "lib_exit_fn: conn=%p", conn);
 
 	if (quorum_pd->tracking_enabled) {
-		list_del (&quorum_pd->list);
-		list_init (&quorum_pd->list);
+		qb_list_del (&quorum_pd->list);
+		qb_list_init (&quorum_pd->list);
 	}
 	return (0);
 }
@@ -338,12 +337,10 @@ static int quorum_lib_exit_fn (void *conn)
 
 static void send_internal_notification(void)
 {
-	struct list_head *tmp;
+	struct qb_list_head *tmp;
 	struct internal_callback_pd *pd;
-
-	for (tmp = internal_trackers_list.next; tmp != &internal_trackers_list; tmp = tmp->next) {
-
-		pd = list_entry(tmp, struct internal_callback_pd, list);
+        qb_list_for_each(tmp, &internal_trackers_list) {
+		pd = qb_list_entry(tmp, struct internal_callback_pd, list);
 
 		pd->callback(primary_designated, pd->context);
 	}
@@ -354,7 +351,7 @@ static void send_library_notification(void *conn)
 	int size = sizeof(struct res_lib_quorum_notification) + sizeof(unsigned int)*quorum_view_list_entries;
 	char buf[size];
 	struct res_lib_quorum_notification *res_lib_quorum_notification = (struct res_lib_quorum_notification *)buf;
-	struct list_head *tmp;
+	struct qb_list_head *tmp;
 	int i;
 
 	log_printf(LOGSYS_LEVEL_DEBUG, "sending quorum notification to %p, length = %d", conn, size);
@@ -377,9 +374,8 @@ static void send_library_notification(void *conn)
 	else {
 		struct quorum_pd *qpd;
 
-		for (tmp = lib_trackers_list.next; tmp != &lib_trackers_list; tmp = tmp->next) {
-
-			qpd = list_entry(tmp, struct quorum_pd, list);
+                qb_list_for_each(tmp, &lib_trackers_list) {
+			qpd = qb_list_entry(tmp, struct quorum_pd, list);
 
 			corosync_api->ipc_dispatch_send(qpd->conn,
 			     res_lib_quorum_notification, size);
@@ -437,7 +433,7 @@ static void message_handler_req_lib_quorum_trackstart (void *conn,
 		quorum_pd->track_flags = req_lib_quorum_trackstart->track_flags;
 		quorum_pd->tracking_enabled = 1;
 
-		list_add (&quorum_pd->list, &lib_trackers_list);
+		qb_list_add (&quorum_pd->list, &lib_trackers_list);
 	}
 
 response_send:
@@ -458,8 +454,8 @@ static void message_handler_req_lib_quorum_trackstop (void *conn, const void *ms
 	if (quorum_pd->tracking_enabled) {
 		res.error = CS_OK;
 		quorum_pd->tracking_enabled = 0;
-		list_del (&quorum_pd->list);
-		list_init (&quorum_pd->list);
+		qb_list_del (&quorum_pd->list);
+		qb_list_init (&quorum_pd->list);
 	} else {
 		res.error = CS_ERR_NOT_EXIST;
 	}

exec/vsf_ykd.h

@@ -36,7 +36,6 @@
 
 #include "quorum.h"
 #include <corosync/logsys.h>
-#include <corosync/list.h>
 #include <corosync/coroapi.h>
 
 char *ykd_init(struct corosync_api_v1 *api,

exec/wd.c

@@ -44,7 +44,7 @@
 #include <corosync/corotypes.h>
 #include <corosync/corodefs.h>
 #include <corosync/coroapi.h>
-#include <corosync/list.h>
+#include <qb/qblist.h>
 #include <corosync/logsys.h>
 #include <corosync/icmap.h>
 #include "fsm.h"
@@ -109,7 +109,7 @@ struct corosync_service_engine wd_service_engine = {
 	.exec_dump_fn		= NULL
 };
 
-static DECLARE_LIST_INIT (confchg_notify);
+static QB_LIST_DECLARE (confchg_notify);
 
 /*
  * F S M

include/Makefile.am

@@ -36,7 +36,7 @@ CS_H			= hdb.h cpg.h cfg.h corodefs.h \
 
 CS_INTERNAL_H		= ipc_cfg.h ipc_cpg.h ipc_quorum.h 	\
 			quorum.h sq.h ipc_votequorum.h ipc_cmap.h \
-			logsys.h coroapi.h icmap.h mar_gen.h list.h swab.h
+			logsys.h coroapi.h icmap.h mar_gen.h swab.h
 
 TOTEM_H			= totem.h totemip.h totempg.h
 

include/corosync/totem/totemip.h

@@ -41,7 +41,7 @@
 #include <sys/socket.h>
 #include <netinet/in.h>
 #include <stdint.h>
-#include <corosync/list.h>
+#include <qb/qblist.h>
 
 #ifdef __cplusplus
 extern "C" {
@@ -74,7 +74,7 @@ struct totem_ip_if_address
 	int interface_up;
 	int interface_num;
 	char *name;
-	struct list_head list;
+	struct qb_list_head list;
 };
 
 extern int totemip_equal(const struct totem_ip_address *addr1,
@@ -100,9 +100,9 @@ extern int totemip_iface_check(struct totem_ip_address *bindnet,
 			       int *interface_num,
 			       int mask_high_bit);
 
-extern int totemip_getifaddrs(struct list_head *addrs);
+extern int totemip_getifaddrs(struct qb_list_head *addrs);
 
-extern void totemip_freeifaddrs(struct list_head *addrs);
+extern void totemip_freeifaddrs(struct qb_list_head *addrs);
 
 /* These two simulate a zero in_addr by clearing the family field */
 static inline void totemip_zero_set(struct totem_ip_address *addr)

lib/cmap.c

@@ -45,7 +45,6 @@
 #include <corosync/corotypes.h>
 #include <corosync/corodefs.h>
 #include <corosync/hdb.h>
-#include <corosync/list.h>
 #include <qb/qbipcc.h>
 
 #include <corosync/cmap.h>

lib/cpg.c

@@ -52,12 +52,12 @@
 #include <errno.h>
 #include <limits.h>
 
+#include <qb/qblist.h>
 #include <qb/qbdefs.h>
 #include <qb/qbipcc.h>
 #include <qb/qblog.h>
 
 #include <corosync/hdb.h>
-#include <corosync/list.h>
 #include <corosync/corotypes.h>
 #include <corosync/corodefs.h>
 #include <corosync/cpg.h>
@@ -88,7 +88,7 @@ struct cpg_inst {
 		cpg_model_data_t model_data;
 		cpg_model_v1_data_t model_v1_data;
 	};
-	struct list_head iteration_list_head;
+	struct qb_list_head iteration_list_head;
     uint32_t max_msg_size;
     char *assembly_buf;
     uint32_t assembly_buf_ptr;
@@ -106,7 +106,7 @@ struct cpg_iteration_instance_t {
 	cpg_iteration_handle_t cpg_iteration_handle;
 	qb_ipcc_connection_t *conn;
 	hdb_handle_t executive_iteration_handle;
-	struct list_head list;
+	struct qb_list_head list;
 };
 
 DECLARE_HDB_DATABASE(cpg_iteration_handle_t_db,NULL);
@@ -130,7 +130,7 @@ coroipcc_msg_send_reply_receive (
 
 static void cpg_iteration_instance_finalize (struct cpg_iteration_instance_t *cpg_iteration_instance)
 {
-	list_del (&cpg_iteration_instance->list);
+	qb_list_del (&cpg_iteration_instance->list);
 	hdb_handle_destroy (&cpg_iteration_handle_t_db, cpg_iteration_instance->cpg_iteration_handle);
 }
 
@@ -142,16 +142,14 @@ static void cpg_inst_free (void *inst)
 
 static void cpg_inst_finalize (struct cpg_inst *cpg_inst, hdb_handle_t handle)
 {
-	struct list_head *iter, *iter_next;
+        struct qb_list_head *iter;
 	struct cpg_iteration_instance_t *cpg_iteration_instance;
 
 	/*
 	 * Traverse thru iteration instances and delete them
 	 */
-	for (iter = cpg_inst->iteration_list_head.next;	iter != &cpg_inst->iteration_list_head;iter = iter_next) {
-		iter_next = iter->next;
-
-		cpg_iteration_instance = list_entry (iter, struct cpg_iteration_instance_t, list);
+        qb_list_for_each(iter, &(cpg_inst->iteration_list_head)) {
+		cpg_iteration_instance = qb_list_entry (iter, struct cpg_iteration_instance_t, list);
 
 		cpg_iteration_instance_finalize (cpg_iteration_instance);
 	}
@@ -229,7 +227,7 @@ cs_error_t cpg_model_initialize (
 	cpg_inst->model_data.model = model;
 	cpg_inst->context = context;
 
-	list_init(&cpg_inst->iteration_list_head);
+	qb_list_init(&cpg_inst->iteration_list_head);
 
 	hdb_handle_put (&cpg_handle_t_db, *handle);
 
@@ -1232,7 +1230,7 @@ cs_error_t cpg_iteration_initialize(
 
 	cpg_iteration_instance->conn = cpg_inst->c;
 
-	list_init (&cpg_iteration_instance->list);
+	qb_list_init (&cpg_iteration_instance->list);
 
 	req_lib_cpg_iterationinitialize.header.size = sizeof (struct req_lib_cpg_iterationinitialize);
 	req_lib_cpg_iterationinitialize.header.id = MESSAGE_REQ_CPG_ITERATIONINITIALIZE;
@@ -1258,7 +1256,7 @@ cs_error_t cpg_iteration_initialize(
 		res_lib_cpg_iterationinitialize.iteration_handle;
 	cpg_iteration_instance->cpg_iteration_handle = *cpg_iteration_handle;
 
-	list_add (&cpg_iteration_instance->list, &cpg_inst->iteration_list_head);
+	qb_list_add (&cpg_iteration_instance->list, &cpg_inst->iteration_list_head);
 
 	hdb_handle_put (&cpg_iteration_handle_t_db, *cpg_iteration_handle);
 	hdb_handle_put (&cpg_handle_t_db, handle);