diff --git a/src/applet.c b/src/applet.c
index 47f30c4..0e550c2 100644
--- a/src/applet.c
+++ b/src/applet.c
@@ -38,7 +38,7 @@
 	if (!applets_active_queue)
 		return;
 
-	SPIN_LOCK(APPLETS_LOCK, &applet_active_lock);
+	HA_SPIN_LOCK(APPLETS_LOCK, &applet_active_lock);
 
 	curr = LIST_NEXT(&applet_active_queue, typeof(curr), runq);
 	while (&curr->runq != &applet_active_queue) {
@@ -52,7 +52,7 @@
 		curr = next;
 	}
 
-	SPIN_UNLOCK(APPLETS_LOCK, &applet_active_lock);
+	HA_SPIN_UNLOCK(APPLETS_LOCK, &applet_active_lock);
 
 	/* The list is only scanned from the head. This guarantees that if any
 	 * applet removes another one, there is no side effect while walking
@@ -84,7 +84,7 @@
 			/* curr was left in the list, move it back to the active list */
 			LIST_DEL(&curr->runq);
 			LIST_INIT(&curr->runq);
-			SPIN_LOCK(APPLETS_LOCK, &applet_active_lock);
+			HA_SPIN_LOCK(APPLETS_LOCK, &applet_active_lock);
 			if (curr->state & APPLET_WANT_DIE) {
 				curr->state = APPLET_SLEEPING;
 				__appctx_free(curr);
@@ -98,7 +98,7 @@
 					curr->state = APPLET_SLEEPING;
 				}
 			}
-			SPIN_UNLOCK(APPLETS_LOCK, &applet_active_lock);
+			HA_SPIN_UNLOCK(APPLETS_LOCK, &applet_active_lock);
 		}
 	}
 }
@@ -106,5 +106,5 @@
 __attribute__((constructor))
 static void __applet_init(void)
 {
-	SPIN_INIT(&applet_active_lock);
+	HA_SPIN_INIT(&applet_active_lock);
 }
diff --git a/src/buffer.c b/src/buffer.c
index db2e053..b365888 100644
--- a/src/buffer.c
+++ b/src/buffer.c
@@ -75,7 +75,7 @@
 	if (global.tune.buf_limit)
 		pool2_buffer->limit = global.tune.buf_limit;
 
-	SPIN_INIT(&buffer_wq_lock);
+	HA_SPIN_INIT(&buffer_wq_lock);
 
 	buffer = pool_refill_alloc(pool2_buffer, pool2_buffer->minavail - 1);
 	if (!buffer)
diff --git a/src/cfgparse.c b/src/cfgparse.c
index 4414f59..b42dd54 100644
--- a/src/cfgparse.c
+++ b/src/cfgparse.c
@@ -2108,7 +2108,7 @@
 		newpeer->proto = proto;
 		newpeer->xprt  = xprt_get(XPRT_RAW);
 		newpeer->sock_init_arg = NULL;
-		SPIN_INIT(&newpeer->lock);
+		HA_SPIN_INIT(&newpeer->lock);
 
 		if (strcmp(newpeer->id, localpeer) == 0) {
 			/* Current is local peer, it define a frontend */
@@ -2251,7 +2251,7 @@
 		LIST_INIT(&curr_resolvers->nameservers);
 		LIST_INIT(&curr_resolvers->resolutions.curr);
 		LIST_INIT(&curr_resolvers->resolutions.wait);
-		SPIN_INIT(&curr_resolvers->lock);
+		HA_SPIN_INIT(&curr_resolvers->lock);
 	}
 	else if (strcmp(args[0], "nameserver") == 0) { /* nameserver definition */
 		struct sockaddr_storage *sk;
@@ -8505,7 +8505,7 @@
 			}
 			break;
 		}
-		SPIN_INIT(&curproxy->lbprm.lock);
+		HA_SPIN_INIT(&curproxy->lbprm.lock);
 
 		if (curproxy->options & PR_O_LOGASAP)
 			curproxy->to_log &= ~LW_BYTES;
diff --git a/src/checks.c b/src/checks.c
index f669f8a..8d5822a 100644
--- a/src/checks.c
+++ b/src/checks.c
@@ -715,7 +715,7 @@
 	struct server *s = check->server;
 	struct task *t = check->task;
 
-	SPIN_LOCK(SERVER_LOCK, &check->server->lock);
+	HA_SPIN_LOCK(SERVER_LOCK, &check->server->lock);
 	if (unlikely(check->result == CHK_RES_FAILED))
 		goto out_wakeup;
 
@@ -768,7 +768,7 @@
  out_nowake:
 	__cs_stop_send(cs);   /* nothing more to write */
  out_unlock:
-	SPIN_UNLOCK(SERVER_LOCK, &check->server->lock);
+	HA_SPIN_UNLOCK(SERVER_LOCK, &check->server->lock);
 }
 
 /*
@@ -798,7 +798,7 @@
 	int done;
 	unsigned short msglen;
 
-	SPIN_LOCK(SERVER_LOCK, &check->server->lock);
+	HA_SPIN_LOCK(SERVER_LOCK, &check->server->lock);
 
 	if (unlikely(check->result == CHK_RES_FAILED))
 		goto out_wakeup;
@@ -1354,7 +1354,7 @@
 
 	task_wakeup(t, TASK_WOKEN_IO);
  out_unlock:
-	SPIN_UNLOCK(SERVER_LOCK, &check->server->lock);
+	HA_SPIN_UNLOCK(SERVER_LOCK, &check->server->lock);
 	return;
 
  wait_more_data:
@@ -1374,7 +1374,7 @@
 	struct check *check = cs->data;
 	int ret = 0;
 
-	SPIN_LOCK(SERVER_LOCK, &check->server->lock);
+	HA_SPIN_LOCK(SERVER_LOCK, &check->server->lock);
 
 	/* we may have to make progress on the TCP checks */
 	if (check->type == PR_O2_TCPCHK_CHK) {
@@ -1411,7 +1411,7 @@
 		ret = -1;
 	}
 
-	SPIN_UNLOCK(SERVER_LOCK, &check->server->lock);
+	HA_SPIN_UNLOCK(SERVER_LOCK, &check->server->lock);
 
 	/* if a connection got replaced, we must absolutely prevent the connection
 	 * handler from touching its fd, and perform the FD polling updates ourselves
@@ -1647,9 +1647,9 @@
 	check->curpid = elem;
 	LIST_INIT(&elem->list);
 
-	SPIN_LOCK(PID_LIST_LOCK, &pid_list_lock);
+	HA_SPIN_LOCK(PID_LIST_LOCK, &pid_list_lock);
 	LIST_ADD(&pid_list, &elem->list);
-	SPIN_UNLOCK(PID_LIST_LOCK, &pid_list_lock);
+	HA_SPIN_UNLOCK(PID_LIST_LOCK, &pid_list_lock);
 
 	return elem;
 }
@@ -1661,9 +1661,9 @@
 	if (!elem)
 		return;
 
-	SPIN_LOCK(PID_LIST_LOCK, &pid_list_lock);
+	HA_SPIN_LOCK(PID_LIST_LOCK, &pid_list_lock);
 	LIST_DEL(&elem->list);
-	SPIN_UNLOCK(PID_LIST_LOCK, &pid_list_lock);
+	HA_SPIN_UNLOCK(PID_LIST_LOCK, &pid_list_lock);
 
 	if (!elem->exited)
 		kill(elem->pid, SIGTERM);
@@ -1678,7 +1678,7 @@
 {
 	struct pid_list *elem;
 
-	SPIN_LOCK(PID_LIST_LOCK, &pid_list_lock);
+	HA_SPIN_LOCK(PID_LIST_LOCK, &pid_list_lock);
 	list_for_each_entry(elem, &pid_list, list) {
 		if (elem->pid == pid) {
 			elem->t->expire = now_ms;
@@ -1688,7 +1688,7 @@
 			break;
 		}
 	}
-	SPIN_UNLOCK(PID_LIST_LOCK, &pid_list_lock);
+	HA_SPIN_UNLOCK(PID_LIST_LOCK, &pid_list_lock);
 }
 
 static void sigchld_handler(struct sig_handler *sh)
@@ -1719,7 +1719,7 @@
 		return 1;
 	}
 
-	SPIN_INIT(&pid_list_lock);
+	HA_SPIN_INIT(&pid_list_lock);
 
 	return 0;
 }
@@ -1979,7 +1979,7 @@
 	int ret;
 	int expired = tick_is_expired(t->expire, now_ms);
 
-	SPIN_LOCK(SERVER_LOCK, &check->server->lock);
+	HA_SPIN_LOCK(SERVER_LOCK, &check->server->lock);
 	if (!(check->state & CHK_ST_INPROGRESS)) {
 		/* no check currently running */
 		if (!expired) /* woke up too early */
@@ -2092,7 +2092,7 @@
 		t->expire = tick_add(t->expire, MS_TO_TICKS(check->inter));
 
  out_unlock:
-	SPIN_UNLOCK(SERVER_LOCK, &check->server->lock);
+	HA_SPIN_UNLOCK(SERVER_LOCK, &check->server->lock);
 	return t;
 }
 
@@ -2113,7 +2113,7 @@
 	int ret;
 	int expired = tick_is_expired(t->expire, now_ms);
 
-	SPIN_LOCK(SERVER_LOCK, &check->server->lock);
+	HA_SPIN_LOCK(SERVER_LOCK, &check->server->lock);
 	if (!(check->state & CHK_ST_INPROGRESS)) {
 		/* no check currently running */
 		if (!expired) /* woke up too early */
@@ -2268,7 +2268,7 @@
 	while (tick_is_expired(t->expire, now_ms))
 		t->expire = tick_add(t->expire, MS_TO_TICKS(check->inter));
  out_unlock:
-	SPIN_UNLOCK(SERVER_LOCK, &check->server->lock);
+	HA_SPIN_UNLOCK(SERVER_LOCK, &check->server->lock);
 	return t;
 }
 
@@ -2597,7 +2597,7 @@
 	struct list *head = check->tcpcheck_rules;
 	int retcode = 0;
 
-	SPIN_LOCK(SERVER_LOCK, &check->server->lock);
+	HA_SPIN_LOCK(SERVER_LOCK, &check->server->lock);
 
 	/* here, we know that the check is complete or that it failed */
 	if (check->result != CHK_RES_UNKNOWN)
@@ -3077,7 +3077,7 @@
 	__cs_stop_both(cs);
 
  out_unlock:
-	SPIN_UNLOCK(SERVER_LOCK, &check->server->lock);
+	HA_SPIN_UNLOCK(SERVER_LOCK, &check->server->lock);
 	return retcode;
 }
 
@@ -3137,7 +3137,7 @@
 
 	q = container_of(check, typeof(*q), check);
 
-	SPIN_LOCK(EMAIL_ALERTS_LOCK, &q->lock);
+	HA_SPIN_LOCK(EMAIL_ALERTS_LOCK, &q->lock);
 	while (1) {
 		if (!(check->state & CHK_ST_ENABLED)) {
 			if (LIST_ISEMPTY(&q->email_alerts)) {
@@ -3167,7 +3167,7 @@
 		check->state         &= ~CHK_ST_ENABLED;
 	}
   end:
-	SPIN_UNLOCK(EMAIL_ALERTS_LOCK, &q->lock);
+	HA_SPIN_UNLOCK(EMAIL_ALERTS_LOCK, &q->lock);
 	return t;
 }
 
@@ -3194,7 +3194,7 @@
 		struct task         *t;
 
 		LIST_INIT(&q->email_alerts);
-		SPIN_INIT(&q->lock);
+		HA_SPIN_INIT(&q->lock);
 		check->inter = mls->timeout.mail;
 		check->rise = DEF_AGENT_RISETIME;
 		check->fall = DEF_AGENT_FALLTIME;
@@ -3398,10 +3398,10 @@
 	if (!add_tcpcheck_expect_str(&alert->tcpcheck_rules, "221 "))
 		goto error;
 
-	SPIN_LOCK(EMAIL_ALERTS_LOCK, &q->lock);
+	HA_SPIN_LOCK(EMAIL_ALERTS_LOCK, &q->lock);
 	task_wakeup(check->task, TASK_WOKEN_MSG);
 	LIST_ADDQ(&q->email_alerts, &alert->list);
-	SPIN_UNLOCK(EMAIL_ALERTS_LOCK, &q->lock);
+	HA_SPIN_UNLOCK(EMAIL_ALERTS_LOCK, &q->lock);
 	return 1;
 
 error:
diff --git a/src/compression.c b/src/compression.c
index ead9934..d476da5 100644
--- a/src/compression.c
+++ b/src/compression.c
@@ -160,10 +160,10 @@
 #endif
 
 	if (unlikely(pool_comp_ctx == NULL)) {
-		SPIN_LOCK(COMP_POOL_LOCK, &comp_pool_lock);
+		HA_SPIN_LOCK(COMP_POOL_LOCK, &comp_pool_lock);
 		if (unlikely(pool_comp_ctx == NULL))
 			pool_comp_ctx = create_pool("comp_ctx", sizeof(struct comp_ctx), MEM_F_SHARED);
-		SPIN_UNLOCK(COMP_POOL_LOCK, &comp_pool_lock);
+		HA_SPIN_UNLOCK(COMP_POOL_LOCK, &comp_pool_lock);
 	}
 
 	*comp_ctx = pool_alloc2(pool_comp_ctx);
@@ -412,10 +412,10 @@
 	switch (round) {
 		case 0:
 			if (zlib_pool_deflate_state == NULL) {
-				SPIN_LOCK(COMP_POOL_LOCK, &comp_pool_lock);
+				HA_SPIN_LOCK(COMP_POOL_LOCK, &comp_pool_lock);
 				if (zlib_pool_deflate_state == NULL)
 					zlib_pool_deflate_state = create_pool("zlib_state", size * items, MEM_F_SHARED);
-				SPIN_UNLOCK(COMP_POOL_LOCK, &comp_pool_lock);
+				HA_SPIN_UNLOCK(COMP_POOL_LOCK, &comp_pool_lock);
 			}
 			pool = zlib_pool_deflate_state;
 			ctx->zlib_deflate_state = buf = pool_alloc2(pool);
@@ -423,10 +423,10 @@
 
 		case 1:
 			if (zlib_pool_window == NULL) {
-				SPIN_LOCK(COMP_POOL_LOCK, &comp_pool_lock);
+				HA_SPIN_LOCK(COMP_POOL_LOCK, &comp_pool_lock);
 				if (zlib_pool_window == NULL)
 					zlib_pool_window = create_pool("zlib_window", size * items, MEM_F_SHARED);
-				SPIN_UNLOCK(COMP_POOL_LOCK, &comp_pool_lock);
+				HA_SPIN_UNLOCK(COMP_POOL_LOCK, &comp_pool_lock);
 			}
 			pool = zlib_pool_window;
 			ctx->zlib_window = buf = pool_alloc2(pool);
@@ -434,10 +434,10 @@
 
 		case 2:
 			if (zlib_pool_prev == NULL) {
-				SPIN_LOCK(COMP_POOL_LOCK, &comp_pool_lock);
+				HA_SPIN_LOCK(COMP_POOL_LOCK, &comp_pool_lock);
 				if (zlib_pool_prev == NULL)
 					zlib_pool_prev = create_pool("zlib_prev", size * items, MEM_F_SHARED);
-				SPIN_UNLOCK(COMP_POOL_LOCK, &comp_pool_lock);
+				HA_SPIN_UNLOCK(COMP_POOL_LOCK, &comp_pool_lock);
 			}
 			pool = zlib_pool_prev;
 			ctx->zlib_prev = buf = pool_alloc2(pool);
@@ -445,10 +445,10 @@
 
 		case 3:
 			if (zlib_pool_head == NULL) {
-				SPIN_LOCK(COMP_POOL_LOCK, &comp_pool_lock);
+				HA_SPIN_LOCK(COMP_POOL_LOCK, &comp_pool_lock);
 				if (zlib_pool_head == NULL)
 					zlib_pool_head = create_pool("zlib_head", size * items, MEM_F_SHARED);
-				SPIN_UNLOCK(COMP_POOL_LOCK, &comp_pool_lock);
+				HA_SPIN_UNLOCK(COMP_POOL_LOCK, &comp_pool_lock);
 			}
 			pool = zlib_pool_head;
 			ctx->zlib_head = buf = pool_alloc2(pool);
@@ -456,10 +456,10 @@
 
 		case 4:
 			if (zlib_pool_pending_buf == NULL) {
-				SPIN_LOCK(COMP_POOL_LOCK, &comp_pool_lock);
+				HA_SPIN_LOCK(COMP_POOL_LOCK, &comp_pool_lock);
 				if (zlib_pool_pending_buf == NULL)
 					zlib_pool_pending_buf = create_pool("zlib_pending_buf", size * items, MEM_F_SHARED);
-				SPIN_UNLOCK(COMP_POOL_LOCK, &comp_pool_lock);
+				HA_SPIN_UNLOCK(COMP_POOL_LOCK, &comp_pool_lock);
 			}
 			pool = zlib_pool_pending_buf;
 			ctx->zlib_pending_buf = buf = pool_alloc2(pool);
@@ -721,7 +721,7 @@
 	global.tune.maxzlibmem = DEFAULT_MAXZLIBMEM * 1024U * 1024U,
 #endif
 #ifdef USE_ZLIB
-	SPIN_INIT(&comp_pool_lock);
+	HA_SPIN_INIT(&comp_pool_lock);
 	memprintf(&ptr, "Built with zlib version : " ZLIB_VERSION);
 	memprintf(&ptr, "%s\nRunning on zlib version : %s", ptr, zlibVersion());
 #elif defined(USE_SLZ)
diff --git a/src/dns.c b/src/dns.c
index 0f93f3c..8f01f05 100644
--- a/src/dns.c
+++ b/src/dns.c
@@ -486,7 +486,7 @@
 
 				/* Remove any associated server */
 				for (srv = srvrq->proxy->srv; srv != NULL; srv = srv->next) {
-					SPIN_LOCK(SERVER_LOCK, &srv->lock);
+					HA_SPIN_LOCK(SERVER_LOCK, &srv->lock);
 					if (srv->srvrq == srvrq && srv->svc_port == item->port &&
 					    item->data_len == srv->hostname_dn_len &&
 					    !memcmp(srv->hostname_dn, item->target, item->data_len)) {
@@ -498,7 +498,7 @@
 						srv->hostname_dn_len = 0;
 						dns_unlink_resolution(srv->dns_requester);
 					}
-					SPIN_UNLOCK(SERVER_LOCK, &srv->lock);
+					HA_SPIN_UNLOCK(SERVER_LOCK, &srv->lock);
 				}
 			}
 
@@ -518,7 +518,7 @@
 
 			/* Check if a server already uses that hostname */
 			for (srv = srvrq->proxy->srv; srv != NULL; srv = srv->next) {
-				SPIN_LOCK(SERVER_LOCK, &srv->lock);
+				HA_SPIN_LOCK(SERVER_LOCK, &srv->lock);
 				if (srv->srvrq == srvrq && srv->svc_port == item->port &&
 				    item->data_len == srv->hostname_dn_len &&
 				    !memcmp(srv->hostname_dn, item->target, item->data_len)) {
@@ -528,20 +528,20 @@
 						snprintf(weight, sizeof(weight), "%d", item->weight);
 						server_parse_weight_change_request(srv, weight);
 					}
-					SPIN_UNLOCK(SERVER_LOCK, &srv->lock);
+					HA_SPIN_UNLOCK(SERVER_LOCK, &srv->lock);
 					break;
 				}
-				SPIN_UNLOCK(SERVER_LOCK, &srv->lock);
+				HA_SPIN_UNLOCK(SERVER_LOCK, &srv->lock);
 			}
 			if (srv)
 				continue;
 
 			/* If not, try to find a server with undefined hostname */
 			for (srv = srvrq->proxy->srv; srv != NULL; srv = srv->next) {
-				SPIN_LOCK(SERVER_LOCK, &srv->lock);
+				HA_SPIN_LOCK(SERVER_LOCK, &srv->lock);
 				if (srv->srvrq == srvrq && !srv->hostname_dn)
 					break;
-				SPIN_UNLOCK(SERVER_LOCK, &srv->lock);
+				HA_SPIN_UNLOCK(SERVER_LOCK, &srv->lock);
 			}
 			/* And update this server, if found */
 			if (srv) {
@@ -551,7 +551,7 @@
 
 				if (dns_dn_label_to_str(item->target, item->data_len+1,
 							hostname, DNS_MAX_NAME_SIZE) == -1) {
-					SPIN_UNLOCK(SERVER_LOCK, &srv->lock);
+					HA_SPIN_UNLOCK(SERVER_LOCK, &srv->lock);
 					continue;
 				}
 				msg = update_server_fqdn(srv, hostname, "SRV record", 1);
@@ -565,7 +565,7 @@
 					srv->check.port = item->port;
 				snprintf(weight, sizeof(weight), "%d", item->weight);
 				server_parse_weight_change_request(srv, weight);
-				SPIN_UNLOCK(SERVER_LOCK, &srv->lock);
+				HA_SPIN_UNLOCK(SERVER_LOCK, &srv->lock);
 			}
 		}
 	}
@@ -1348,11 +1348,11 @@
 
 	if (srv) {
 		if (!requester_locked)
-			SPIN_LOCK(SERVER_LOCK, &srv->lock);
+			HA_SPIN_LOCK(SERVER_LOCK, &srv->lock);
 		if (srv->dns_requester == NULL) {
 			if ((req = calloc(1, sizeof(*req))) == NULL) {
 				if (!requester_locked)
-					SPIN_UNLOCK(SERVER_LOCK, &srv->lock);
+					HA_SPIN_UNLOCK(SERVER_LOCK, &srv->lock);
 				goto err;
 			}
 			req->owner         = &srv->obj_type;
@@ -1361,7 +1361,7 @@
 		else
 			req = srv->dns_requester;
 		if (!requester_locked)
-			SPIN_UNLOCK(SERVER_LOCK, &srv->lock);
+			HA_SPIN_UNLOCK(SERVER_LOCK, &srv->lock);
 	}
 	else if (srvrq) {
 		if (srvrq->dns_requester == NULL) {
@@ -1463,7 +1463,7 @@
 		return;
 
 	resolvers = ns->resolvers;
-	SPIN_LOCK(DNS_LOCK, &resolvers->lock);
+	HA_SPIN_LOCK(DNS_LOCK, &resolvers->lock);
 
 	/* process all pending input messages */
 	while (1) {
@@ -1617,10 +1617,10 @@
 			struct server *s = objt_server(req->owner);
 
 			if (s)
-				SPIN_LOCK(SERVER_LOCK, &s->lock);
+				HA_SPIN_LOCK(SERVER_LOCK, &s->lock);
 			req->requester_cb(req, tmpns);
 			if (s)
-				SPIN_UNLOCK(SERVER_LOCK, &s->lock);
+				HA_SPIN_UNLOCK(SERVER_LOCK, &s->lock);
 			tmpns = NULL;
 		}
 
@@ -1630,7 +1630,7 @@
 		continue;
 	}
 	dns_update_resolvers_timeout(resolvers);
-	SPIN_UNLOCK(DNS_LOCK, &resolvers->lock);
+	HA_SPIN_UNLOCK(DNS_LOCK, &resolvers->lock);
 }
 
 /* Called when a resolvers network socket is ready to send data */
@@ -1655,7 +1655,7 @@
 		return;
 
 	resolvers = ns->resolvers;
-	SPIN_LOCK(DNS_LOCK, &resolvers->lock);
+	HA_SPIN_LOCK(DNS_LOCK, &resolvers->lock);
 
 	list_for_each_entry(res, &resolvers->resolutions.curr, list) {
 		int ret;
@@ -1682,7 +1682,7 @@
 		ns->counters.snd_error++;
 		res->nb_queries++;
 	}
-	SPIN_UNLOCK(DNS_LOCK, &resolvers->lock);
+	HA_SPIN_UNLOCK(DNS_LOCK, &resolvers->lock);
 }
 
 /* Processes DNS resolution. First, it checks the active list to detect expired
@@ -1695,7 +1695,7 @@
 	struct dns_resolution *res, *resback;
 	int exp;
 
-	SPIN_LOCK(DNS_LOCK, &resolvers->lock);
+	HA_SPIN_LOCK(DNS_LOCK, &resolvers->lock);
 
 	/* Handle all expired resolutions from the active list */
 	list_for_each_entry_safe(res, resback, &resolvers->resolutions.curr, list) {
@@ -1765,7 +1765,7 @@
 	}
 
 	dns_update_resolvers_timeout(resolvers);
-	SPIN_UNLOCK(DNS_LOCK, &resolvers->lock);
+	HA_SPIN_UNLOCK(DNS_LOCK, &resolvers->lock);
 	return t;
 }
 
diff --git a/src/ev_epoll.c b/src/ev_epoll.c
index 65e5164..602a243 100644
--- a/src/ev_epoll.c
+++ b/src/ev_epoll.c
@@ -71,14 +71,14 @@
 		if (!fdtab[fd].owner)
 			continue;
 
-		SPIN_LOCK(FD_LOCK, &fdtab[fd].lock);
+		HA_SPIN_LOCK(FD_LOCK, &fdtab[fd].lock);
 		fdtab[fd].updated = 0;
 		fdtab[fd].new = 0;
 
 		eo = fdtab[fd].state;
 		en = fd_compute_new_polled_status(eo);
 		fdtab[fd].state = en;
-		SPIN_UNLOCK(FD_LOCK, &fdtab[fd].lock);
+		HA_SPIN_UNLOCK(FD_LOCK, &fdtab[fd].lock);
 
 		if ((eo ^ en) & FD_EV_POLLED_RW) {
 			/* poll status changed */
diff --git a/src/ev_kqueue.c b/src/ev_kqueue.c
index 00dc965..b61fe65 100644
--- a/src/ev_kqueue.c
+++ b/src/ev_kqueue.c
@@ -50,14 +50,14 @@
 		if (!fdtab[fd].owner)
 			continue;
 
-		SPIN_LOCK(FD_LOCK, &fdtab[fd].lock);
+		HA_SPIN_LOCK(FD_LOCK, &fdtab[fd].lock);
 		fdtab[fd].updated = 0;
 		fdtab[fd].new = 0;
 
 		eo = fdtab[fd].state;
 		en = fd_compute_new_polled_status(eo);
 		fdtab[fd].state = en;
-		SPIN_UNLOCK(FD_LOCK, &fdtab[fd].lock);
+		HA_SPIN_UNLOCK(FD_LOCK, &fdtab[fd].lock);
 
 		if ((eo ^ en) & FD_EV_POLLED_RW) {
 			/* poll status changed */
diff --git a/src/ev_poll.c b/src/ev_poll.c
index edeffa8..f9e4451 100644
--- a/src/ev_poll.c
+++ b/src/ev_poll.c
@@ -50,10 +50,10 @@
 
 REGPRM1 static void __fd_clo(int fd)
 {
-	SPIN_LOCK(POLL_LOCK, &poll_lock);
+	HA_SPIN_LOCK(POLL_LOCK, &poll_lock);
 	hap_fd_clr(fd, fd_evts[DIR_RD]);
 	hap_fd_clr(fd, fd_evts[DIR_WR]);
-	SPIN_UNLOCK(POLL_LOCK, &poll_lock);
+	HA_SPIN_UNLOCK(POLL_LOCK, &poll_lock);
 }
 
 /*
@@ -76,18 +76,18 @@
 		if (!fdtab[fd].owner)
 			continue;
 
-		SPIN_LOCK(FD_LOCK, &fdtab[fd].lock);
+		HA_SPIN_LOCK(FD_LOCK, &fdtab[fd].lock);
 		fdtab[fd].updated = 0;
 		fdtab[fd].new = 0;
 
 		eo = fdtab[fd].state;
 		en = fd_compute_new_polled_status(eo);
 		fdtab[fd].state = en;
-		SPIN_UNLOCK(FD_LOCK, &fdtab[fd].lock);
+		HA_SPIN_UNLOCK(FD_LOCK, &fdtab[fd].lock);
 
 		if ((eo ^ en) & FD_EV_POLLED_RW) {
 			/* poll status changed, update the lists */
-			SPIN_LOCK(POLL_LOCK, &poll_lock);
+			HA_SPIN_LOCK(POLL_LOCK, &poll_lock);
 			if ((eo & ~en) & FD_EV_POLLED_R)
 				hap_fd_clr(fd, fd_evts[DIR_RD]);
 			else if ((en & ~eo) & FD_EV_POLLED_R)
@@ -97,7 +97,7 @@
 				hap_fd_clr(fd, fd_evts[DIR_WR]);
 			else if ((en & ~eo) & FD_EV_POLLED_W)
 				hap_fd_set(fd, fd_evts[DIR_WR]);
-			SPIN_UNLOCK(POLL_LOCK, &poll_lock);
+			HA_SPIN_UNLOCK(POLL_LOCK, &poll_lock);
 		}
 	}
 	fd_nbupdt = 0;
diff --git a/src/ev_select.c b/src/ev_select.c
index 5dad408..b2b4e50 100644
--- a/src/ev_select.c
+++ b/src/ev_select.c
@@ -31,10 +31,10 @@
 /* Immediately remove the entry upon close() */
 REGPRM1 static void __fd_clo(int fd)
 {
-	SPIN_LOCK(POLL_LOCK, &poll_lock);
+	HA_SPIN_LOCK(POLL_LOCK, &poll_lock);
 	FD_CLR(fd, fd_evts[DIR_RD]);
 	FD_CLR(fd, fd_evts[DIR_WR]);
-	SPIN_UNLOCK(POLL_LOCK, &poll_lock);
+	HA_SPIN_UNLOCK(POLL_LOCK, &poll_lock);
 }
 
 /*
@@ -58,18 +58,18 @@
 		if (!fdtab[fd].owner)
 			continue;
 
-		SPIN_LOCK(FD_LOCK, &fdtab[fd].lock);
+		HA_SPIN_LOCK(FD_LOCK, &fdtab[fd].lock);
 		fdtab[fd].updated = 0;
 		fdtab[fd].new = 0;
 
 		eo = fdtab[fd].state;
 		en = fd_compute_new_polled_status(eo);
 		fdtab[fd].state = en;
-		SPIN_UNLOCK(FD_LOCK, &fdtab[fd].lock);
+		HA_SPIN_UNLOCK(FD_LOCK, &fdtab[fd].lock);
 
 		if ((eo ^ en) & FD_EV_POLLED_RW) {
 			/* poll status changed, update the lists */
-			SPIN_LOCK(POLL_LOCK, &poll_lock);
+			HA_SPIN_LOCK(POLL_LOCK, &poll_lock);
 			if ((eo & ~en) & FD_EV_POLLED_R)
 				FD_CLR(fd, fd_evts[DIR_RD]);
 			else if ((en & ~eo) & FD_EV_POLLED_R)
@@ -79,7 +79,7 @@
 				FD_CLR(fd, fd_evts[DIR_WR]);
 			else if ((en & ~eo) & FD_EV_POLLED_W)
 				FD_SET(fd, fd_evts[DIR_WR]);
-			SPIN_UNLOCK(POLL_LOCK, &poll_lock);
+			HA_SPIN_UNLOCK(POLL_LOCK, &poll_lock);
 		}
 	}
 	fd_nbupdt = 0;
diff --git a/src/fd.c b/src/fd.c
index e8419aa..d2e9569 100644
--- a/src/fd.c
+++ b/src/fd.c
@@ -185,7 +185,7 @@
  */
 static void fd_dodelete(int fd, int do_close)
 {
-	SPIN_LOCK(FD_LOCK, &fdtab[fd].lock);
+	HA_SPIN_LOCK(FD_LOCK, &fdtab[fd].lock);
 	if (fdtab[fd].linger_risk) {
 		/* this is generally set when connecting to servers */
 		setsockopt(fd, SOL_SOCKET, SO_LINGER,
@@ -205,12 +205,12 @@
 	fdtab[fd].thread_mask = 0;
 	if (do_close)
 		close(fd);
-	SPIN_UNLOCK(FD_LOCK, &fdtab[fd].lock);
+	HA_SPIN_UNLOCK(FD_LOCK, &fdtab[fd].lock);
 
-	SPIN_LOCK(FDTAB_LOCK, &fdtab_lock);
+	HA_SPIN_LOCK(FDTAB_LOCK, &fdtab_lock);
 	while ((maxfd-1 >= 0) && !fdtab[maxfd-1].owner)
 		maxfd--;
-	SPIN_UNLOCK(FDTAB_LOCK, &fdtab_lock);
+	HA_SPIN_UNLOCK(FDTAB_LOCK, &fdtab_lock);
 }
 
 /* Deletes an FD from the fdsets, and recomputes the maxfd limit.
@@ -241,16 +241,16 @@
 	if (!fd_cache_num)
 		return;
 
-	RWLOCK_RDLOCK(FDCACHE_LOCK, &fdcache_lock);
+	HA_RWLOCK_RDLOCK(FDCACHE_LOCK, &fdcache_lock);
 	for (entry = 0; entry < fd_cache_num; ) {
 		fd = fd_cache[entry];
 
 		if (!(fdtab[fd].thread_mask & tid_bit))
 			goto next;
-		if (SPIN_TRYLOCK(FD_LOCK, &fdtab[fd].lock))
+		if (HA_SPIN_TRYLOCK(FD_LOCK, &fdtab[fd].lock))
 			goto next;
 
-		RWLOCK_RDUNLOCK(FDCACHE_LOCK, &fdcache_lock);
+		HA_RWLOCK_RDUNLOCK(FDCACHE_LOCK, &fdcache_lock);
 
 		e = fdtab[fd].state;
 		fdtab[fd].ev &= FD_POLL_STICKY;
@@ -262,15 +262,15 @@
 			fdtab[fd].ev |= FD_POLL_OUT;
 
 		if (fdtab[fd].iocb && fdtab[fd].owner && fdtab[fd].ev) {
-			SPIN_UNLOCK(FD_LOCK, &fdtab[fd].lock);
+			HA_SPIN_UNLOCK(FD_LOCK, &fdtab[fd].lock);
 			fdtab[fd].iocb(fd);
 		}
 		else {
 			fd_release_cache_entry(fd);
-			SPIN_UNLOCK(FD_LOCK, &fdtab[fd].lock);
+			HA_SPIN_UNLOCK(FD_LOCK, &fdtab[fd].lock);
 		}
 
-		RWLOCK_RDLOCK(FDCACHE_LOCK, &fdcache_lock);
+		HA_RWLOCK_RDLOCK(FDCACHE_LOCK, &fdcache_lock);
 		/* If the fd was removed from the cache, it has been
 		 * replaced by the next one that we don't want to skip !
 		 */
@@ -279,7 +279,7 @@
 	  next:
 		entry++;
 	}
-	RWLOCK_RDUNLOCK(FDCACHE_LOCK, &fdcache_lock);
+	HA_RWLOCK_RDUNLOCK(FDCACHE_LOCK, &fdcache_lock);
 }
 
 /* disable the specified poller */
@@ -329,11 +329,11 @@
 	hap_register_per_thread_deinit(deinit_pollers_per_thread);
 
 	for (p = 0; p < global.maxsock; p++)
-		SPIN_INIT(&fdtab[p].lock);
+		HA_SPIN_INIT(&fdtab[p].lock);
 
-	SPIN_INIT(&fdtab_lock);
-	RWLOCK_INIT(&fdcache_lock);
-	SPIN_INIT(&poll_lock);
+	HA_SPIN_INIT(&fdtab_lock);
+	HA_RWLOCK_INIT(&fdcache_lock);
+	HA_SPIN_INIT(&poll_lock);
 	do {
 		bp = NULL;
 		for (p = 0; p < nbpollers; p++)
@@ -367,7 +367,7 @@
 	int p;
 
 	for (p = 0; p < global.maxsock; p++)
-		SPIN_DESTROY(&fdtab[p].lock);
+		HA_SPIN_DESTROY(&fdtab[p].lock);
 
 	for (p = 0; p < nbpollers; p++) {
 		bp = &pollers[p];
@@ -380,9 +380,9 @@
 	free(fdinfo);   fdinfo   = NULL;
 	free(fdtab);    fdtab    = NULL;
 
-	SPIN_DESTROY(&fdtab_lock);
-	RWLOCK_DESTROY(&fdcache_lock);
-	SPIN_DESTROY(&poll_lock);
+	HA_SPIN_DESTROY(&fdtab_lock);
+	HA_RWLOCK_DESTROY(&fdcache_lock);
+	HA_SPIN_DESTROY(&poll_lock);
 }
 
 /*
diff --git a/src/flt_spoe.c b/src/flt_spoe.c
index cdb6238..5a8c9e6 100644
--- a/src/flt_spoe.c
+++ b/src/flt_spoe.c
@@ -171,7 +171,7 @@
 		spoe_release_group(grp);
 	}
 	for (i = 0; i < global.nbthread; ++i)
-		SPIN_DESTROY(&agent->rt[i].lock);
+		HA_SPIN_DESTROY(&agent->rt[i].lock);
 	free(agent->rt);
 	free(agent);
 }
@@ -1426,10 +1426,10 @@
 			 * add the applet in the list of running applets. */
 			agent->rt[tid].applets_idle++;
 			appctx->st0 = SPOE_APPCTX_ST_IDLE;
-			SPIN_LOCK(SPOE_APPLET_LOCK, &agent->rt[tid].lock);
+			HA_SPIN_LOCK(SPOE_APPLET_LOCK, &agent->rt[tid].lock);
 			LIST_DEL(&SPOE_APPCTX(appctx)->list);
 			LIST_ADD(&agent->rt[tid].applets, &SPOE_APPCTX(appctx)->list);
-			SPIN_UNLOCK(SPOE_APPLET_LOCK, &agent->rt[tid].lock);
+			HA_SPIN_UNLOCK(SPOE_APPLET_LOCK, &agent->rt[tid].lock);
 
 			/* Update runtinme agent info */
 			HA_ATOMIC_UPDATE_MIN(&agent->rt[tid].frame_size, SPOE_APPCTX(appctx)->max_frame_size);
@@ -1710,10 +1710,10 @@
 		agent->rt[tid].applets_idle++;
 	}
 	if (fpa || (SPOE_APPCTX(appctx)->flags & SPOE_APPCTX_FL_PERSIST)) {
-		SPIN_LOCK(SPOE_APPLET_LOCK, &agent->rt[tid].lock);
+		HA_SPIN_LOCK(SPOE_APPLET_LOCK, &agent->rt[tid].lock);
 		LIST_DEL(&SPOE_APPCTX(appctx)->list);
 		LIST_ADD(&agent->rt[tid].applets, &SPOE_APPCTX(appctx)->list);
-		SPIN_UNLOCK(SPOE_APPLET_LOCK, &agent->rt[tid].lock);
+		HA_SPIN_UNLOCK(SPOE_APPLET_LOCK, &agent->rt[tid].lock);
 		if (fpa)
 			SPOE_APPCTX(appctx)->task->expire =
 				tick_add_ifset(now_ms, agent->timeout.idle);
@@ -1985,9 +1985,9 @@
 	strm->do_log = NULL;
 	strm->res.flags |= CF_READ_DONTWAIT;
 
-	SPIN_LOCK(SPOE_APPLET_LOCK, &conf->agent->rt[tid].lock);
+	HA_SPIN_LOCK(SPOE_APPLET_LOCK, &conf->agent->rt[tid].lock);
 	LIST_ADDQ(&conf->agent->rt[tid].applets, &SPOE_APPCTX(appctx)->list);
-	SPIN_UNLOCK(SPOE_APPLET_LOCK, &conf->agent->rt[tid].lock);
+	HA_SPIN_UNLOCK(SPOE_APPLET_LOCK, &conf->agent->rt[tid].lock);
 	conf->agent->rt[tid].applets_act++;
 
 	task_wakeup(SPOE_APPCTX(appctx)->task, TASK_WOKEN_INIT);
@@ -2096,10 +2096,10 @@
 		appctx = spoe_appctx->owner;
 		if (appctx->st0 == SPOE_APPCTX_ST_IDLE) {
 			spoe_wakeup_appctx(appctx);
-			SPIN_LOCK(SPOE_APPLET_LOCK, &agent->rt[tid].lock);
+			HA_SPIN_LOCK(SPOE_APPLET_LOCK, &agent->rt[tid].lock);
 			LIST_DEL(&spoe_appctx->list);
 			LIST_ADDQ(&agent->rt[tid].applets, &spoe_appctx->list);
-			SPIN_UNLOCK(SPOE_APPLET_LOCK, &agent->rt[tid].lock);
+			HA_SPIN_UNLOCK(SPOE_APPLET_LOCK, &agent->rt[tid].lock);
 			break;
 		}
 	}
@@ -2699,18 +2699,18 @@
 		return 1;
 
 	if (!LIST_ISEMPTY(&buffer_wait->list)) {
-		SPIN_LOCK(BUF_WQ_LOCK, &buffer_wq_lock);
+		HA_SPIN_LOCK(BUF_WQ_LOCK, &buffer_wq_lock);
 		LIST_DEL(&buffer_wait->list);
 		LIST_INIT(&buffer_wait->list);
-		SPIN_UNLOCK(BUF_WQ_LOCK, &buffer_wq_lock);
+		HA_SPIN_UNLOCK(BUF_WQ_LOCK, &buffer_wq_lock);
 	}
 
 	if (b_alloc_margin(buf, global.tune.reserved_bufs))
 		return 1;
 
-	SPIN_LOCK(BUF_WQ_LOCK, &buffer_wq_lock);
+	HA_SPIN_LOCK(BUF_WQ_LOCK, &buffer_wq_lock);
 	LIST_ADDQ(&buffer_wq, &buffer_wait->list);
-	SPIN_UNLOCK(BUF_WQ_LOCK, &buffer_wq_lock);
+	HA_SPIN_UNLOCK(BUF_WQ_LOCK, &buffer_wq_lock);
 	return 0;
 }
 
@@ -2718,10 +2718,10 @@
 spoe_release_buffer(struct buffer **buf, struct buffer_wait *buffer_wait)
 {
 	if (!LIST_ISEMPTY(&buffer_wait->list)) {
-		SPIN_LOCK(BUF_WQ_LOCK, &buffer_wq_lock);
+		HA_SPIN_LOCK(BUF_WQ_LOCK, &buffer_wq_lock);
 		LIST_DEL(&buffer_wait->list);
 		LIST_INIT(&buffer_wait->list);
-		SPIN_UNLOCK(BUF_WQ_LOCK, &buffer_wq_lock);
+		HA_SPIN_UNLOCK(BUF_WQ_LOCK, &buffer_wq_lock);
 	}
 
 	/* Release the buffer if needed */
@@ -2813,10 +2813,10 @@
 			agent = conf->agent;
 
 			for (i = 0; i < global.nbthread; ++i) {
-				SPIN_LOCK(SPOE_APPLET_LOCK, &agent->rt[i].lock);
+				HA_SPIN_LOCK(SPOE_APPLET_LOCK, &agent->rt[i].lock);
 				list_for_each_entry(spoe_appctx, &agent->rt[i].applets, list)
 					spoe_wakeup_appctx(spoe_appctx->owner);
-				SPIN_UNLOCK(SPOE_APPLET_LOCK, &agent->rt[i].lock);
+				HA_SPIN_UNLOCK(SPOE_APPLET_LOCK, &agent->rt[i].lock);
 			}
 		}
 		p = p->next;
@@ -3221,7 +3221,7 @@
 			LIST_INIT(&curagent->rt[i].applets);
 			LIST_INIT(&curagent->rt[i].sending_queue);
 			LIST_INIT(&curagent->rt[i].waiting_queue);
-			SPIN_INIT(&curagent->rt[i].lock);
+			HA_SPIN_INIT(&curagent->rt[i].lock);
 		}
 	}
 	else if (!strcmp(args[0], "use-backend")) {
diff --git a/src/haproxy.c b/src/haproxy.c
index 4d4bd3b..8993b89 100644
--- a/src/haproxy.c
+++ b/src/haproxy.c
@@ -2075,7 +2075,7 @@
 				if (xprt_get(XPRT_SSL) && xprt_get(XPRT_SSL)->destroy_srv)
 					xprt_get(XPRT_SSL)->destroy_srv(s);
 			}
-			SPIN_DESTROY(&s->lock);
+			HA_SPIN_DESTROY(&s->lock);
 			free(s);
 			s = s_next;
 		}/* end while(s) */
@@ -2124,8 +2124,8 @@
 
 		p0 = p;
 		p = p->next;
-		SPIN_DESTROY(&p0->lbprm.lock);
-		SPIN_DESTROY(&p0->lock);
+		HA_SPIN_DESTROY(&p0->lbprm.lock);
+		HA_SPIN_DESTROY(&p0->lock);
 		free(p0);
 	}/* end while(p) */
 
diff --git a/src/hathreads.c b/src/hathreads.c
index 36bdca2..2856a9f 100644
--- a/src/hathreads.c
+++ b/src/hathreads.c
@@ -120,7 +120,7 @@
 
 	thread_sync_barrier(&barrier);
 	if (threads_want_sync & tid_bit)
-		SPIN_LOCK(THREAD_SYNC_LOCK, &sync_lock);
+		HA_SPIN_LOCK(THREAD_SYNC_LOCK, &sync_lock);
 }
 
 /* Exit from the sync point and unlock it if it was previously locked. If the
@@ -135,7 +135,7 @@
 		return;
 
 	if (threads_want_sync & tid_bit)
-		SPIN_UNLOCK(THREAD_SYNC_LOCK, &sync_lock);
+		HA_SPIN_UNLOCK(THREAD_SYNC_LOCK, &sync_lock);
 
 	if (HA_ATOMIC_AND(&threads_want_sync, ~tid_bit) == 0) {
 		char c;
@@ -151,7 +151,7 @@
 __attribute__((constructor))
 static void __hathreads_init(void)
 {
-	SPIN_INIT(&sync_lock);
+	HA_SPIN_INIT(&sync_lock);
 #if defined(DEBUG_THREAD) || defined(DEBUG_FULL)
 	memset(lock_stats, 0, sizeof(lock_stats));
 #endif
diff --git a/src/hlua.c b/src/hlua.c
index 761fa7f..439bbf4 100644
--- a/src/hlua.c
+++ b/src/hlua.c
@@ -125,11 +125,11 @@
 #define SET_SAFE_LJMP(__L) \
 	({ \
 		int ret; \
-		SPIN_LOCK(LUA_LOCK, &hlua_global_lock); \
+		HA_SPIN_LOCK(LUA_LOCK, &hlua_global_lock); \
 		if (setjmp(safe_ljmp_env) != 0) { \
 			lua_atpanic(__L, hlua_panic_safe); \
 			ret = 0; \
-			SPIN_UNLOCK(LUA_LOCK, &hlua_global_lock); \
+			HA_SPIN_UNLOCK(LUA_LOCK, &hlua_global_lock); \
 		} else { \
 			lua_atpanic(__L, hlua_panic_ljmp); \
 			ret = 1; \
@@ -143,7 +143,7 @@
 #define RESET_SAFE_LJMP(__L) \
 	do { \
 		lua_atpanic(__L, hlua_panic_safe); \
-		SPIN_UNLOCK(LUA_LOCK, &hlua_global_lock); \
+		HA_SPIN_UNLOCK(LUA_LOCK, &hlua_global_lock); \
 	} while(0)
 
 /* Applet status flags */
@@ -994,7 +994,7 @@
 	/* Lock the whole Lua execution. This lock must be before the
 	 * label "resume_execution".
 	 */
-	SPIN_LOCK(LUA_LOCK, &hlua_global_lock);
+	HA_SPIN_LOCK(LUA_LOCK, &hlua_global_lock);
 
 resume_execution:
 
@@ -1154,7 +1154,7 @@
 	}
 
 	/* This is the main exit point, remove the Lua lock. */
-	SPIN_UNLOCK(LUA_LOCK, &hlua_global_lock);
+	HA_SPIN_UNLOCK(LUA_LOCK, &hlua_global_lock);
 
 	return ret;
 }
@@ -7370,7 +7370,7 @@
 	};
 #endif
 
-	SPIN_INIT(&hlua_global_lock);
+	HA_SPIN_INIT(&hlua_global_lock);
 
 	/* Initialise struct hlua and com signals pool */
 	pool2_hlua = create_pool("hlua", sizeof(struct hlua), MEM_F_SHARED);
diff --git a/src/hlua_fcn.c b/src/hlua_fcn.c
index 566b0e5..54fbfa7 100644
--- a/src/hlua_fcn.c
+++ b/src/hlua_fcn.c
@@ -587,9 +587,9 @@
 	srv = hlua_check_server(L, 1);
 	weight = luaL_checkstring(L, 2);
 
-	SPIN_LOCK(SERVER_LOCK, &srv->lock);
+	HA_SPIN_LOCK(SERVER_LOCK, &srv->lock);
 	err = server_parse_weight_change_request(srv, weight);
-	SPIN_UNLOCK(SERVER_LOCK, &srv->lock);
+	HA_SPIN_UNLOCK(SERVER_LOCK, &srv->lock);
 	if (!err)
 		lua_pushnil(L);
 	else
@@ -615,9 +615,9 @@
 	srv = hlua_check_server(L, 1);
 	addr = luaL_checkstring(L, 2);
 
-	SPIN_LOCK(SERVER_LOCK, &srv->lock);
+	HA_SPIN_LOCK(SERVER_LOCK, &srv->lock);
 	err = server_parse_addr_change_request(srv, addr, "Lua script");
-	SPIN_UNLOCK(SERVER_LOCK, &srv->lock);
+	HA_SPIN_UNLOCK(SERVER_LOCK, &srv->lock);
 	if (!err)
 		lua_pushnil(L);
 	else
@@ -630,9 +630,9 @@
 	struct server *srv;
 
 	srv = hlua_check_server(L, 1);
-	SPIN_LOCK(SERVER_LOCK, &srv->lock);
+	HA_SPIN_LOCK(SERVER_LOCK, &srv->lock);
 	srv_shutdown_streams(srv, SF_ERR_KILLED);
-	SPIN_UNLOCK(SERVER_LOCK, &srv->lock);
+	HA_SPIN_UNLOCK(SERVER_LOCK, &srv->lock);
 	return 0;
 }
 
@@ -641,9 +641,9 @@
 	struct server *srv;
 
 	srv = hlua_check_server(L, 1);
-	SPIN_LOCK(SERVER_LOCK, &srv->lock);
+	HA_SPIN_LOCK(SERVER_LOCK, &srv->lock);
 	srv_adm_set_drain(srv);
-	SPIN_UNLOCK(SERVER_LOCK, &srv->lock);
+	HA_SPIN_UNLOCK(SERVER_LOCK, &srv->lock);
 	return 0;
 }
 
@@ -652,9 +652,9 @@
 	struct server *srv;
 
 	srv = hlua_check_server(L, 1);
-	SPIN_LOCK(SERVER_LOCK, &srv->lock);
+	HA_SPIN_LOCK(SERVER_LOCK, &srv->lock);
 	srv_adm_set_maint(srv);
-	SPIN_UNLOCK(SERVER_LOCK, &srv->lock);
+	HA_SPIN_UNLOCK(SERVER_LOCK, &srv->lock);
 	return 0;
 }
 
@@ -663,9 +663,9 @@
 	struct server *srv;
 
 	srv = hlua_check_server(L, 1);
-	SPIN_LOCK(SERVER_LOCK, &srv->lock);
+	HA_SPIN_LOCK(SERVER_LOCK, &srv->lock);
 	srv_adm_set_ready(srv);
-	SPIN_UNLOCK(SERVER_LOCK, &srv->lock);
+	HA_SPIN_UNLOCK(SERVER_LOCK, &srv->lock);
 	return 0;
 }
 
@@ -674,11 +674,11 @@
 	struct server *sv;
 
 	sv = hlua_check_server(L, 1);
-	SPIN_LOCK(SERVER_LOCK, &sv->lock);
+	HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
 	if (sv->check.state & CHK_ST_CONFIGURED) {
 		sv->check.state |= CHK_ST_ENABLED;
 	}
-	SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
+	HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
 	return 0;
 }
 
@@ -687,11 +687,11 @@
 	struct server *sv;
 
 	sv = hlua_check_server(L, 1);
-	SPIN_LOCK(SERVER_LOCK, &sv->lock);
+	HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
 	if (sv->check.state & CHK_ST_CONFIGURED) {
 		sv->check.state &= ~CHK_ST_ENABLED;
 	}
-	SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
+	HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
 	return 0;
 }
 
@@ -700,12 +700,12 @@
 	struct server *sv;
 
 	sv = hlua_check_server(L, 1);
-	SPIN_LOCK(SERVER_LOCK, &sv->lock);
+	HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
 	if (!(sv->track)) {
 		sv->check.health = sv->check.rise + sv->check.fall - 1;
 		srv_set_running(sv, "changed from Lua script", NULL);
 	}
-	SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
+	HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
 	return 0;
 }
 
@@ -714,12 +714,12 @@
 	struct server *sv;
 
 	sv = hlua_check_server(L, 1);
-	SPIN_LOCK(SERVER_LOCK, &sv->lock);
+	HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
 	if (!(sv->track)) {
 		sv->check.health = sv->check.rise + sv->check.fall - 1;
 		srv_set_stopping(sv, "changed from Lua script", NULL);
 	}
-	SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
+	HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
 	return 0;
 }
 
@@ -728,12 +728,12 @@
 	struct server *sv;
 
 	sv = hlua_check_server(L, 1);
-	SPIN_LOCK(SERVER_LOCK, &sv->lock);
+	HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
 	if (!(sv->track)) {
 		sv->check.health = 0;
 		srv_set_stopped(sv, "changed from Lua script", NULL);
 	}
-	SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
+	HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
 	return 0;
 }
 
@@ -742,11 +742,11 @@
 	struct server *sv;
 
 	sv = hlua_check_server(L, 1);
-	SPIN_LOCK(SERVER_LOCK, &sv->lock);
+	HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
 	if (sv->agent.state & CHK_ST_CONFIGURED) {
 		sv->agent.state |= CHK_ST_ENABLED;
 	}
-	SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
+	HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
 	return 0;
 }
 
@@ -755,11 +755,11 @@
 	struct server *sv;
 
 	sv = hlua_check_server(L, 1);
-	SPIN_LOCK(SERVER_LOCK, &sv->lock);
+	HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
 	if (sv->agent.state & CHK_ST_CONFIGURED) {
 		sv->agent.state &= ~CHK_ST_ENABLED;
 	}
-	SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
+	HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
 	return 0;
 }
 
@@ -768,12 +768,12 @@
 	struct server *sv;
 
 	sv = hlua_check_server(L, 1);
-	SPIN_LOCK(SERVER_LOCK, &sv->lock);
+	HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
 	if (sv->agent.state & CHK_ST_ENABLED) {
 		sv->agent.health = sv->agent.rise + sv->agent.fall - 1;
 		srv_set_running(sv, "changed from Lua script", NULL);
 	}
-	SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
+	HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
 	return 0;
 }
 
@@ -782,12 +782,12 @@
 	struct server *sv;
 
 	sv = hlua_check_server(L, 1);
-	SPIN_LOCK(SERVER_LOCK, &sv->lock);
+	HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
 	if (sv->agent.state & CHK_ST_ENABLED) {
 		sv->agent.health = 0;
 		srv_set_stopped(sv, "changed from Lua script", NULL);
 	}
-	SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
+	HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
 	return 0;
 }
 
diff --git a/src/lb_chash.c b/src/lb_chash.c
index 70a455d..e3bf65d 100644
--- a/src/lb_chash.c
+++ b/src/lb_chash.c
@@ -364,7 +364,7 @@
 	srv = avoided = NULL;
 	avoided_node = NULL;
 
-	SPIN_LOCK(LBPRM_LOCK, &p->lbprm.lock);
+	HA_SPIN_LOCK(LBPRM_LOCK, &p->lbprm.lock);
 	if (p->srv_act)
 		root = &p->lbprm.chash.act;
 	else if (p->lbprm.fbck) {
@@ -423,7 +423,7 @@
 	}
 
  out:
-	SPIN_UNLOCK(LBPRM_LOCK, &p->lbprm.lock);
+	HA_SPIN_UNLOCK(LBPRM_LOCK, &p->lbprm.lock);
 	return srv;
 }
 
diff --git a/src/lb_fas.c b/src/lb_fas.c
index db292db..d301143 100644
--- a/src/lb_fas.c
+++ b/src/lb_fas.c
@@ -64,10 +64,10 @@
 	if (!s->lb_tree)
 		return;
 
-	SPIN_LOCK(LBPRM_LOCK, &s->proxy->lbprm.lock);
+	HA_SPIN_LOCK(LBPRM_LOCK, &s->proxy->lbprm.lock);
 	fas_dequeue_srv(s);
 	fas_queue_srv(s);
-	SPIN_UNLOCK(LBPRM_LOCK, &s->proxy->lbprm.lock);
+	HA_SPIN_UNLOCK(LBPRM_LOCK, &s->proxy->lbprm.lock);
 }
 
 /* This function updates the server trees according to server <srv>'s new
@@ -277,7 +277,7 @@
 
 	srv = avoided = NULL;
 
-	SPIN_LOCK(LBPRM_LOCK, &p->lbprm.lock);
+	HA_SPIN_LOCK(LBPRM_LOCK, &p->lbprm.lock);
 	if (p->srv_act)
 		node = eb32_first(&p->lbprm.fas.act);
 	else if (p->lbprm.fbck) {
@@ -313,7 +313,7 @@
 	if (!srv)
 		srv = avoided;
   out:
-	SPIN_UNLOCK(LBPRM_LOCK, &p->lbprm.lock);
+	HA_SPIN_UNLOCK(LBPRM_LOCK, &p->lbprm.lock);
 	return srv;
 }
 
diff --git a/src/lb_fwlc.c b/src/lb_fwlc.c
index 8bd3ac2..fd9b437 100644
--- a/src/lb_fwlc.c
+++ b/src/lb_fwlc.c
@@ -56,10 +56,10 @@
 	if (!s->lb_tree)
 		return;
 
-	SPIN_LOCK(LBPRM_LOCK, &s->proxy->lbprm.lock);
+	HA_SPIN_LOCK(LBPRM_LOCK, &s->proxy->lbprm.lock);
 	fwlc_dequeue_srv(s);
 	fwlc_queue_srv(s);
-	SPIN_UNLOCK(LBPRM_LOCK, &s->proxy->lbprm.lock);
+	HA_SPIN_UNLOCK(LBPRM_LOCK, &s->proxy->lbprm.lock);
 }
 
 /* This function updates the server trees according to server <srv>'s new
@@ -269,7 +269,7 @@
 
 	srv = avoided = NULL;
 
-	SPIN_LOCK(LBPRM_LOCK, &p->lbprm.lock);
+	HA_SPIN_LOCK(LBPRM_LOCK, &p->lbprm.lock);
 	if (p->srv_act)
 		node = eb32_first(&p->lbprm.fwlc.act);
 	else if (p->lbprm.fbck) {
@@ -305,7 +305,7 @@
 	if (!srv)
 		srv = avoided;
  out:
-	SPIN_UNLOCK(LBPRM_LOCK, &p->lbprm.lock);
+	HA_SPIN_UNLOCK(LBPRM_LOCK, &p->lbprm.lock);
 	return srv;
 }
 
diff --git a/src/lb_fwrr.c b/src/lb_fwrr.c
index fe2777d..cba7db5 100644
--- a/src/lb_fwrr.c
+++ b/src/lb_fwrr.c
@@ -470,7 +470,7 @@
 	struct fwrr_group *grp;
 	int switched;
 
-	SPIN_LOCK(LBPRM_LOCK, &p->lbprm.lock);
+	HA_SPIN_LOCK(LBPRM_LOCK, &p->lbprm.lock);
 	if (p->srv_act)
 		grp = &p->lbprm.fwrr.act;
 	else if (p->lbprm.fbck) {
@@ -564,7 +564,7 @@
 		}
 	}
  out:
-	SPIN_UNLOCK(LBPRM_LOCK, &p->lbprm.lock);
+	HA_SPIN_UNLOCK(LBPRM_LOCK, &p->lbprm.lock);
 	return srv;
 }
 
diff --git a/src/lb_map.c b/src/lb_map.c
index df0e185..ecab4de 100644
--- a/src/lb_map.c
+++ b/src/lb_map.c
@@ -208,7 +208,7 @@
 	int newidx, avoididx;
 	struct server *srv, *avoided;
 
-	SPIN_LOCK(LBPRM_LOCK, &px->lbprm.lock);
+	HA_SPIN_LOCK(LBPRM_LOCK, &px->lbprm.lock);
 	if (px->lbprm.tot_weight == 0) {
 		avoided = NULL;
 		goto out;
@@ -240,7 +240,7 @@
 		px->lbprm.map.rr_idx = avoididx;
 
   out:
-	SPIN_UNLOCK(LBPRM_LOCK, &px->lbprm.lock);
+	HA_SPIN_UNLOCK(LBPRM_LOCK, &px->lbprm.lock);
 	/* return NULL or srvtoavoid if found */
 	return avoided;
 }
diff --git a/src/listener.c b/src/listener.c
index c88d76d..2ac25fd 100644
--- a/src/listener.c
+++ b/src/listener.c
@@ -60,7 +60,7 @@
  */
 static void enable_listener(struct listener *listener)
 {
-	SPIN_LOCK(LISTENER_LOCK, &listener->lock);
+	HA_SPIN_LOCK(LISTENER_LOCK, &listener->lock);
 	if (listener->state == LI_LISTEN) {
 		if ((global.mode & (MODE_DAEMON | MODE_MWORKER)) &&
 		    listener->bind_conf->bind_proc &&
@@ -83,7 +83,7 @@
 			listener->state = LI_FULL;
 		}
 	}
-	SPIN_UNLOCK(LISTENER_LOCK, &listener->lock);
+	HA_SPIN_UNLOCK(LISTENER_LOCK, &listener->lock);
 }
 
 /* This function removes the specified listener's file descriptor from the
@@ -92,19 +92,19 @@
  */
 static void disable_listener(struct listener *listener)
 {
-	SPIN_LOCK(LISTENER_LOCK, &listener->lock);
+	HA_SPIN_LOCK(LISTENER_LOCK, &listener->lock);
 	if (listener->state < LI_READY)
 		goto end;
 	if (listener->state == LI_READY)
 		fd_stop_recv(listener->fd);
 	if (listener->state == LI_LIMITED) {
-		SPIN_LOCK(LISTENER_QUEUE_LOCK, &lq_lock);
+		HA_SPIN_LOCK(LISTENER_QUEUE_LOCK, &lq_lock);
 		LIST_DEL(&listener->wait_queue);
-		SPIN_UNLOCK(LISTENER_QUEUE_LOCK, &lq_lock);
+		HA_SPIN_UNLOCK(LISTENER_QUEUE_LOCK, &lq_lock);
 	}
 	listener->state = LI_LISTEN;
   end:
-	SPIN_UNLOCK(LISTENER_LOCK, &listener->lock);
+	HA_SPIN_UNLOCK(LISTENER_LOCK, &listener->lock);
 }
 
 /* This function tries to temporarily disable a listener, depending on the OS
@@ -118,7 +118,7 @@
 {
 	int ret = 1;
 
-	SPIN_LOCK(LISTENER_LOCK, &l->lock);
+	HA_SPIN_LOCK(LISTENER_LOCK, &l->lock);
 
 	if (l->state <= LI_ZOMBIE)
 		goto end;
@@ -138,15 +138,15 @@
 	}
 
 	if (l->state == LI_LIMITED) {
-		SPIN_LOCK(LISTENER_QUEUE_LOCK, &lq_lock);
+		HA_SPIN_LOCK(LISTENER_QUEUE_LOCK, &lq_lock);
 		LIST_DEL(&l->wait_queue);
-		SPIN_UNLOCK(LISTENER_QUEUE_LOCK, &lq_lock);
+		HA_SPIN_UNLOCK(LISTENER_QUEUE_LOCK, &lq_lock);
 	}
 
 	fd_stop_recv(l->fd);
 	l->state = LI_PAUSED;
   end:
-	SPIN_UNLOCK(LISTENER_LOCK, &l->lock);
+	HA_SPIN_UNLOCK(LISTENER_LOCK, &l->lock);
 	return ret;
 }
 
@@ -164,7 +164,7 @@
 {
 	int ret = 1;
 
-	SPIN_LOCK(LISTENER_LOCK, &l->lock);
+	HA_SPIN_LOCK(LISTENER_LOCK, &l->lock);
 
 	if ((global.mode & (MODE_DAEMON | MODE_MWORKER)) &&
 	    l->bind_conf->bind_proc &&
@@ -213,7 +213,7 @@
 	fd_want_recv(l->fd);
 	l->state = LI_READY;
   end:
-	SPIN_UNLOCK(LISTENER_LOCK, &l->lock);
+	HA_SPIN_UNLOCK(LISTENER_LOCK, &l->lock);
 	return ret;
 }
 
@@ -221,9 +221,9 @@
 {
 	int ret;
 
-	SPIN_LOCK(LISTENER_QUEUE_LOCK, &lq_lock);
+	HA_SPIN_LOCK(LISTENER_QUEUE_LOCK, &lq_lock);
 	ret = __resume_listener(l);
-	SPIN_UNLOCK(LISTENER_QUEUE_LOCK, &lq_lock);
+	HA_SPIN_UNLOCK(LISTENER_QUEUE_LOCK, &lq_lock);
 	return ret;
 }
 
@@ -237,9 +237,9 @@
 {
 	if (l->state >= LI_READY) {
 		if (l->state == LI_LIMITED) {
-			SPIN_LOCK(LISTENER_QUEUE_LOCK, &lq_lock);
+			HA_SPIN_LOCK(LISTENER_QUEUE_LOCK, &lq_lock);
 			LIST_DEL(&l->wait_queue);
-			SPIN_UNLOCK(LISTENER_QUEUE_LOCK, &lq_lock);
+			HA_SPIN_UNLOCK(LISTENER_QUEUE_LOCK, &lq_lock);
 		}
 
 		fd_stop_recv(l->fd);
@@ -256,9 +256,9 @@
 static void limit_listener(struct listener *l, struct list *list)
 {
 	if (l->state == LI_READY) {
-		SPIN_LOCK(LISTENER_QUEUE_LOCK, &lq_lock);
+		HA_SPIN_LOCK(LISTENER_QUEUE_LOCK, &lq_lock);
 		LIST_ADDQ(list, &l->wait_queue);
-		SPIN_UNLOCK(LISTENER_QUEUE_LOCK, &lq_lock);
+		HA_SPIN_UNLOCK(LISTENER_QUEUE_LOCK, &lq_lock);
 		fd_stop_recv(l->fd);
 		l->state = LI_LIMITED;
 	}
@@ -298,7 +298,7 @@
 {
 	struct listener *listener, *l_back;
 
-	SPIN_LOCK(LISTENER_QUEUE_LOCK, &lq_lock);
+	HA_SPIN_LOCK(LISTENER_QUEUE_LOCK, &lq_lock);
 	list_for_each_entry_safe(listener, l_back, list, wait_queue) {
 		/* This cannot fail because the listeners are by definition in
 		 * the LI_LIMITED state. The function also removes the entry
@@ -306,7 +306,7 @@
 		 */
 		__resume_listener(listener);
 	}
-	SPIN_UNLOCK(LISTENER_QUEUE_LOCK, &lq_lock);
+	HA_SPIN_UNLOCK(LISTENER_QUEUE_LOCK, &lq_lock);
 }
 
 /* must be called with the lock held */
@@ -316,9 +316,9 @@
 		fd_stop_recv(listener->fd);
 
 	if (listener->state == LI_LIMITED) {
-		SPIN_LOCK(LISTENER_QUEUE_LOCK, &lq_lock);
+		HA_SPIN_LOCK(LISTENER_QUEUE_LOCK, &lq_lock);
 		LIST_DEL(&listener->wait_queue);
-		SPIN_UNLOCK(LISTENER_QUEUE_LOCK, &lq_lock);
+		HA_SPIN_UNLOCK(LISTENER_QUEUE_LOCK, &lq_lock);
 	}
 
 	if (listener->state >= LI_PAUSED) {
@@ -334,9 +334,9 @@
 
 static void do_unbind_listener(struct listener *listener, int do_close)
 {
-	SPIN_LOCK(LISTENER_LOCK, &listener->lock);
+	HA_SPIN_LOCK(LISTENER_LOCK, &listener->lock);
 	__do_unbind_listener(listener, do_close);
-	SPIN_UNLOCK(LISTENER_LOCK, &listener->lock);
+	HA_SPIN_UNLOCK(LISTENER_LOCK, &listener->lock);
 }
 
 /* This function closes the listening socket for the specified listener,
@@ -406,7 +406,7 @@
 
 		proto->add(l, port);
 
-		SPIN_INIT(&l->lock);
+		HA_SPIN_INIT(&l->lock);
 		HA_ATOMIC_ADD(&jobs, 1);
 		HA_ATOMIC_ADD(&listeners, 1);
 	}
@@ -424,13 +424,13 @@
 	if (listener->state != LI_ASSIGNED)
 		return;
 
-	SPIN_LOCK(LISTENER_LOCK, &listener->lock);
+	HA_SPIN_LOCK(LISTENER_LOCK, &listener->lock);
 	listener->state = LI_INIT;
 	LIST_DEL(&listener->proto_list);
 	listener->proto->nb_listeners--;
 	HA_ATOMIC_SUB(&jobs, 1);
 	HA_ATOMIC_SUB(&listeners, 1);
-	SPIN_UNLOCK(LISTENER_LOCK, &listener->lock);
+	HA_SPIN_UNLOCK(LISTENER_LOCK, &listener->lock);
 }
 
 /* This function is called on a read event from a listening socket, corresponding
@@ -449,7 +449,7 @@
 	static int accept4_broken;
 #endif
 
-	if (SPIN_TRYLOCK(LISTENER_LOCK, &l->lock))
+	if (HA_SPIN_TRYLOCK(LISTENER_LOCK, &l->lock))
 		return;
 
 	if (unlikely(l->nbconn >= l->maxconn)) {
@@ -657,7 +657,7 @@
 	limit_listener(l, &global_listener_queue);
 	task_schedule(global_listener_queue_task, tick_first(expire, global_listener_queue_task->expire));
  end:
-	SPIN_UNLOCK(LISTENER_LOCK, &l->lock);
+	HA_SPIN_UNLOCK(LISTENER_LOCK, &l->lock);
 }
 
 /* Notify the listener that a connection initiated from it was released. This
@@ -1019,7 +1019,7 @@
 	sample_register_fetches(&smp_kws);
 	acl_register_keywords(&acl_kws);
 	bind_register_keywords(&bind_kws);
-	SPIN_INIT(&lq_lock);
+	HA_SPIN_INIT(&lq_lock);
 }
 
 /*
diff --git a/src/map.c b/src/map.c
index 99ea334..fb41173 100644
--- a/src/map.c
+++ b/src/map.c
@@ -325,16 +325,16 @@
 		 * this pointer. We know we have reached the end when this
 		 * pointer points back to the head of the streams list.
 		 */
-		SPIN_LOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
+		HA_SPIN_LOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
 		LIST_INIT(&appctx->ctx.map.bref.users);
 		appctx->ctx.map.bref.ref = appctx->ctx.map.ref->head.n;
-		SPIN_UNLOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
+		HA_SPIN_UNLOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
 		appctx->st2 = STAT_ST_LIST;
 		/* fall through */
 
 	case STAT_ST_LIST:
 
-		SPIN_LOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
+		HA_SPIN_LOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
 
 		if (!LIST_ISEMPTY(&appctx->ctx.map.bref.users)) {
 			LIST_DEL(&appctx->ctx.map.bref.users);
@@ -360,7 +360,7 @@
 				 * this stream's users so that it can remove us upon termination.
 				 */
 				LIST_ADDQ(&elt->back_refs, &appctx->ctx.map.bref.users);
-				SPIN_UNLOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
+				HA_SPIN_UNLOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
 				si_applet_cant_put(si);
 				return 0;
 			}
@@ -368,7 +368,7 @@
 			/* get next list entry and check the end of the list */
 			appctx->ctx.map.bref.ref = elt->list.n;
 		}
-		SPIN_UNLOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
+		HA_SPIN_UNLOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
 		appctx->st2 = STAT_ST_FIN;
 		/* fall through */
 
@@ -456,7 +456,7 @@
 		/* fall through */
 
 	case STAT_ST_LIST:
-		SPIN_LOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
+		HA_SPIN_LOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
 		/* for each lookup type */
 		while (appctx->ctx.map.expr) {
 			/* initialise chunk to build new message */
@@ -542,7 +542,7 @@
 				/* let's try again later from this stream. We add ourselves into
 				 * this stream's users so that it can remove us upon termination.
 				 */
-				SPIN_UNLOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
+				HA_SPIN_UNLOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
 				si_applet_cant_put(si);
 				return 0;
 			}
@@ -551,7 +551,7 @@
 			appctx->ctx.map.expr = pat_expr_get_next(appctx->ctx.map.expr,
 			                                         &appctx->ctx.map.ref->pat);
 		}
-		SPIN_UNLOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
+		HA_SPIN_UNLOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
 		appctx->st2 = STAT_ST_FIN;
 		/* fall through */
 
@@ -628,10 +628,10 @@
 static void cli_release_show_map(struct appctx *appctx)
 {
 	if (appctx->st2 == STAT_ST_LIST) {
-		SPIN_LOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
+		HA_SPIN_LOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
 		if (!LIST_ISEMPTY(&appctx->ctx.map.bref.users))
 			LIST_DEL(&appctx->ctx.map.bref.users);
-		SPIN_UNLOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
+		HA_SPIN_UNLOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
 	}
 }
 
@@ -728,32 +728,32 @@
 
 			/* Try to delete the entry. */
 			err = NULL;
-			SPIN_LOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
+			HA_SPIN_LOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
 			if (!pat_ref_set_by_id(appctx->ctx.map.ref, ref, args[4], &err)) {
-				SPIN_UNLOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
+				HA_SPIN_UNLOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
 				if (err)
 					memprintf(&err, "%s.\n", err);
 				appctx->ctx.cli.err = err;
 				appctx->st0 = CLI_ST_PRINT_FREE;
 				return 1;
 			}
-			SPIN_UNLOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
+			HA_SPIN_UNLOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
 		}
 		else {
 			/* Else, use the entry identifier as pattern
 			 * string, and update the value.
 			 */
 			err = NULL;
-			SPIN_LOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
+			HA_SPIN_LOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
 			if (!pat_ref_set(appctx->ctx.map.ref, args[3], args[4], &err)) {
-				SPIN_UNLOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
+				HA_SPIN_UNLOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
 				if (err)
 					memprintf(&err, "%s.\n", err);
 				appctx->ctx.cli.err = err;
 				appctx->st0 = CLI_ST_PRINT_FREE;
 				return 1;
 			}
-			SPIN_UNLOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
+			HA_SPIN_UNLOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
 		}
 
 		/* The set is done, send message. */
@@ -825,12 +825,12 @@
 
 		/* Add value. */
 		err = NULL;
-		SPIN_LOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
+		HA_SPIN_LOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
 		if (appctx->ctx.map.display_flags == PAT_REF_MAP)
 			ret = pat_ref_add(appctx->ctx.map.ref, args[3], args[4], &err);
 		else
 			ret = pat_ref_add(appctx->ctx.map.ref, args[3], NULL, &err);
-		SPIN_UNLOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
+		HA_SPIN_UNLOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
 		if (!ret) {
 			if (err)
 				memprintf(&err, "%s.\n", err);
@@ -910,31 +910,31 @@
 		}
 
 		/* Try to delete the entry. */
-		SPIN_LOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
+		HA_SPIN_LOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
 		if (!pat_ref_delete_by_id(appctx->ctx.map.ref, ref)) {
-			SPIN_UNLOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
+			HA_SPIN_UNLOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
 			/* The entry is not found, send message. */
 			appctx->ctx.cli.severity = LOG_ERR;
 			appctx->ctx.cli.msg = "Key not found.\n";
 			appctx->st0 = CLI_ST_PRINT;
 			return 1;
 		}
-		SPIN_UNLOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
+		HA_SPIN_UNLOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
 	}
 	else {
 		/* Else, use the entry identifier as pattern
 		 * string and try to delete the entry.
 		 */
-		SPIN_LOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
+		HA_SPIN_LOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
 		if (!pat_ref_delete(appctx->ctx.map.ref, args[3])) {
-			SPIN_UNLOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
+			HA_SPIN_UNLOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
 			/* The entry is not found, send message. */
 			appctx->ctx.cli.severity = LOG_ERR;
 			appctx->ctx.cli.msg = "Key not found.\n";
 			appctx->st0 = CLI_ST_PRINT;
 			return 1;
 		}
-		SPIN_UNLOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
+		HA_SPIN_UNLOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
 	}
 
 	/* The deletion is done, send message. */
@@ -983,9 +983,9 @@
 		}
 
 		/* Clear all. */
-		SPIN_LOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
+		HA_SPIN_LOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
 		pat_ref_prune(appctx->ctx.map.ref);
-		SPIN_UNLOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
+		HA_SPIN_UNLOCK(PATREF_LOCK, &appctx->ctx.map.ref->lock);
 
 		/* return response */
 		appctx->st0 = CLI_ST_PROMPT;
diff --git a/src/memory.c b/src/memory.c
index 9313aa9..b0b32e7 100644
--- a/src/memory.c
+++ b/src/memory.c
@@ -93,7 +93,7 @@
 		LIST_ADDQ(start, &pool->list);
 	}
 	pool->users++;
-	SPIN_INIT(&pool->lock);
+	HA_SPIN_INIT(&pool->lock);
 	return pool;
 }
 
@@ -143,9 +143,9 @@
 {
 	void *ptr;
 
-	SPIN_LOCK(POOL_LOCK, &pool->lock);
+	HA_SPIN_LOCK(POOL_LOCK, &pool->lock);
 	ptr = __pool_refill_alloc(pool, avail);
-	SPIN_UNLOCK(POOL_LOCK, &pool->lock);
+	HA_SPIN_UNLOCK(POOL_LOCK, &pool->lock);
 	return ptr;
 }
 /*
@@ -157,7 +157,7 @@
 	if (!pool)
 		return;
 
-	SPIN_LOCK(POOL_LOCK, &pool->lock);
+	HA_SPIN_LOCK(POOL_LOCK, &pool->lock);
 	next = pool->free_list;
 	while (next) {
 		temp = next;
@@ -166,7 +166,7 @@
 		free(temp);
 	}
 	pool->free_list = next;
-	SPIN_UNLOCK(POOL_LOCK, &pool->lock);
+	HA_SPIN_UNLOCK(POOL_LOCK, &pool->lock);
 	/* here, we should have pool->allocate == pool->used */
 }
 
@@ -192,7 +192,7 @@
 		void *temp, *next;
 		//qfprintf(stderr, "Flushing pool %s\n", entry->name);
 		if (entry != pool_ctx)
-			SPIN_LOCK(POOL_LOCK, &entry->lock);
+			HA_SPIN_LOCK(POOL_LOCK, &entry->lock);
 		next = entry->free_list;
 		while (next &&
 		       (int)(entry->allocated - entry->used) > (int)entry->minavail) {
@@ -203,7 +203,7 @@
 		}
 		entry->free_list = next;
 		if (entry != pool_ctx)
-			SPIN_UNLOCK(POOL_LOCK, &entry->lock);
+			HA_SPIN_UNLOCK(POOL_LOCK, &entry->lock);
 	}
 
 	HA_ATOMIC_STORE(&recurse, 0);
@@ -225,7 +225,7 @@
 		pool->users--;
 		if (!pool->users) {
 			LIST_DEL(&pool->list);
-			SPIN_DESTROY(&pool->lock);
+			HA_SPIN_DESTROY(&pool->lock);
 			free(pool);
 		}
 	}
@@ -242,7 +242,7 @@
 	allocated = used = nbpools = 0;
 	chunk_printf(&trash, "Dumping pools usage. Use SIGQUIT to flush them.\n");
 	list_for_each_entry(entry, &pools, list) {
-		SPIN_LOCK(POOL_LOCK, &entry->lock);
+		HA_SPIN_LOCK(POOL_LOCK, &entry->lock);
 		chunk_appendf(&trash, "  - Pool %s (%d bytes) : %d allocated (%u bytes), %d used, %d failures, %d users%s\n",
 			 entry->name, entry->size, entry->allocated,
 		         entry->size * entry->allocated, entry->used, entry->failed,
@@ -251,7 +251,7 @@
 		allocated += entry->allocated * entry->size;
 		used += entry->used * entry->size;
 		nbpools++;
-		SPIN_UNLOCK(POOL_LOCK, &entry->lock);
+		HA_SPIN_UNLOCK(POOL_LOCK, &entry->lock);
 	}
 	chunk_appendf(&trash, "Total: %d pools, %lu bytes allocated, %lu used.\n",
 		 nbpools, allocated, used);
diff --git a/src/mux_h2.c b/src/mux_h2.c
index fbd042b..07a94bc 100644
--- a/src/mux_h2.c
+++ b/src/mux_h2.c
@@ -233,9 +233,9 @@
 	    unlikely((buf = b_alloc_margin(&h2c->dbuf, 0)) == NULL)) {
 		h2c->dbuf_wait.target = h2c->conn;
 		h2c->dbuf_wait.wakeup_cb = h2_dbuf_available;
-		SPIN_LOCK(BUF_WQ_LOCK, &buffer_wq_lock);
+		HA_SPIN_LOCK(BUF_WQ_LOCK, &buffer_wq_lock);
 		LIST_ADDQ(&buffer_wq, &h2c->dbuf_wait.list);
-		SPIN_UNLOCK(BUF_WQ_LOCK, &buffer_wq_lock);
+		HA_SPIN_UNLOCK(BUF_WQ_LOCK, &buffer_wq_lock);
 		__conn_xprt_stop_recv(h2c->conn);
 	}
 	return buf;
@@ -289,9 +289,9 @@
 	    unlikely((buf = b_alloc_margin(&h2c->mbuf, 0)) == NULL)) {
 		h2c->mbuf_wait.target = h2c;
 		h2c->mbuf_wait.wakeup_cb = h2_mbuf_available;
-		SPIN_LOCK(BUF_WQ_LOCK, &buffer_wq_lock);
+		HA_SPIN_LOCK(BUF_WQ_LOCK, &buffer_wq_lock);
 		LIST_ADDQ(&buffer_wq, &h2c->mbuf_wait.list);
-		SPIN_UNLOCK(BUF_WQ_LOCK, &buffer_wq_lock);
+		HA_SPIN_UNLOCK(BUF_WQ_LOCK, &buffer_wq_lock);
 
 		/* FIXME: we should in fact only block the direction being
 		 * currently used. For now it will be enough like this.
@@ -425,14 +425,14 @@
 	if (h2c) {
 		hpack_dht_free(h2c->ddht);
 		h2_release_dbuf(h2c);
-		SPIN_LOCK(BUF_WQ_LOCK, &buffer_wq_lock);
+		HA_SPIN_LOCK(BUF_WQ_LOCK, &buffer_wq_lock);
 		LIST_DEL(&h2c->dbuf_wait.list);
-		SPIN_UNLOCK(BUF_WQ_LOCK, &buffer_wq_lock);
+		HA_SPIN_UNLOCK(BUF_WQ_LOCK, &buffer_wq_lock);
 
 		h2_release_mbuf(h2c);
-		SPIN_LOCK(BUF_WQ_LOCK, &buffer_wq_lock);
+		HA_SPIN_LOCK(BUF_WQ_LOCK, &buffer_wq_lock);
 		LIST_DEL(&h2c->mbuf_wait.list);
-		SPIN_UNLOCK(BUF_WQ_LOCK, &buffer_wq_lock);
+		HA_SPIN_UNLOCK(BUF_WQ_LOCK, &buffer_wq_lock);
 
 		if (h2c->task) {
 			task_delete(h2c->task);
diff --git a/src/pattern.c b/src/pattern.c
index 61ef5f0..39ecd95 100644
--- a/src/pattern.c
+++ b/src/pattern.c
@@ -489,15 +489,15 @@
 	if (pat_lru_tree) {
 		unsigned long long seed = pat_lru_seed ^ (long)expr;
 
-		SPIN_LOCK(PATLRU_LOCK, &pat_lru_tree_lock);
+		HA_SPIN_LOCK(PATLRU_LOCK, &pat_lru_tree_lock);
 		lru = lru64_get(XXH64(smp->data.u.str.str, smp->data.u.str.len, seed),
 				pat_lru_tree, expr, expr->revision);
 		if (!lru) {
-			SPIN_UNLOCK(PATLRU_LOCK, &pat_lru_tree_lock);
+			HA_SPIN_UNLOCK(PATLRU_LOCK, &pat_lru_tree_lock);
 		}
 		else if (lru->domain) {
 			ret = lru->data;
-			SPIN_UNLOCK(PATLRU_LOCK, &pat_lru_tree_lock);
+			HA_SPIN_UNLOCK(PATLRU_LOCK, &pat_lru_tree_lock);
 			return ret;
 		}
 	}
@@ -519,7 +519,7 @@
 
 	if (lru) {
 		lru64_commit(lru, ret, expr, expr->revision, NULL);
-		SPIN_UNLOCK(PATLRU_LOCK, &pat_lru_tree_lock);
+		HA_SPIN_UNLOCK(PATLRU_LOCK, &pat_lru_tree_lock);
 	}
 
 	return ret;
@@ -536,15 +536,15 @@
 	if (pat_lru_tree) {
 		unsigned long long seed = pat_lru_seed ^ (long)expr;
 
-		SPIN_LOCK(PATLRU_LOCK, &pat_lru_tree_lock);
+		HA_SPIN_LOCK(PATLRU_LOCK, &pat_lru_tree_lock);
 		lru = lru64_get(XXH64(smp->data.u.str.str, smp->data.u.str.len, seed),
 				pat_lru_tree, expr, expr->revision);
 		if (!lru) {
-			SPIN_UNLOCK(PATLRU_LOCK, &pat_lru_tree_lock);
+			HA_SPIN_UNLOCK(PATLRU_LOCK, &pat_lru_tree_lock);
 		}
 		else if (lru->domain) {
 			ret = lru->data;
-			SPIN_UNLOCK(PATLRU_LOCK, &pat_lru_tree_lock);
+			HA_SPIN_UNLOCK(PATLRU_LOCK, &pat_lru_tree_lock);
 			return ret;
 		}
 	}
@@ -563,7 +563,7 @@
 
 	if (lru) {
 		lru64_commit(lru, ret, expr, expr->revision, NULL);
-		SPIN_UNLOCK(PATLRU_LOCK, &pat_lru_tree_lock);
+		HA_SPIN_UNLOCK(PATLRU_LOCK, &pat_lru_tree_lock);
 	}
 
 	return ret;
@@ -606,15 +606,15 @@
 	if (pat_lru_tree) {
 		unsigned long long seed = pat_lru_seed ^ (long)expr;
 
-		SPIN_LOCK(PATLRU_LOCK, &pat_lru_tree_lock);
+		HA_SPIN_LOCK(PATLRU_LOCK, &pat_lru_tree_lock);
 		lru = lru64_get(XXH64(smp->data.u.str.str, smp->data.u.str.len, seed),
 				pat_lru_tree, expr, expr->revision);
 		if (!lru) {
-			SPIN_UNLOCK(PATLRU_LOCK, &pat_lru_tree_lock);
+			HA_SPIN_UNLOCK(PATLRU_LOCK, &pat_lru_tree_lock);
 		}
 		else if (lru->domain) {
 			ret = lru->data;
-			SPIN_UNLOCK(PATLRU_LOCK, &pat_lru_tree_lock);
+			HA_SPIN_UNLOCK(PATLRU_LOCK, &pat_lru_tree_lock);
 			return ret;
 		}
 	}
@@ -630,7 +630,7 @@
 
 	if (lru) {
 		lru64_commit(lru, ret, expr, expr->revision, NULL);
-		SPIN_UNLOCK(PATLRU_LOCK, &pat_lru_tree_lock);
+		HA_SPIN_UNLOCK(PATLRU_LOCK, &pat_lru_tree_lock);
 	}
 
 	return ret;
@@ -675,15 +675,15 @@
 	if (pat_lru_tree) {
 		unsigned long long seed = pat_lru_seed ^ (long)expr;
 
-		SPIN_LOCK(PATLRU_LOCK, &pat_lru_tree_lock);
+		HA_SPIN_LOCK(PATLRU_LOCK, &pat_lru_tree_lock);
 		lru = lru64_get(XXH64(smp->data.u.str.str, smp->data.u.str.len, seed),
 				pat_lru_tree, expr, expr->revision);
 		if (!lru) {
-			SPIN_UNLOCK(PATLRU_LOCK, &pat_lru_tree_lock);
+			HA_SPIN_UNLOCK(PATLRU_LOCK, &pat_lru_tree_lock);
 		}
 		else if (lru->domain) {
 			ret = lru->data;
-			SPIN_UNLOCK(PATLRU_LOCK, &pat_lru_tree_lock);
+			HA_SPIN_UNLOCK(PATLRU_LOCK, &pat_lru_tree_lock);
 			return ret;
 		}
 	}
@@ -705,7 +705,7 @@
 
 	if (lru) {
 		lru64_commit(lru, ret, expr, expr->revision, NULL);
-		SPIN_UNLOCK(PATLRU_LOCK, &pat_lru_tree_lock);
+		HA_SPIN_UNLOCK(PATLRU_LOCK, &pat_lru_tree_lock);
 	}
 
 	return ret;
@@ -723,15 +723,15 @@
 	if (pat_lru_tree) {
 		unsigned long long seed = pat_lru_seed ^ (long)expr;
 
-		SPIN_LOCK(PATLRU_LOCK, &pat_lru_tree_lock);
+		HA_SPIN_LOCK(PATLRU_LOCK, &pat_lru_tree_lock);
 		lru = lru64_get(XXH64(smp->data.u.str.str, smp->data.u.str.len, seed),
 				pat_lru_tree, expr, expr->revision);
 		if (!lru) {
-			SPIN_UNLOCK(PATLRU_LOCK, &pat_lru_tree_lock);
+			HA_SPIN_UNLOCK(PATLRU_LOCK, &pat_lru_tree_lock);
 		}
 		else if (lru->domain) {
 			ret = lru->data;
-			SPIN_UNLOCK(PATLRU_LOCK, &pat_lru_tree_lock);
+			HA_SPIN_UNLOCK(PATLRU_LOCK, &pat_lru_tree_lock);
 			return ret;
 		}
 	}
@@ -753,7 +753,7 @@
 
 	if (lru) {
 		lru64_commit(lru, ret, expr, expr->revision, NULL);
-		SPIN_UNLOCK(PATLRU_LOCK, &pat_lru_tree_lock);
+		HA_SPIN_UNLOCK(PATLRU_LOCK, &pat_lru_tree_lock);
 	}
 
 	return ret;
@@ -775,15 +775,15 @@
 	if (pat_lru_tree) {
 		unsigned long long seed = pat_lru_seed ^ (long)expr;
 
-		SPIN_LOCK(PATLRU_LOCK, &pat_lru_tree_lock);
+		HA_SPIN_LOCK(PATLRU_LOCK, &pat_lru_tree_lock);
 		lru = lru64_get(XXH64(smp->data.u.str.str, smp->data.u.str.len, seed),
 				pat_lru_tree, expr, expr->revision);
 		if (!lru) {
-			SPIN_UNLOCK(PATLRU_LOCK, &pat_lru_tree_lock);
+			HA_SPIN_UNLOCK(PATLRU_LOCK, &pat_lru_tree_lock);
 		}
 		else if (lru->domain) {
 			ret = lru->data;
-			SPIN_UNLOCK(PATLRU_LOCK, &pat_lru_tree_lock);
+			HA_SPIN_UNLOCK(PATLRU_LOCK, &pat_lru_tree_lock);
 			return ret;
 		}
 	}
@@ -819,7 +819,7 @@
  leave:
 	if (lru) {
 		lru64_commit(lru, ret, expr, expr->revision, NULL);
-		SPIN_UNLOCK(PATLRU_LOCK, &pat_lru_tree_lock);
+		HA_SPIN_UNLOCK(PATLRU_LOCK, &pat_lru_tree_lock);
 	}
 
 	return ret;
@@ -1765,11 +1765,11 @@
 		if (!expr->pat_head->parse_smp)
 			continue;
 
-		RWLOCK_WRLOCK(PATEXP_LOCK, &expr->lock);
+		HA_RWLOCK_WRLOCK(PATEXP_LOCK, &expr->lock);
 		data = pattern_find_smp(expr, elt);
 		if (data && *data && !expr->pat_head->parse_smp(sample, *data))
 			*data = NULL;
-		RWLOCK_WRUNLOCK(PATEXP_LOCK, &expr->lock);
+		HA_RWLOCK_WRUNLOCK(PATEXP_LOCK, &expr->lock);
 	}
 
 	/* free old sample only when all exprs are updated */
@@ -1872,7 +1872,7 @@
 
 	LIST_INIT(&ref->head);
 	LIST_INIT(&ref->pat);
-	SPIN_INIT(&ref->lock);
+	HA_SPIN_INIT(&ref->lock);
 	LIST_ADDQ(&pattern_reference, &ref->list);
 
 	return ref;
@@ -1991,14 +1991,14 @@
 		return 0;
 	}
 
-	RWLOCK_WRLOCK(PATEXP_LOCK, &expr->lock);
+	HA_RWLOCK_WRLOCK(PATEXP_LOCK, &expr->lock);
 	/* index pattern */
 	if (!expr->pat_head->index(expr, &pattern, err)) {
-		RWLOCK_WRUNLOCK(PATEXP_LOCK, &expr->lock);
+		HA_RWLOCK_WRUNLOCK(PATEXP_LOCK, &expr->lock);
 		free(data);
 		return 0;
 	}
-	RWLOCK_WRUNLOCK(PATEXP_LOCK, &expr->lock);
+	HA_RWLOCK_WRUNLOCK(PATEXP_LOCK, &expr->lock);
 
 	return 1;
 }
@@ -2073,9 +2073,9 @@
 	struct pattern pattern;
 
 
-	SPIN_LOCK(PATREF_LOCK, &ref->lock);
+	HA_SPIN_LOCK(PATREF_LOCK, &ref->lock);
 	list_for_each_entry(expr, &ref->pat, list) {
-		RWLOCK_WRLOCK(PATEXP_LOCK, &expr->lock);
+		HA_RWLOCK_WRLOCK(PATEXP_LOCK, &expr->lock);
 	}
 
 	/* all expr are locked, we can safely remove all pat_ref */
@@ -2145,9 +2145,9 @@
 				continue;
 			}
 		}
-		RWLOCK_WRUNLOCK(PATEXP_LOCK, &expr->lock);
+		HA_RWLOCK_WRUNLOCK(PATEXP_LOCK, &expr->lock);
 	}
-	SPIN_UNLOCK(PATREF_LOCK, &ref->lock);
+	HA_SPIN_UNLOCK(PATREF_LOCK, &ref->lock);
 }
 
 /* This function prune all entries of <ref>. This function
@@ -2160,9 +2160,9 @@
 	struct bref *bref, *back;
 
 	list_for_each_entry(expr, &ref->pat, list) {
-		RWLOCK_WRLOCK(PATEXP_LOCK, &expr->lock);
+		HA_RWLOCK_WRLOCK(PATEXP_LOCK, &expr->lock);
 		expr->pat_head->prune(expr);
-		RWLOCK_WRUNLOCK(PATEXP_LOCK, &expr->lock);
+		HA_RWLOCK_WRUNLOCK(PATEXP_LOCK, &expr->lock);
 	}
 
 	/* we trash pat_ref_elt in a second time to ensure that data is
@@ -2267,7 +2267,7 @@
 
 		expr->ref = ref;
 
-		RWLOCK_INIT(&expr->lock);
+		HA_RWLOCK_INIT(&expr->lock);
 
 		/* We must free this pattern if it is no more used. */
 		list->do_free = 1;
@@ -2579,7 +2579,7 @@
 		return NULL;
 
 	list_for_each_entry(list, &head->head, list) {
-		RWLOCK_RDLOCK(PATEXP_LOCK, &list->expr->lock);
+		HA_RWLOCK_RDLOCK(PATEXP_LOCK, &list->expr->lock);
 		pat = head->match(smp, list->expr, fill);
 		if (pat) {
 			/* We duplicate the pattern cause it could be modified
@@ -2610,10 +2610,10 @@
 				}
 				pat->data = &static_sample_data;
 			}
-			RWLOCK_RDUNLOCK(PATEXP_LOCK, &list->expr->lock);
+			HA_RWLOCK_RDUNLOCK(PATEXP_LOCK, &list->expr->lock);
 			return pat;
 		}
-		RWLOCK_RDUNLOCK(PATEXP_LOCK, &list->expr->lock);
+		HA_RWLOCK_RDUNLOCK(PATEXP_LOCK, &list->expr->lock);
 	}
 	return NULL;
 }
@@ -2627,9 +2627,9 @@
 		LIST_DEL(&list->list);
 		if (list->do_free) {
 			LIST_DEL(&list->expr->list);
-			RWLOCK_WRLOCK(PATEXP_LOCK, &list->expr->lock);
+			HA_RWLOCK_WRLOCK(PATEXP_LOCK, &list->expr->lock);
 			head->prune(list->expr);
-			RWLOCK_WRUNLOCK(PATEXP_LOCK, &list->expr->lock);
+			HA_RWLOCK_WRUNLOCK(PATEXP_LOCK, &list->expr->lock);
 			free(list->expr);
 		}
 		free(list);
@@ -2676,9 +2676,9 @@
  */
 int pattern_delete(struct pattern_expr *expr, struct pat_ref_elt *ref)
 {
-	RWLOCK_WRLOCK(PATEXP_LOCK, &expr->lock);
+	HA_RWLOCK_WRLOCK(PATEXP_LOCK, &expr->lock);
 	expr->pat_head->delete(expr, ref);
-	RWLOCK_WRUNLOCK(PATEXP_LOCK, &expr->lock);
+	HA_RWLOCK_WRUNLOCK(PATEXP_LOCK, &expr->lock);
 	return 1;
 }
 
@@ -2694,7 +2694,7 @@
 	pat_lru_seed = random();
 	if (global.tune.pattern_cache) {
 		pat_lru_tree = lru64_new(global.tune.pattern_cache);
-		SPIN_INIT(&pat_lru_tree_lock);
+		HA_SPIN_INIT(&pat_lru_tree_lock);
 	}
 
 	list_for_each_entry(ref, &pattern_reference, list) {
diff --git a/src/peers.c b/src/peers.c
index 4819937..94a4852 100644
--- a/src/peers.c
+++ b/src/peers.c
@@ -319,7 +319,7 @@
 		cursor += st->table->key_size;
 	}
 
-	RWLOCK_RDLOCK(STK_SESS_LOCK, &ts->lock);
+	HA_RWLOCK_RDLOCK(STK_SESS_LOCK, &ts->lock);
 	/* encode values */
 	for (data_type = 0 ; data_type < STKTABLE_DATA_TYPES ; data_type++) {
 
@@ -359,7 +359,7 @@
 			}
 		}
 	}
-	RWLOCK_RDUNLOCK(STK_SESS_LOCK, &ts->lock);
+	HA_RWLOCK_RDUNLOCK(STK_SESS_LOCK, &ts->lock);
 
 	/* Compute datalen */
 	datalen = (cursor - datamsg);
@@ -510,7 +510,7 @@
 
 	/* peer session identified */
 	if (peer) {
-		SPIN_LOCK(PEER_LOCK, &peer->lock);
+		HA_SPIN_LOCK(PEER_LOCK, &peer->lock);
 		if (peer->appctx == appctx) {
 			/* Re-init current table pointers to force announcement on re-connect */
 			peer->remote_table = peer->last_local_table = NULL;
@@ -527,7 +527,7 @@
 			peer->flags &= PEER_TEACH_RESET;
 			peer->flags &= PEER_LEARN_RESET;
 		}
-		SPIN_UNLOCK(PEER_LOCK, &peer->lock);
+		HA_SPIN_UNLOCK(PEER_LOCK, &peer->lock);
 		task_wakeup(peers->sync_task, TASK_WOKEN_MSG);
 	}
 }
@@ -692,7 +692,7 @@
 					goto switchstate;
 				}
 
-				SPIN_LOCK(PEER_LOCK, &curpeer->lock);
+				HA_SPIN_LOCK(PEER_LOCK, &curpeer->lock);
 				if (curpeer->appctx && curpeer->appctx != appctx) {
 					if (curpeer->local) {
 						/* Local connection, reply a retry */
@@ -726,7 +726,7 @@
 
 				if (!curpeer) {
 					curpeer = appctx->ctx.peers.ptr;
-					SPIN_LOCK(PEER_LOCK, &curpeer->lock);
+					HA_SPIN_LOCK(PEER_LOCK, &curpeer->lock);
 					if (curpeer->appctx != appctx) {
 						appctx->st0 = PEER_SESS_ST_END;
 						goto switchstate;
@@ -787,7 +787,7 @@
 
 				if (!curpeer) {
 					curpeer = appctx->ctx.peers.ptr;
-					SPIN_LOCK(PEER_LOCK, &curpeer->lock);
+					HA_SPIN_LOCK(PEER_LOCK, &curpeer->lock);
 					if (curpeer->appctx != appctx) {
 						appctx->st0 = PEER_SESS_ST_END;
 						goto switchstate;
@@ -826,7 +826,7 @@
 
 				if (!curpeer) {
 					curpeer = appctx->ctx.peers.ptr;
-					SPIN_LOCK(PEER_LOCK, &curpeer->lock);
+					HA_SPIN_LOCK(PEER_LOCK, &curpeer->lock);
 					if (curpeer->appctx != appctx) {
 						appctx->st0 = PEER_SESS_ST_END;
 						goto switchstate;
@@ -913,7 +913,7 @@
 
 				if (!curpeer) {
 					curpeer = appctx->ctx.peers.ptr;
-					SPIN_LOCK(PEER_LOCK, &curpeer->lock);
+					HA_SPIN_LOCK(PEER_LOCK, &curpeer->lock);
 					if (curpeer->appctx != appctx) {
 						appctx->st0 = PEER_SESS_ST_END;
 						goto switchstate;
@@ -1252,7 +1252,7 @@
 							newts = NULL;
 						}
 
-						RWLOCK_WRLOCK(STK_SESS_LOCK, &ts->lock);
+						HA_RWLOCK_WRLOCK(STK_SESS_LOCK, &ts->lock);
 
 						for (data_type = 0 ; data_type < STKTABLE_DATA_TYPES ; data_type++) {
 
@@ -1264,7 +1264,7 @@
 										data = intdecode(&msg_cur, msg_end);
 										if (!msg_cur) {
 											/* malformed message */
-											RWLOCK_WRUNLOCK(STK_SESS_LOCK, &ts->lock);
+											HA_RWLOCK_WRUNLOCK(STK_SESS_LOCK, &ts->lock);
 											stktable_touch_remote(st->table, ts, 1);
 											appctx->st0 = PEER_SESS_ST_ERRPROTO;
 											goto switchstate;
@@ -1281,7 +1281,7 @@
 										data = intdecode(&msg_cur, msg_end);
 										if (!msg_cur) {
 											/* malformed message */
-											RWLOCK_WRUNLOCK(STK_SESS_LOCK, &ts->lock);
+											HA_RWLOCK_WRUNLOCK(STK_SESS_LOCK, &ts->lock);
 											stktable_touch_remote(st->table, ts, 1);
 											appctx->st0 = PEER_SESS_ST_ERRPROTO;
 											goto switchstate;
@@ -1298,7 +1298,7 @@
 										data = intdecode(&msg_cur, msg_end);
 										if (!msg_cur) {
 											/* malformed message */
-											RWLOCK_WRUNLOCK(STK_SESS_LOCK, &ts->lock);
+											HA_RWLOCK_WRUNLOCK(STK_SESS_LOCK, &ts->lock);
 											stktable_touch_remote(st->table, ts, 1);
 											appctx->st0 = PEER_SESS_ST_ERRPROTO;
 											goto switchstate;
@@ -1320,7 +1320,7 @@
 										data.curr_tick = tick_add(now_ms, -intdecode(&msg_cur, msg_end)) & ~0x1;
 										if (!msg_cur) {
 											/* malformed message */
-											RWLOCK_WRUNLOCK(STK_SESS_LOCK, &ts->lock);
+											HA_RWLOCK_WRUNLOCK(STK_SESS_LOCK, &ts->lock);
 											stktable_touch_remote(st->table, ts, 1);
 											appctx->st0 = PEER_SESS_ST_ERRPROTO;
 											goto switchstate;
@@ -1328,7 +1328,7 @@
 										data.curr_ctr = intdecode(&msg_cur, msg_end);
 										if (!msg_cur) {
 											/* malformed message */
-											RWLOCK_WRUNLOCK(STK_SESS_LOCK, &ts->lock);
+											HA_RWLOCK_WRUNLOCK(STK_SESS_LOCK, &ts->lock);
 											stktable_touch_remote(st->table, ts, 1);
 											appctx->st0 = PEER_SESS_ST_ERRPROTO;
 											goto switchstate;
@@ -1336,7 +1336,7 @@
 										data.prev_ctr = intdecode(&msg_cur, msg_end);
 										if (!msg_cur) {
 											/* malformed message */
-											RWLOCK_WRUNLOCK(STK_SESS_LOCK, &ts->lock);
+											HA_RWLOCK_WRUNLOCK(STK_SESS_LOCK, &ts->lock);
 											stktable_touch_remote(st->table, ts, 1);
 											appctx->st0 = PEER_SESS_ST_ERRPROTO;
 											goto switchstate;
@@ -1351,7 +1351,7 @@
 							}
 						}
 
-						RWLOCK_WRUNLOCK(STK_SESS_LOCK, &ts->lock);
+						HA_RWLOCK_WRUNLOCK(STK_SESS_LOCK, &ts->lock);
 						stktable_touch_remote(st->table, ts, 1);
 
 					}
@@ -1463,7 +1463,7 @@
 						}
 
 						if (!(curpeer->flags & PEER_F_TEACH_PROCESS)) {
-							SPIN_LOCK(STK_TABLE_LOCK, &st->table->lock);
+							HA_SPIN_LOCK(STK_TABLE_LOCK, &st->table->lock);
 							if (!(curpeer->flags & PEER_F_LEARN_ASSIGN) &&
 							    ((int)(st->last_pushed - st->table->localupdate) < 0)) {
 								struct eb32_node *eb;
@@ -1517,14 +1517,14 @@
 									ts = eb32_entry(eb, struct stksess, upd);
 									updateid = ts->upd.key;
 									ts->ref_cnt++;
-									SPIN_UNLOCK(STK_TABLE_LOCK, &st->table->lock);
+									HA_SPIN_UNLOCK(STK_TABLE_LOCK, &st->table->lock);
 
 									msglen = peer_prepare_updatemsg(ts, st, updateid, trash.str, trash.size, new_pushed, 0);
 									if (!msglen) {
 										/* internal error: message does not fit in trash */
-										SPIN_LOCK(STK_TABLE_LOCK, &st->table->lock);
+										HA_SPIN_LOCK(STK_TABLE_LOCK, &st->table->lock);
 										ts->ref_cnt--;
-										SPIN_UNLOCK(STK_TABLE_LOCK, &st->table->lock);
+										HA_SPIN_UNLOCK(STK_TABLE_LOCK, &st->table->lock);
 										appctx->st0 = PEER_SESS_ST_END;
 										goto switchstate;
 									}
@@ -1533,9 +1533,9 @@
 									repl = ci_putblk(si_ic(si), trash.str, msglen);
 									if (repl <= 0) {
 										/* no more write possible */
-										SPIN_LOCK(STK_TABLE_LOCK, &st->table->lock);
+										HA_SPIN_LOCK(STK_TABLE_LOCK, &st->table->lock);
 										ts->ref_cnt--;
-										SPIN_UNLOCK(STK_TABLE_LOCK, &st->table->lock);
+										HA_SPIN_UNLOCK(STK_TABLE_LOCK, &st->table->lock);
 										if (repl == -1) {
 											goto full;
 										}
@@ -1543,7 +1543,7 @@
 										goto switchstate;
 									}
 
-									SPIN_LOCK(STK_TABLE_LOCK, &st->table->lock);
+									HA_SPIN_LOCK(STK_TABLE_LOCK, &st->table->lock);
 									ts->ref_cnt--;
 									st->last_pushed = updateid;
 									if ((int)(st->last_pushed - st->table->commitupdate) > 0)
@@ -1552,7 +1552,7 @@
 									new_pushed = 0;
 								}
 							}
-							SPIN_UNLOCK(STK_TABLE_LOCK, &st->table->lock);
+							HA_SPIN_UNLOCK(STK_TABLE_LOCK, &st->table->lock);
 						}
 						else {
 							if (!(st->flags & SHTABLE_F_TEACH_STAGE1)) {
@@ -1584,7 +1584,7 @@
 
 								/* We force new pushed to 1 to force identifier in update message */
 								new_pushed = 1;
-								SPIN_LOCK(STK_TABLE_LOCK, &st->table->lock);
+								HA_SPIN_LOCK(STK_TABLE_LOCK, &st->table->lock);
 								while (1) {
 									uint32_t msglen;
 									struct stksess *ts;
@@ -1604,15 +1604,15 @@
 									ts = eb32_entry(eb, struct stksess, upd);
 									updateid = ts->upd.key;
 									ts->ref_cnt++;
-									SPIN_UNLOCK(STK_TABLE_LOCK, &st->table->lock);
+									HA_SPIN_UNLOCK(STK_TABLE_LOCK, &st->table->lock);
 
 									use_timed = !(curpeer->flags & PEER_F_DWNGRD);
 									msglen = peer_prepare_updatemsg(ts, st, updateid, trash.str, trash.size, new_pushed, use_timed);
 									if (!msglen) {
 										/* internal error: message does not fit in trash */
-										SPIN_LOCK(STK_TABLE_LOCK, &st->table->lock);
+										HA_SPIN_LOCK(STK_TABLE_LOCK, &st->table->lock);
 										ts->ref_cnt--;
-										SPIN_UNLOCK(STK_TABLE_LOCK, &st->table->lock);
+										HA_SPIN_UNLOCK(STK_TABLE_LOCK, &st->table->lock);
 										appctx->st0 = PEER_SESS_ST_END;
 										goto switchstate;
 									}
@@ -1621,22 +1621,22 @@
 									repl = ci_putblk(si_ic(si), trash.str, msglen);
 									if (repl <= 0) {
 										/* no more write possible */
-										SPIN_LOCK(STK_TABLE_LOCK, &st->table->lock);
+										HA_SPIN_LOCK(STK_TABLE_LOCK, &st->table->lock);
 										ts->ref_cnt--;
-										SPIN_UNLOCK(STK_TABLE_LOCK, &st->table->lock);
+										HA_SPIN_UNLOCK(STK_TABLE_LOCK, &st->table->lock);
 										if (repl == -1) {
 											goto full;
 										}
 										appctx->st0 = PEER_SESS_ST_END;
 										goto switchstate;
 									}
-									SPIN_LOCK(STK_TABLE_LOCK, &st->table->lock);
+									HA_SPIN_LOCK(STK_TABLE_LOCK, &st->table->lock);
 									ts->ref_cnt--;
 									st->last_pushed = updateid;
 									/* identifier may not needed in next update message */
 									new_pushed = 0;
 								}
-								SPIN_UNLOCK(STK_TABLE_LOCK, &st->table->lock);
+								HA_SPIN_UNLOCK(STK_TABLE_LOCK, &st->table->lock);
 							}
 
 							if (!(st->flags & SHTABLE_F_TEACH_STAGE2)) {
@@ -1668,7 +1668,7 @@
 
 								/* We force new pushed to 1 to force identifier in update message */
 								new_pushed = 1;
-								SPIN_LOCK(STK_TABLE_LOCK, &st->table->lock);
+								HA_SPIN_LOCK(STK_TABLE_LOCK, &st->table->lock);
 								while (1) {
 									uint32_t msglen;
 									struct stksess *ts;
@@ -1687,15 +1687,15 @@
 									ts = eb32_entry(eb, struct stksess, upd);
 									updateid = ts->upd.key;
 									ts->ref_cnt++;
-									SPIN_UNLOCK(STK_TABLE_LOCK, &st->table->lock);
+									HA_SPIN_UNLOCK(STK_TABLE_LOCK, &st->table->lock);
 
 									use_timed = !(curpeer->flags & PEER_F_DWNGRD);
 									msglen = peer_prepare_updatemsg(ts, st, updateid, trash.str, trash.size, new_pushed, use_timed);
 									if (!msglen) {
 										/* internal error: message does not fit in trash */
-										SPIN_LOCK(STK_TABLE_LOCK, &st->table->lock);
+										HA_SPIN_LOCK(STK_TABLE_LOCK, &st->table->lock);
 										ts->ref_cnt--;
-										SPIN_UNLOCK(STK_TABLE_LOCK, &st->table->lock);
+										HA_SPIN_UNLOCK(STK_TABLE_LOCK, &st->table->lock);
 										appctx->st0 = PEER_SESS_ST_END;
 										goto switchstate;
 									}
@@ -1704,9 +1704,9 @@
 									repl = ci_putblk(si_ic(si), trash.str, msglen);
 									if (repl <= 0) {
 										/* no more write possible */
-										SPIN_LOCK(STK_TABLE_LOCK, &st->table->lock);
+										HA_SPIN_LOCK(STK_TABLE_LOCK, &st->table->lock);
 										ts->ref_cnt--;
-										SPIN_UNLOCK(STK_TABLE_LOCK, &st->table->lock);
+										HA_SPIN_UNLOCK(STK_TABLE_LOCK, &st->table->lock);
 										if (repl == -1) {
 											goto full;
 										}
@@ -1714,13 +1714,13 @@
 										goto switchstate;
 									}
 
-									SPIN_LOCK(STK_TABLE_LOCK, &st->table->lock);
+									HA_SPIN_LOCK(STK_TABLE_LOCK, &st->table->lock);
 									ts->ref_cnt--;
 									st->last_pushed = updateid;
 									/* identifier may not needed in next update message */
 									new_pushed = 0;
 								}
-								SPIN_UNLOCK(STK_TABLE_LOCK, &st->table->lock);
+								HA_SPIN_UNLOCK(STK_TABLE_LOCK, &st->table->lock);
 							}
 						}
 
@@ -1803,7 +1803,7 @@
 			}
 			case PEER_SESS_ST_END: {
 				if (curpeer) {
-					SPIN_UNLOCK(PEER_LOCK, &curpeer->lock);
+					HA_SPIN_UNLOCK(PEER_LOCK, &curpeer->lock);
 					curpeer = NULL;
 				}
 				si_shutw(si);
@@ -1817,7 +1817,7 @@
 	si_oc(si)->flags |= CF_READ_DONTWAIT;
 
 	if (curpeer)
-		SPIN_UNLOCK(PEER_LOCK, &curpeer->lock);
+		HA_SPIN_UNLOCK(PEER_LOCK, &curpeer->lock);
 	return;
 full:
 	si_applet_cant_put(si);
@@ -1973,7 +1973,7 @@
 
 	/* Acquire lock for all peers of the section */
 	for (ps = peers->remote; ps; ps = ps->next)
-		SPIN_LOCK(PEER_LOCK, &ps->lock);
+		HA_SPIN_LOCK(PEER_LOCK, &ps->lock);
 
 	if (!stopping) {
 		/* Normal case (not soft stop)*/
@@ -2147,7 +2147,7 @@
 
 	/* Release lock for all peers of the section */
 	for (ps = peers->remote; ps; ps = ps->next)
-		SPIN_UNLOCK(PEER_LOCK, &ps->lock);
+		HA_SPIN_UNLOCK(PEER_LOCK, &ps->lock);
 
 	/* Wakeup for re-connect */
 	return task;
diff --git a/src/proto_http.c b/src/proto_http.c
index 8d813d3..bfce2cf 100644
--- a/src/proto_http.c
+++ b/src/proto_http.c
@@ -2621,9 +2621,9 @@
 
 			/* perform update */
 			/* returned code: 1=ok, 0=ko */
-			SPIN_LOCK(PATREF_LOCK, &ref->lock);
+			HA_SPIN_LOCK(PATREF_LOCK, &ref->lock);
 			pat_ref_delete(ref, key->str);
-			SPIN_UNLOCK(PATREF_LOCK, &ref->lock);
+			HA_SPIN_UNLOCK(PATREF_LOCK, &ref->lock);
 
 			free_trash_chunk(key);
 			break;
@@ -2649,10 +2649,10 @@
 
 			/* perform update */
 			/* add entry only if it does not already exist */
-			SPIN_LOCK(PATREF_LOCK, &ref->lock);
+			HA_SPIN_LOCK(PATREF_LOCK, &ref->lock);
 			if (pat_ref_find_elt(ref, key->str) == NULL)
 				pat_ref_add(ref, key->str, NULL, NULL);
-			SPIN_UNLOCK(PATREF_LOCK, &ref->lock);
+			HA_SPIN_UNLOCK(PATREF_LOCK, &ref->lock);
 
 			free_trash_chunk(key);
 			break;
@@ -2737,7 +2737,7 @@
 					ptr1 = stktable_data_ptr(t, ts, STKTABLE_DT_HTTP_REQ_CNT);
 					ptr2 = stktable_data_ptr(t, ts, STKTABLE_DT_HTTP_REQ_RATE);
 					if (ptr1 || ptr2) {
-						RWLOCK_WRLOCK(STK_SESS_LOCK, &ts->lock);
+						HA_RWLOCK_WRLOCK(STK_SESS_LOCK, &ts->lock);
 
 						if (ptr1)
 							stktable_data_cast(ptr1, http_req_cnt)++;
@@ -2746,7 +2746,7 @@
 							update_freq_ctr_period(&stktable_data_cast(ptr2, http_req_rate),
 							                       t->data_arg[STKTABLE_DT_HTTP_REQ_RATE].u, 1);
 
-						RWLOCK_WRUNLOCK(STK_SESS_LOCK, &ts->lock);
+						HA_RWLOCK_WRUNLOCK(STK_SESS_LOCK, &ts->lock);
 					}
 
 					stkctr_set_flags(&s->stkctr[trk_idx(rule->action)], STKCTR_TRACK_CONTENT);
@@ -2915,9 +2915,9 @@
 
 			/* perform update */
 			/* returned code: 1=ok, 0=ko */
-			SPIN_LOCK(PATREF_LOCK, &ref->lock);
+			HA_SPIN_LOCK(PATREF_LOCK, &ref->lock);
 			pat_ref_delete(ref, key->str);
-			SPIN_UNLOCK(PATREF_LOCK, &ref->lock);
+			HA_SPIN_UNLOCK(PATREF_LOCK, &ref->lock);
 
 			free_trash_chunk(key);
 			break;
@@ -2980,14 +2980,14 @@
 			value->str[value->len] = '\0';
 
 			/* perform update */
-			SPIN_LOCK(PATREF_LOCK, &ref->lock);
+			HA_SPIN_LOCK(PATREF_LOCK, &ref->lock);
 			if (pat_ref_find_elt(ref, key->str) != NULL)
 				/* update entry if it exists */
 				pat_ref_set(ref, key->str, value->str, NULL);
 			else
 				/* insert a new entry */
 				pat_ref_add(ref, key->str, value->str, NULL);
-			SPIN_UNLOCK(PATREF_LOCK, &ref->lock);
+			HA_SPIN_UNLOCK(PATREF_LOCK, &ref->lock);
 			free_trash_chunk(key);
 			free_trash_chunk(value);
 			break;
@@ -3015,7 +3015,7 @@
 				if (key && (ts = stktable_get_entry(t, key))) {
 					stream_track_stkctr(&s->stkctr[trk_idx(rule->action)], t, ts);
 
-					RWLOCK_WRLOCK(STK_SESS_LOCK, &ts->lock);
+					HA_RWLOCK_WRLOCK(STK_SESS_LOCK, &ts->lock);
 
 					/* let's count a new HTTP request as it's the first time we do it */
 					ptr = stktable_data_ptr(t, ts, STKTABLE_DT_HTTP_REQ_CNT);
@@ -3045,7 +3045,7 @@
 									       t->data_arg[STKTABLE_DT_HTTP_ERR_RATE].u, 1);
 					}
 
-					RWLOCK_WRUNLOCK(STK_SESS_LOCK, &ts->lock);
+					HA_RWLOCK_WRUNLOCK(STK_SESS_LOCK, &ts->lock);
 
 					stkctr_set_flags(&s->stkctr[trk_idx(rule->action)], STKCTR_TRACK_CONTENT);
 					if (sess->fe != s->be)
@@ -7755,7 +7755,7 @@
 	struct channel *chn = msg->chn;
 	int len1, len2;
 
-	SPIN_LOCK(PROXY_LOCK, &proxy->lock);
+	HA_SPIN_LOCK(PROXY_LOCK, &proxy->lock);
 	es->len = MIN(chn->buf->i, global.tune.bufsize);
 	len1 = chn->buf->data + chn->buf->size - chn->buf->p;
 	len1 = MIN(len1, es->len);
@@ -7795,7 +7795,7 @@
 	es->b_tot = chn->total;
 	es->m_clen = msg->chunk_len;
 	es->m_blen = msg->body_len;
-	SPIN_UNLOCK(PROXY_LOCK, &proxy->lock);
+	HA_SPIN_UNLOCK(PROXY_LOCK, &proxy->lock);
 }
 
 /* Return in <vptr> and <vlen> the pointer and length of occurrence <occ> of
diff --git a/src/proxy.c b/src/proxy.c
index 9169ed9..3af01ef 100644
--- a/src/proxy.c
+++ b/src/proxy.c
@@ -762,7 +762,7 @@
 	/* initial uuid is unassigned (-1) */
 	p->uuid = -1;
 
-	SPIN_INIT(&p->lock);
+	HA_SPIN_INIT(&p->lock);
 }
 
 /*
diff --git a/src/queue.c b/src/queue.c
index 93d3e94..481b506 100644
--- a/src/queue.c
+++ b/src/queue.c
@@ -142,8 +142,8 @@
 	struct proxy  *p = s->proxy;
 	int maxconn;
 
-	SPIN_LOCK(PROXY_LOCK,  &p->lock);
-	SPIN_LOCK(SERVER_LOCK, &s->lock);
+	HA_SPIN_LOCK(PROXY_LOCK,  &p->lock);
+	HA_SPIN_LOCK(SERVER_LOCK, &s->lock);
 
 	/* First, check if we can handle some connections queued at the proxy. We
 	 * will take as many as we can handle.
@@ -156,8 +156,8 @@
 			break;
 		task_wakeup(strm->task, TASK_WOKEN_RES);
 	}
-	SPIN_UNLOCK(SERVER_LOCK, &s->lock);
-	SPIN_UNLOCK(PROXY_LOCK,  &p->lock);
+	HA_SPIN_UNLOCK(SERVER_LOCK, &s->lock);
+	HA_SPIN_UNLOCK(PROXY_LOCK,  &p->lock);
 }
 
 /* Adds the stream <strm> to the pending connection list of server <strm>->srv
@@ -182,17 +182,17 @@
 
 	if ((strm->flags & SF_ASSIGNED) && srv) {
 		p->srv = srv;
-		SPIN_LOCK(SERVER_LOCK, &srv->lock);
+		HA_SPIN_LOCK(SERVER_LOCK, &srv->lock);
 		LIST_ADDQ(&srv->pendconns, &p->list);
-		SPIN_UNLOCK(SERVER_LOCK, &srv->lock);
+		HA_SPIN_UNLOCK(SERVER_LOCK, &srv->lock);
 		count = HA_ATOMIC_ADD(&srv->nbpend, 1);
 		strm->logs.srv_queue_size += count;
 		HA_ATOMIC_UPDATE_MAX(&srv->counters.nbpend_max, count);
 	} else {
 		p->srv = NULL;
-		SPIN_LOCK(PROXY_LOCK, &strm->be->lock);
+		HA_SPIN_LOCK(PROXY_LOCK, &strm->be->lock);
 		LIST_ADDQ(&strm->be->pendconns, &p->list);
-		SPIN_UNLOCK(PROXY_LOCK, &strm->be->lock);
+		HA_SPIN_UNLOCK(PROXY_LOCK, &strm->be->lock);
 		count = HA_ATOMIC_ADD(&strm->be->nbpend, 1);
 		strm->logs.prx_queue_size += count;
 		HA_ATOMIC_UPDATE_MAX(&strm->be->be_counters.nbpend_max, count);
@@ -209,7 +209,7 @@
 	struct pendconn *pc, *pc_bck;
 	int xferred = 0;
 
-	SPIN_LOCK(SERVER_LOCK, &s->lock);
+	HA_SPIN_LOCK(SERVER_LOCK, &s->lock);
 	list_for_each_entry_safe(pc, pc_bck, &s->pendconns, list) {
 		struct stream *strm = pc->strm;
 
@@ -227,7 +227,7 @@
 			xferred++;
 		}
 	}
-	SPIN_UNLOCK(SERVER_LOCK, &s->lock);
+	HA_SPIN_UNLOCK(SERVER_LOCK, &s->lock);
 	return xferred;
 }
 
@@ -243,7 +243,7 @@
 	if (!srv_currently_usable(s))
 		return 0;
 
-	SPIN_LOCK(PROXY_LOCK, &s->proxy->lock);
+	HA_SPIN_LOCK(PROXY_LOCK, &s->proxy->lock);
 	for (xferred = 0; !s->maxconn || xferred < srv_dynamic_maxconn(s); xferred++) {
 		struct stream *strm;
 		struct pendconn *p;
@@ -256,7 +256,7 @@
 		__pendconn_free(p);
 		task_wakeup(strm->task, TASK_WOKEN_RES);
 	}
-	SPIN_UNLOCK(PROXY_LOCK, &s->proxy->lock);
+	HA_SPIN_UNLOCK(PROXY_LOCK, &s->proxy->lock);
 	return xferred;
 }
 
@@ -268,15 +268,15 @@
 void pendconn_free(struct pendconn *p)
 {
 	if (p->srv) {
-		SPIN_LOCK(SERVER_LOCK, &p->srv->lock);
+		HA_SPIN_LOCK(SERVER_LOCK, &p->srv->lock);
 		LIST_DEL(&p->list);
-		SPIN_UNLOCK(SERVER_LOCK, &p->srv->lock);
+		HA_SPIN_UNLOCK(SERVER_LOCK, &p->srv->lock);
 		HA_ATOMIC_SUB(&p->srv->nbpend, 1);
 	}
 	else {
-		SPIN_LOCK(SERVER_LOCK, &p->strm->be->lock);
+		HA_SPIN_LOCK(SERVER_LOCK, &p->strm->be->lock);
 		LIST_DEL(&p->list);
-		SPIN_UNLOCK(SERVER_LOCK, &p->strm->be->lock);
+		HA_SPIN_UNLOCK(SERVER_LOCK, &p->strm->be->lock);
 		HA_ATOMIC_SUB(&p->strm->be->nbpend, 1);
 	}
 	p->strm->pend_pos = NULL;
diff --git a/src/server.c b/src/server.c
index 1a78fb3..d79e951 100644
--- a/src/server.c
+++ b/src/server.c
@@ -881,9 +881,9 @@
 
 	srv_register_update(s);
 	for (srv = s->trackers; srv; srv = srv->tracknext) {
-		SPIN_LOCK(SERVER_LOCK, &srv->lock);
+		HA_SPIN_LOCK(SERVER_LOCK, &srv->lock);
 		srv_set_stopped(srv, NULL, NULL);
-		SPIN_UNLOCK(SERVER_LOCK, &srv->lock);
+		HA_SPIN_UNLOCK(SERVER_LOCK, &srv->lock);
 	}
 }
 
@@ -923,9 +923,9 @@
 
 	srv_register_update(s);
 	for (srv = s->trackers; srv; srv = srv->tracknext) {
-		SPIN_LOCK(SERVER_LOCK, &srv->lock);
+		HA_SPIN_LOCK(SERVER_LOCK, &srv->lock);
 		srv_set_running(srv, NULL, NULL);
-		SPIN_UNLOCK(SERVER_LOCK, &srv->lock);
+		HA_SPIN_UNLOCK(SERVER_LOCK, &srv->lock);
 	}
 }
 
@@ -964,9 +964,9 @@
 
 	srv_register_update(s);
 	for (srv = s->trackers; srv; srv = srv->tracknext) {
-		SPIN_LOCK(SERVER_LOCK, &srv->lock);
+		HA_SPIN_LOCK(SERVER_LOCK, &srv->lock);
 		srv_set_stopping(srv, NULL, NULL);
-		SPIN_LOCK(SERVER_LOCK, &srv->lock);
+		HA_SPIN_LOCK(SERVER_LOCK, &srv->lock);
 	}
 }
 
@@ -1007,9 +1007,9 @@
 		mode = SRV_ADMF_IDRAIN;
 
 	for (srv = s->trackers; srv; srv = srv->tracknext) {
-		SPIN_LOCK(SERVER_LOCK, &srv->lock);
+		HA_SPIN_LOCK(SERVER_LOCK, &srv->lock);
 		srv_set_admin_flag(srv, mode, cause);
-		SPIN_LOCK(SERVER_LOCK, &srv->lock);
+		HA_SPIN_LOCK(SERVER_LOCK, &srv->lock);
 	}
 }
 
@@ -1045,9 +1045,9 @@
 		mode = SRV_ADMF_IDRAIN;
 
 	for (srv = s->trackers; srv; srv = srv->tracknext) {
-		SPIN_LOCK(SERVER_LOCK, &srv->lock);
+		HA_SPIN_LOCK(SERVER_LOCK, &srv->lock);
 		srv_clr_admin_flag(srv, mode);
-		SPIN_UNLOCK(SERVER_LOCK, &srv->lock);
+		HA_SPIN_UNLOCK(SERVER_LOCK, &srv->lock);
 	}
 }
 
@@ -1062,13 +1062,13 @@
 		return;
 
 	for (srv2 = srv->trackers; srv2; srv2 = srv2->tracknext) {
-		SPIN_LOCK(SERVER_LOCK, &srv2->lock);
+		HA_SPIN_LOCK(SERVER_LOCK, &srv2->lock);
 		if (srv->next_admin & (SRV_ADMF_MAINT | SRV_ADMF_CMAINT))
 			srv_set_admin_flag(srv2, SRV_ADMF_IMAINT, NULL);
 
 		if (srv->next_admin & SRV_ADMF_DRAIN)
 			srv_set_admin_flag(srv2, SRV_ADMF_IDRAIN, NULL);
-		SPIN_UNLOCK(SERVER_LOCK, &srv2->lock);
+		HA_SPIN_UNLOCK(SERVER_LOCK, &srv2->lock);
 	}
 }
 
@@ -2028,7 +2028,7 @@
 
 			/* Copy default server settings to new server settings. */
 			srv_settings_cpy(newsrv, &curproxy->defsrv, 0);
-			SPIN_INIT(&newsrv->lock);
+			HA_SPIN_INIT(&newsrv->lock);
 			cur_arg++;
 		} else {
 			newsrv = &curproxy->defsrv;
@@ -2600,10 +2600,10 @@
 {
 	if (LIST_ISEMPTY(&srv->update_status)) {
 		THREAD_WANT_SYNC();
-		SPIN_LOCK(UPDATED_SERVERS_LOCK, &updated_servers_lock);
+		HA_SPIN_LOCK(UPDATED_SERVERS_LOCK, &updated_servers_lock);
 		if (LIST_ISEMPTY(&srv->update_status))
 			LIST_ADDQ(&updated_servers, &srv->update_status);
-		SPIN_UNLOCK(UPDATED_SERVERS_LOCK, &updated_servers_lock);
+		HA_SPIN_UNLOCK(UPDATED_SERVERS_LOCK, &updated_servers_lock);
 	}
 }
 
@@ -2789,7 +2789,7 @@
 			if (msg->len)
 				goto out;
 
-			SPIN_LOCK(SERVER_LOCK, &srv->lock);
+			HA_SPIN_LOCK(SERVER_LOCK, &srv->lock);
 			/* recover operational state and apply it to this server
 			 * and all servers tracking this one */
 			switch (srv_op_state) {
@@ -2919,7 +2919,7 @@
 
 			if (port_str)
 				srv->svc_port = port;
-			SPIN_UNLOCK(SERVER_LOCK, &srv->lock);
+			HA_SPIN_UNLOCK(SERVER_LOCK, &srv->lock);
 
 			break;
 		default:
@@ -3696,9 +3696,9 @@
 	s = objt_server(requester->owner);
 	if (!s)
 		return 1;
-	SPIN_LOCK(SERVER_LOCK, &s->lock);
+	HA_SPIN_LOCK(SERVER_LOCK, &s->lock);
 	snr_update_srv_status(s, 0);
-	SPIN_UNLOCK(SERVER_LOCK, &s->lock);
+	HA_SPIN_UNLOCK(SERVER_LOCK, &s->lock);
 	return 1;
 }
 
@@ -3731,18 +3731,18 @@
 		 *     one used for the server found in the backend
 		 *   * the server found in the backend is not our current server
 		 */
-		SPIN_LOCK(SERVER_LOCK, &tmpsrv->lock);
+		HA_SPIN_LOCK(SERVER_LOCK, &tmpsrv->lock);
 		if ((tmpsrv->hostname_dn == NULL) ||
 		    (srv->hostname_dn_len != tmpsrv->hostname_dn_len) ||
 		    (strcmp(srv->hostname_dn, tmpsrv->hostname_dn) != 0) ||
 		    (srv->puid == tmpsrv->puid)) {
-			SPIN_UNLOCK(SERVER_LOCK, &tmpsrv->lock);
+			HA_SPIN_UNLOCK(SERVER_LOCK, &tmpsrv->lock);
 			continue;
 		}
 
 		/* If the server has been taken down, don't consider it */
 		if (tmpsrv->next_admin & SRV_ADMF_RMAINT) {
-			SPIN_UNLOCK(SERVER_LOCK, &tmpsrv->lock);
+			HA_SPIN_UNLOCK(SERVER_LOCK, &tmpsrv->lock);
 			continue;
 		}
 
@@ -3754,10 +3754,10 @@
 		      memcmp(ip, &((struct sockaddr_in *)&tmpsrv->addr)->sin_addr, 4) == 0) ||
 		     (tmpsrv->addr.ss_family == AF_INET6 &&
 		      memcmp(ip, &((struct sockaddr_in6 *)&tmpsrv->addr)->sin6_addr, 16) == 0))) {
-			SPIN_UNLOCK(SERVER_LOCK, &tmpsrv->lock);
+			HA_SPIN_UNLOCK(SERVER_LOCK, &tmpsrv->lock);
 			return tmpsrv;
 		}
-		SPIN_UNLOCK(SERVER_LOCK, &tmpsrv->lock);
+		HA_SPIN_UNLOCK(SERVER_LOCK, &tmpsrv->lock);
 	}
 
 
@@ -3789,7 +3789,7 @@
 	int                    hostname_len, hostname_dn_len;
 
 	if (!dns_locked)
-		SPIN_LOCK(DNS_LOCK, &srv->resolvers->lock);
+		HA_SPIN_LOCK(DNS_LOCK, &srv->resolvers->lock);
 	/* run time DNS resolution was not active for this server
 	 * and we can't enable it at run time for now.
 	 */
@@ -3825,12 +3825,12 @@
 
   end:
 	if (!dns_locked)
-		SPIN_UNLOCK(DNS_LOCK, &srv->resolvers->lock);
+		HA_SPIN_UNLOCK(DNS_LOCK, &srv->resolvers->lock);
 	return 0;
 
   err:
 	if (!dns_locked)
-		SPIN_UNLOCK(DNS_LOCK, &srv->resolvers->lock);
+		HA_SPIN_UNLOCK(DNS_LOCK, &srv->resolvers->lock);
 	return -1;
 }
 
@@ -4053,7 +4053,7 @@
 	if (!sv)
 		return 1;
 
-	SPIN_LOCK(SERVER_LOCK, &sv->lock);
+	HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
 
 	if (strcmp(args[3], "weight") == 0) {
 		warning = server_parse_weight_change_request(sv, args[4]);
@@ -4220,7 +4220,7 @@
 		appctx->st0 = CLI_ST_PRINT;
 	}
  out_unlock:
-	SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
+	HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
 	return 1;
 }
 
@@ -4427,7 +4427,7 @@
 __attribute__((constructor))
 static void __server_init(void)
 {
-	SPIN_INIT(&updated_servers_lock);
+	HA_SPIN_INIT(&updated_servers_lock);
 	cli_register_kw(&cli_kws);
 }
 
diff --git a/src/signal.c b/src/signal.c
index 14e4f1e..3409e76 100644
--- a/src/signal.c
+++ b/src/signal.c
@@ -73,7 +73,7 @@
 	struct signal_descriptor *desc;
 	sigset_t old_sig;
 
-	if (SPIN_TRYLOCK(SIGNALS_LOCK, &signals_lock))
+	if (HA_SPIN_TRYLOCK(SIGNALS_LOCK, &signals_lock))
 		return;
 
 	/* block signal delivery during processing */
@@ -102,7 +102,7 @@
 
 	/* restore signal delivery */
 	sigprocmask(SIG_SETMASK, &old_sig, NULL);
-	SPIN_UNLOCK(SIGNALS_LOCK, &signals_lock);
+	HA_SPIN_UNLOCK(SIGNALS_LOCK, &signals_lock);
 }
 
 /* perform minimal intializations, report 0 in case of error, 1 if OK. */
@@ -114,7 +114,7 @@
 	memset(signal_queue, 0, sizeof(signal_queue));
 	memset(signal_state, 0, sizeof(signal_state));
 
-	SPIN_INIT(&signals_lock);
+	HA_SPIN_INIT(&signals_lock);
 
 	/* Ensure signals are not blocked. Some shells or service managers may
 	 * accidently block all of our signals unfortunately, causing lots of
@@ -150,7 +150,7 @@
 			pool_free2(pool2_sig_handlers, sh);
 		}
 	}
-	SPIN_DESTROY(&signals_lock);
+	HA_SPIN_DESTROY(&signals_lock);
 }
 
 /* Register a function and an integer argument on a signal. A pointer to the
diff --git a/src/ssl_sock.c b/src/ssl_sock.c
index b1d39db..597a479 100644
--- a/src/ssl_sock.c
+++ b/src/ssl_sock.c
@@ -218,15 +218,15 @@
 {
 	if (mode & CRYPTO_LOCK) {
 		if (mode & CRYPTO_READ)
-			RWLOCK_RDLOCK(SSL_LOCK, &ssl_rwlocks[n]);
+			HA_RWLOCK_RDLOCK(SSL_LOCK, &ssl_rwlocks[n]);
 		else
-			RWLOCK_WRLOCK(SSL_LOCK, &ssl_rwlocks[n]);
+			HA_RWLOCK_WRLOCK(SSL_LOCK, &ssl_rwlocks[n]);
 	}
 	else {
 		if (mode & CRYPTO_READ)
-			RWLOCK_RDUNLOCK(SSL_LOCK, &ssl_rwlocks[n]);
+			HA_RWLOCK_RDUNLOCK(SSL_LOCK, &ssl_rwlocks[n]);
 		else
-			RWLOCK_WRUNLOCK(SSL_LOCK, &ssl_rwlocks[n]);
+			HA_RWLOCK_WRUNLOCK(SSL_LOCK, &ssl_rwlocks[n]);
 	}
 }
 
@@ -239,7 +239,7 @@
 		return -1;
 
 	for (i = 0 ; i < CRYPTO_num_locks() ; i++)
-		RWLOCK_INIT(&ssl_rwlocks[i]);
+		HA_RWLOCK_INIT(&ssl_rwlocks[i]);
 
 	CRYPTO_set_id_callback(ssl_id_function);
 	CRYPTO_set_locking_callback(ssl_locking_function);
@@ -1795,15 +1795,15 @@
 	struct lru64 *lru = NULL;
 
 	if (ssl_ctx_lru_tree) {
-		RWLOCK_RDLOCK(SSL_GEN_CERTS_LOCK, &ssl_ctx_lru_rwlock);
+		HA_RWLOCK_RDLOCK(SSL_GEN_CERTS_LOCK, &ssl_ctx_lru_rwlock);
 		lru = lru64_lookup(key, ssl_ctx_lru_tree, bind_conf->ca_sign_cert, 0);
 		if (lru && lru->domain) {
 			if (ssl)
 				SSL_set_SSL_CTX(ssl, (SSL_CTX *)lru->data);
-			RWLOCK_RDUNLOCK(SSL_GEN_CERTS_LOCK, &ssl_ctx_lru_rwlock);
+			HA_RWLOCK_RDUNLOCK(SSL_GEN_CERTS_LOCK, &ssl_ctx_lru_rwlock);
 			return (SSL_CTX *)lru->data;
 		}
-		RWLOCK_RDUNLOCK(SSL_GEN_CERTS_LOCK, &ssl_ctx_lru_rwlock);
+		HA_RWLOCK_RDUNLOCK(SSL_GEN_CERTS_LOCK, &ssl_ctx_lru_rwlock);
 	}
 	return NULL;
 }
@@ -1826,16 +1826,16 @@
 	struct lru64 *lru = NULL;
 
 	if (ssl_ctx_lru_tree) {
-		RWLOCK_WRLOCK(SSL_GEN_CERTS_LOCK, &ssl_ctx_lru_rwlock);
+		HA_RWLOCK_WRLOCK(SSL_GEN_CERTS_LOCK, &ssl_ctx_lru_rwlock);
 		lru = lru64_get(key, ssl_ctx_lru_tree, bind_conf->ca_sign_cert, 0);
 		if (!lru) {
-			RWLOCK_WRUNLOCK(SSL_GEN_CERTS_LOCK, &ssl_ctx_lru_rwlock);
+			HA_RWLOCK_WRUNLOCK(SSL_GEN_CERTS_LOCK, &ssl_ctx_lru_rwlock);
 			return -1;
 		}
 		if (lru->domain && lru->data)
 			lru->free((SSL_CTX *)lru->data);
 		lru64_commit(lru, ssl_ctx, bind_conf->ca_sign_cert, 0, (void (*)(void *))SSL_CTX_free);
-		RWLOCK_WRUNLOCK(SSL_GEN_CERTS_LOCK, &ssl_ctx_lru_rwlock);
+		HA_RWLOCK_WRUNLOCK(SSL_GEN_CERTS_LOCK, &ssl_ctx_lru_rwlock);
 		return 0;
 	}
 	return -1;
@@ -1861,7 +1861,7 @@
 
 	key = ssl_sock_generated_cert_key(servername, strlen(servername));
 	if (ssl_ctx_lru_tree) {
-		RWLOCK_WRLOCK(SSL_GEN_CERTS_LOCK, &ssl_ctx_lru_rwlock);
+		HA_RWLOCK_WRLOCK(SSL_GEN_CERTS_LOCK, &ssl_ctx_lru_rwlock);
 		lru = lru64_get(key, ssl_ctx_lru_tree, cacert, 0);
 		if (lru && lru->domain)
 			ssl_ctx = (SSL_CTX *)lru->data;
@@ -1870,7 +1870,7 @@
 			lru64_commit(lru, ssl_ctx, cacert, 0, (void (*)(void *))SSL_CTX_free);
 		}
 		SSL_set_SSL_CTX(ssl, ssl_ctx);
-		RWLOCK_WRUNLOCK(SSL_GEN_CERTS_LOCK, &ssl_ctx_lru_rwlock);
+		HA_RWLOCK_WRUNLOCK(SSL_GEN_CERTS_LOCK, &ssl_ctx_lru_rwlock);
 		return 1;
 	}
 	else {
@@ -4782,7 +4782,7 @@
 #if (defined SSL_CTRL_SET_TLSEXT_HOSTNAME && !defined SSL_NO_GENERATE_CERTIFICATES)
 	if (global_ssl.ctx_cache) {
 		ssl_ctx_lru_tree = lru64_new(global_ssl.ctx_cache);
-		RWLOCK_INIT(&ssl_ctx_lru_rwlock);
+		HA_RWLOCK_INIT(&ssl_ctx_lru_rwlock);
 	}
 	ssl_ctx_lru_seed = (unsigned int)time(NULL);
 	ssl_ctx_serial   = now_ms;
@@ -8803,7 +8803,7 @@
 #if (defined SSL_CTRL_SET_TLSEXT_HOSTNAME && !defined SSL_NO_GENERATE_CERTIFICATES)
 	if (ssl_ctx_lru_tree) {
 		lru64_destroy(ssl_ctx_lru_tree);
-		RWLOCK_DESTROY(&ssl_ctx_lru_rwlock);
+		HA_RWLOCK_DESTROY(&ssl_ctx_lru_rwlock);
 	}
 #endif
 
diff --git a/src/stats.c b/src/stats.c
index 1e4d6ff..038c074 100644
--- a/src/stats.c
+++ b/src/stats.c
@@ -2764,7 +2764,7 @@
 					reprocess = 1;
 				}
 				else if ((sv = findserver(px, value)) != NULL) {
-					SPIN_LOCK(SERVER_LOCK, &sv->lock);
+					HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
 					switch (action) {
 					case ST_ADM_ACTION_DISABLE:
 						if (!(sv->cur_admin & SRV_ADMF_FMAINT)) {
@@ -2890,7 +2890,7 @@
 						}
 						break;
 					}
-					SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
+					HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
 				} else {
 					/* the server name is unknown or ambiguous (duplicate names) */
 					total_servers++;
diff --git a/src/stick_table.c b/src/stick_table.c
index 4810c7f..6351143 100644
--- a/src/stick_table.c
+++ b/src/stick_table.c
@@ -61,9 +61,9 @@
  */
 void stksess_free(struct stktable *t, struct stksess *ts)
 {
-	SPIN_LOCK(STK_TABLE_LOCK, &t->lock);
+	HA_SPIN_LOCK(STK_TABLE_LOCK, &t->lock);
 	__stksess_free(t, ts);
-	SPIN_UNLOCK(STK_TABLE_LOCK, &t->lock);
+	HA_SPIN_UNLOCK(STK_TABLE_LOCK, &t->lock);
 }
 
 /*
@@ -90,11 +90,11 @@
 {
 	int ret;
 
-	SPIN_LOCK(STK_TABLE_LOCK, &t->lock);
+	HA_SPIN_LOCK(STK_TABLE_LOCK, &t->lock);
 	if (decrefcnt)
 		ts->ref_cnt--;
 	ret = __stksess_kill(t, ts);
-	SPIN_UNLOCK(STK_TABLE_LOCK, &t->lock);
+	HA_SPIN_UNLOCK(STK_TABLE_LOCK, &t->lock);
 
 	return ret;
 }
@@ -126,7 +126,7 @@
 	ts->exp.node.leaf_p = NULL;
 	ts->upd.node.leaf_p = NULL;
 	ts->expire = tick_add(now_ms, MS_TO_TICKS(t->expire));
-	RWLOCK_INIT(&ts->lock);
+	HA_RWLOCK_INIT(&ts->lock);
 	return ts;
 }
 
@@ -201,9 +201,9 @@
 {
 	int ret;
 
-	SPIN_LOCK(STK_TABLE_LOCK, &t->lock);
+	HA_SPIN_LOCK(STK_TABLE_LOCK, &t->lock);
 	ret = __stktable_trash_oldest(t, to_batch);
-	SPIN_UNLOCK(STK_TABLE_LOCK, &t->lock);
+	HA_SPIN_UNLOCK(STK_TABLE_LOCK, &t->lock);
 
 	return ret;
 }
@@ -249,9 +249,9 @@
 {
 	struct stksess *ts;
 
-	SPIN_LOCK(STK_TABLE_LOCK, &t->lock);
+	HA_SPIN_LOCK(STK_TABLE_LOCK, &t->lock);
 	ts = __stksess_new(t, key);
-	SPIN_UNLOCK(STK_TABLE_LOCK, &t->lock);
+	HA_SPIN_UNLOCK(STK_TABLE_LOCK, &t->lock);
 
 	return ts;
 }
@@ -287,11 +287,11 @@
 {
 	struct stksess *ts;
 
-	SPIN_LOCK(STK_TABLE_LOCK, &t->lock);
+	HA_SPIN_LOCK(STK_TABLE_LOCK, &t->lock);
 	ts = __stktable_lookup_key(t, key);
 	if (ts)
 		ts->ref_cnt++;
-	SPIN_UNLOCK(STK_TABLE_LOCK, &t->lock);
+	HA_SPIN_UNLOCK(STK_TABLE_LOCK, &t->lock);
 
 	return ts;
 }
@@ -325,11 +325,11 @@
 {
 	struct stksess *lts;
 
-	SPIN_LOCK(STK_TABLE_LOCK, &t->lock);
+	HA_SPIN_LOCK(STK_TABLE_LOCK, &t->lock);
 	lts = __stktable_lookup(t, ts);
 	if (lts)
 		lts->ref_cnt++;
-	SPIN_UNLOCK(STK_TABLE_LOCK, &t->lock);
+	HA_SPIN_UNLOCK(STK_TABLE_LOCK, &t->lock);
 
 	return lts;
 }
@@ -389,11 +389,11 @@
  */
 void stktable_touch_remote(struct stktable *t, struct stksess *ts, int decrefcnt)
 {
-	SPIN_LOCK(STK_TABLE_LOCK, &t->lock);
+	HA_SPIN_LOCK(STK_TABLE_LOCK, &t->lock);
 	__stktable_touch_with_exp(t, ts, 0, ts->expire);
 	if (decrefcnt)
 		ts->ref_cnt--;
-	SPIN_UNLOCK(STK_TABLE_LOCK, &t->lock);
+	HA_SPIN_UNLOCK(STK_TABLE_LOCK, &t->lock);
 }
 
 /* Update the expiration timer for <ts> but do not touch its expiration node.
@@ -406,18 +406,18 @@
 {
 	int expire = tick_add(now_ms, MS_TO_TICKS(t->expire));
 
-	SPIN_LOCK(STK_TABLE_LOCK, &t->lock);
+	HA_SPIN_LOCK(STK_TABLE_LOCK, &t->lock);
 	__stktable_touch_with_exp(t, ts, 1, expire);
 	if (decrefcnt)
 		ts->ref_cnt--;
-	SPIN_UNLOCK(STK_TABLE_LOCK, &t->lock);
+	HA_SPIN_UNLOCK(STK_TABLE_LOCK, &t->lock);
 }
 /* Just decrease the ref_cnt of the current session */
 void stktable_release(struct stktable *t, struct stksess *ts)
 {
-	SPIN_LOCK(STK_TABLE_LOCK, &t->lock);
+	HA_SPIN_LOCK(STK_TABLE_LOCK, &t->lock);
 	ts->ref_cnt--;
-	SPIN_UNLOCK(STK_TABLE_LOCK, &t->lock);
+	HA_SPIN_UNLOCK(STK_TABLE_LOCK, &t->lock);
 }
 
 /* Insert new sticky session <ts> in the table. It is assumed that it does not
@@ -466,11 +466,11 @@
 {
 	struct stksess *ts;
 
-	SPIN_LOCK(STK_TABLE_LOCK, &table->lock);
+	HA_SPIN_LOCK(STK_TABLE_LOCK, &table->lock);
 	ts = __stktable_get_entry(table, key);
 	if (ts)
 		ts->ref_cnt++;
-	SPIN_UNLOCK(STK_TABLE_LOCK, &table->lock);
+	HA_SPIN_UNLOCK(STK_TABLE_LOCK, &table->lock);
 
 	return ts;
 }
@@ -498,10 +498,10 @@
 {
 	struct stksess *ts;
 
-	SPIN_LOCK(STK_TABLE_LOCK, &table->lock);
+	HA_SPIN_LOCK(STK_TABLE_LOCK, &table->lock);
 	ts = __stktable_set_entry(table, nts);
 	ts->ref_cnt++;
-	SPIN_UNLOCK(STK_TABLE_LOCK, &table->lock);
+	HA_SPIN_UNLOCK(STK_TABLE_LOCK, &table->lock);
 
 	return ts;
 }
@@ -515,7 +515,7 @@
 	struct eb32_node *eb;
 	int looped = 0;
 
-	SPIN_LOCK(STK_TABLE_LOCK, &t->lock);
+	HA_SPIN_LOCK(STK_TABLE_LOCK, &t->lock);
 	eb = eb32_lookup_ge(&t->exps, now_ms - TIMER_LOOK_BACK);
 
 	while (1) {
@@ -570,7 +570,7 @@
 	/* We have found no task to expire in any tree */
 	t->exp_next = TICK_ETERNITY;
 out_unlock:
-	SPIN_UNLOCK(STK_TABLE_LOCK, &t->lock);
+	HA_SPIN_UNLOCK(STK_TABLE_LOCK, &t->lock);
 	return t->exp_next;
 }
 
@@ -593,7 +593,7 @@
 		t->keys = EB_ROOT_UNIQUE;
 		memset(&t->exps, 0, sizeof(t->exps));
 		t->updates = EB_ROOT_UNIQUE;
-		SPIN_INIT(&t->lock);
+		HA_SPIN_INIT(&t->lock);
 
 		t->pool = create_pool("sticktables", sizeof(struct stksess) + t->data_size + t->key_size, MEM_F_SHARED);
 
@@ -1546,7 +1546,7 @@
 		ptr1 = stktable_data_ptr(stkctr->table, ts, STKTABLE_DT_GPC0_RATE);
 		ptr2 = stktable_data_ptr(stkctr->table, ts, STKTABLE_DT_GPC0);
 		if (ptr1 || ptr2) {
-			RWLOCK_WRLOCK(STK_SESS_LOCK, &ts->lock);
+			HA_RWLOCK_WRLOCK(STK_SESS_LOCK, &ts->lock);
 
 			if (ptr1)
 				update_freq_ctr_period(&stktable_data_cast(ptr1, gpc0_rate),
@@ -1555,7 +1555,7 @@
 			if (ptr2)
 				stktable_data_cast(ptr2, gpc0)++;
 
-			RWLOCK_WRUNLOCK(STK_SESS_LOCK, &ts->lock);
+			HA_RWLOCK_WRUNLOCK(STK_SESS_LOCK, &ts->lock);
 
 			/* If data was modified, we need to touch to re-schedule sync */
 			stktable_touch_local(stkctr->table, ts, 0);
@@ -1628,11 +1628,11 @@
 	/* Store the sample in the required sc, and ignore errors. */
 	ptr = stktable_data_ptr(stkctr->table, ts, STKTABLE_DT_GPT0);
 	if (ptr) {
-		RWLOCK_WRLOCK(STK_SESS_LOCK, &ts->lock);
+		HA_RWLOCK_WRLOCK(STK_SESS_LOCK, &ts->lock);
 
 		stktable_data_cast(ptr, gpt0) = rule->arg.gpt.value;
 
-		RWLOCK_WRUNLOCK(STK_SESS_LOCK, &ts->lock);
+		HA_RWLOCK_WRUNLOCK(STK_SESS_LOCK, &ts->lock);
 
 		stktable_touch_local(stkctr->table, ts, 0);
 	}
@@ -1887,11 +1887,11 @@
 			return 0; /* parameter not stored */
 		}
 
-		RWLOCK_RDLOCK(STK_SESS_LOCK, &stkctr_entry(stkctr)->lock);
+		HA_RWLOCK_RDLOCK(STK_SESS_LOCK, &stkctr_entry(stkctr)->lock);
 
 		smp->data.u.sint = stktable_data_cast(ptr, gpt0);
 
-		RWLOCK_RDUNLOCK(STK_SESS_LOCK, &stkctr_entry(stkctr)->lock);
+		HA_RWLOCK_RDUNLOCK(STK_SESS_LOCK, &stkctr_entry(stkctr)->lock);
 
 		if (stkctr == &tmpstkctr)
 			stktable_release(stkctr->table, stkctr_entry(stkctr));
@@ -1928,11 +1928,11 @@
 			return 0; /* parameter not stored */
 		}
 
-		RWLOCK_RDLOCK(STK_SESS_LOCK, &stkctr_entry(stkctr)->lock);
+		HA_RWLOCK_RDLOCK(STK_SESS_LOCK, &stkctr_entry(stkctr)->lock);
 
 		smp->data.u.sint = stktable_data_cast(ptr, gpc0);
 
-		RWLOCK_RDUNLOCK(STK_SESS_LOCK, &stkctr_entry(stkctr)->lock);
+		HA_RWLOCK_RDUNLOCK(STK_SESS_LOCK, &stkctr_entry(stkctr)->lock);
 
 		if (stkctr == &tmpstkctr)
 			stktable_release(stkctr->table, stkctr_entry(stkctr));
@@ -1968,12 +1968,12 @@
 			return 0; /* parameter not stored */
 		}
 
-		RWLOCK_RDLOCK(STK_SESS_LOCK, &stkctr_entry(stkctr)->lock);
+		HA_RWLOCK_RDLOCK(STK_SESS_LOCK, &stkctr_entry(stkctr)->lock);
 
 		smp->data.u.sint = read_freq_ctr_period(&stktable_data_cast(ptr, gpc0_rate),
 		                  stkctr->table->data_arg[STKTABLE_DT_GPC0_RATE].u);
 
-		RWLOCK_RDUNLOCK(STK_SESS_LOCK, &stkctr_entry(stkctr)->lock);
+		HA_RWLOCK_RDUNLOCK(STK_SESS_LOCK, &stkctr_entry(stkctr)->lock);
 
 		if (stkctr == &tmpstkctr)
 			stktable_release(stkctr->table, stkctr_entry(stkctr));
@@ -2012,7 +2012,7 @@
 		ptr1 = stktable_data_ptr(stkctr->table, stkctr_entry(stkctr), STKTABLE_DT_GPC0_RATE);
 		ptr2 = stktable_data_ptr(stkctr->table, stkctr_entry(stkctr), STKTABLE_DT_GPC0);
 		if (ptr1 || ptr2) {
-			RWLOCK_WRLOCK(STK_SESS_LOCK, &stkctr_entry(stkctr)->lock);
+			HA_RWLOCK_WRLOCK(STK_SESS_LOCK, &stkctr_entry(stkctr)->lock);
 
 			if (ptr1) {
 				update_freq_ctr_period(&stktable_data_cast(ptr1, gpc0_rate),
@@ -2023,7 +2023,7 @@
 			if (ptr2)
 				smp->data.u.sint = ++stktable_data_cast(ptr2, gpc0);
 
-			RWLOCK_WRUNLOCK(STK_SESS_LOCK, &stkctr_entry(stkctr)->lock);
+			HA_RWLOCK_WRUNLOCK(STK_SESS_LOCK, &stkctr_entry(stkctr)->lock);
 
 			/* If data was modified, we need to touch to re-schedule sync */
 			stktable_touch_local(stkctr->table, stkctr_entry(stkctr), (stkctr == &tmpstkctr) ? 1 : 0);
@@ -2065,12 +2065,12 @@
 			return 0; /* parameter not stored */
 		}
 
-		RWLOCK_WRLOCK(STK_SESS_LOCK, &stkctr_entry(stkctr)->lock);
+		HA_RWLOCK_WRLOCK(STK_SESS_LOCK, &stkctr_entry(stkctr)->lock);
 
 		smp->data.u.sint = stktable_data_cast(ptr, gpc0);
 		stktable_data_cast(ptr, gpc0) = 0;
 
-		RWLOCK_WRUNLOCK(STK_SESS_LOCK, &stkctr_entry(stkctr)->lock);
+		HA_RWLOCK_WRUNLOCK(STK_SESS_LOCK, &stkctr_entry(stkctr)->lock);
 
 		/* If data was modified, we need to touch to re-schedule sync */
 		stktable_touch_local(stkctr->table, stkctr_entry(stkctr), (stkctr == &tmpstkctr) ? 1 : 0);
@@ -2105,11 +2105,11 @@
 			return 0; /* parameter not stored */
 		}
 
-		RWLOCK_RDLOCK(STK_SESS_LOCK, &stkctr_entry(stkctr)->lock);
+		HA_RWLOCK_RDLOCK(STK_SESS_LOCK, &stkctr_entry(stkctr)->lock);
 
 		smp->data.u.sint = stktable_data_cast(ptr, conn_cnt);
 
-		RWLOCK_RDUNLOCK(STK_SESS_LOCK, &stkctr_entry(stkctr)->lock);
+		HA_RWLOCK_RDUNLOCK(STK_SESS_LOCK, &stkctr_entry(stkctr)->lock);
 
 		if (stkctr == &tmpstkctr)
 			stktable_release(stkctr->table, stkctr_entry(stkctr));
@@ -2146,12 +2146,12 @@
 			return 0; /* parameter not stored */
 		}
 
-		RWLOCK_RDLOCK(STK_SESS_LOCK, &stkctr_entry(stkctr)->lock);
+		HA_RWLOCK_RDLOCK(STK_SESS_LOCK, &stkctr_entry(stkctr)->lock);
 
 		smp->data.u.sint = read_freq_ctr_period(&stktable_data_cast(ptr, conn_rate),
 					       stkctr->table->data_arg[STKTABLE_DT_CONN_RATE].u);
 
-		RWLOCK_RDUNLOCK(STK_SESS_LOCK, &stkctr_entry(stkctr)->lock);
+		HA_RWLOCK_RDUNLOCK(STK_SESS_LOCK, &stkctr_entry(stkctr)->lock);
 
 		if (stkctr == &tmpstkctr)
 			stktable_release(stkctr->table, stkctr_entry(stkctr));
@@ -2197,11 +2197,11 @@
 
 	smp->data.type = SMP_T_SINT;
 
-	RWLOCK_WRLOCK(STK_SESS_LOCK, &ts->lock);
+	HA_RWLOCK_WRLOCK(STK_SESS_LOCK, &ts->lock);
 
 	smp->data.u.sint = ++stktable_data_cast(ptr, conn_cnt);
 
-	RWLOCK_WRUNLOCK(STK_SESS_LOCK, &ts->lock);
+	HA_RWLOCK_WRUNLOCK(STK_SESS_LOCK, &ts->lock);
 
 	smp->flags = SMP_F_VOL_TEST;
 
@@ -2238,11 +2238,11 @@
 			return 0; /* parameter not stored */
 		}
 
-		RWLOCK_RDLOCK(STK_SESS_LOCK, &stkctr_entry(stkctr)->lock);
+		HA_RWLOCK_RDLOCK(STK_SESS_LOCK, &stkctr_entry(stkctr)->lock);
 
 		smp->data.u.sint = stktable_data_cast(ptr, conn_cur);
 
-		RWLOCK_RDUNLOCK(STK_SESS_LOCK, &stkctr_entry(stkctr)->lock);
+		HA_RWLOCK_RDUNLOCK(STK_SESS_LOCK, &stkctr_entry(stkctr)->lock);
 
 		if (stkctr == &tmpstkctr)
 			stktable_release(stkctr->table, stkctr_entry(stkctr));
@@ -2277,11 +2277,11 @@
 			return 0; /* parameter not stored */
 		}
 
-		RWLOCK_RDLOCK(STK_SESS_LOCK, &stkctr_entry(stkctr)->lock);
+		HA_RWLOCK_RDLOCK(STK_SESS_LOCK, &stkctr_entry(stkctr)->lock);
 
 		smp->data.u.sint = stktable_data_cast(ptr, sess_cnt);
 
-		RWLOCK_RDUNLOCK(STK_SESS_LOCK, &stkctr_entry(stkctr)->lock);
+		HA_RWLOCK_RDUNLOCK(STK_SESS_LOCK, &stkctr_entry(stkctr)->lock);
 
 		if (stkctr == &tmpstkctr)
 			stktable_release(stkctr->table, stkctr_entry(stkctr));
@@ -2315,12 +2315,12 @@
 			return 0; /* parameter not stored */
 		}
 
-		RWLOCK_RDLOCK(STK_SESS_LOCK, &stkctr_entry(stkctr)->lock);
+		HA_RWLOCK_RDLOCK(STK_SESS_LOCK, &stkctr_entry(stkctr)->lock);
 
 		smp->data.u.sint = read_freq_ctr_period(&stktable_data_cast(ptr, sess_rate),
 					       stkctr->table->data_arg[STKTABLE_DT_SESS_RATE].u);
 
-		RWLOCK_RDUNLOCK(STK_SESS_LOCK, &stkctr_entry(stkctr)->lock);
+		HA_RWLOCK_RDUNLOCK(STK_SESS_LOCK, &stkctr_entry(stkctr)->lock);
 
 		if (stkctr == &tmpstkctr)
 			stktable_release(stkctr->table, stkctr_entry(stkctr));
@@ -2355,11 +2355,11 @@
 			return 0; /* parameter not stored */
 		}
 
-		RWLOCK_RDLOCK(STK_SESS_LOCK, &stkctr_entry(stkctr)->lock);
+		HA_RWLOCK_RDLOCK(STK_SESS_LOCK, &stkctr_entry(stkctr)->lock);
 
 		smp->data.u.sint = stktable_data_cast(ptr, http_req_cnt);
 
-		RWLOCK_RDUNLOCK(STK_SESS_LOCK, &stkctr_entry(stkctr)->lock);
+		HA_RWLOCK_RDUNLOCK(STK_SESS_LOCK, &stkctr_entry(stkctr)->lock);
 
 		if (stkctr == &tmpstkctr)
 			stktable_release(stkctr->table, stkctr_entry(stkctr));
@@ -2394,12 +2394,12 @@
 			return 0; /* parameter not stored */
 		}
 
-		RWLOCK_RDLOCK(STK_SESS_LOCK, &stkctr_entry(stkctr)->lock);
+		HA_RWLOCK_RDLOCK(STK_SESS_LOCK, &stkctr_entry(stkctr)->lock);
 
 		smp->data.u.sint = read_freq_ctr_period(&stktable_data_cast(ptr, http_req_rate),
 					       stkctr->table->data_arg[STKTABLE_DT_HTTP_REQ_RATE].u);
 
-		RWLOCK_RDUNLOCK(STK_SESS_LOCK, &stkctr_entry(stkctr)->lock);
+		HA_RWLOCK_RDUNLOCK(STK_SESS_LOCK, &stkctr_entry(stkctr)->lock);
 
 		if (stkctr == &tmpstkctr)
 			stktable_release(stkctr->table, stkctr_entry(stkctr));
@@ -2434,11 +2434,11 @@
 			return 0; /* parameter not stored */
 		}
 
-		RWLOCK_RDLOCK(STK_SESS_LOCK, &stkctr_entry(stkctr)->lock);
+		HA_RWLOCK_RDLOCK(STK_SESS_LOCK, &stkctr_entry(stkctr)->lock);
 
 		smp->data.u.sint = stktable_data_cast(ptr, http_err_cnt);
 
-		RWLOCK_RDUNLOCK(STK_SESS_LOCK, &stkctr_entry(stkctr)->lock);
+		HA_RWLOCK_RDUNLOCK(STK_SESS_LOCK, &stkctr_entry(stkctr)->lock);
 
 		if (stkctr == &tmpstkctr)
 			stktable_release(stkctr->table, stkctr_entry(stkctr));
@@ -2473,12 +2473,12 @@
 			return 0; /* parameter not stored */
 		}
 
-		RWLOCK_RDLOCK(STK_SESS_LOCK, &stkctr_entry(stkctr)->lock);
+		HA_RWLOCK_RDLOCK(STK_SESS_LOCK, &stkctr_entry(stkctr)->lock);
 
 		smp->data.u.sint = read_freq_ctr_period(&stktable_data_cast(ptr, http_err_rate),
 					       stkctr->table->data_arg[STKTABLE_DT_HTTP_ERR_RATE].u);
 
-		RWLOCK_RDUNLOCK(STK_SESS_LOCK, &stkctr_entry(stkctr)->lock);
+		HA_RWLOCK_RDUNLOCK(STK_SESS_LOCK, &stkctr_entry(stkctr)->lock);
 
 		if (stkctr == &tmpstkctr)
 			stktable_release(stkctr->table, stkctr_entry(stkctr));
@@ -2513,11 +2513,11 @@
 			return 0; /* parameter not stored */
 		}
 
-		RWLOCK_RDLOCK(STK_SESS_LOCK, &stkctr_entry(stkctr)->lock);
+		HA_RWLOCK_RDLOCK(STK_SESS_LOCK, &stkctr_entry(stkctr)->lock);
 
 		smp->data.u.sint = stktable_data_cast(ptr, bytes_in_cnt) >> 10;
 
-		RWLOCK_RDUNLOCK(STK_SESS_LOCK, &stkctr_entry(stkctr)->lock);
+		HA_RWLOCK_RDUNLOCK(STK_SESS_LOCK, &stkctr_entry(stkctr)->lock);
 
 		if (stkctr == &tmpstkctr)
 			stktable_release(stkctr->table, stkctr_entry(stkctr));
@@ -2552,12 +2552,12 @@
 			return 0; /* parameter not stored */
 		}
 
-		RWLOCK_RDLOCK(STK_SESS_LOCK, &stkctr_entry(stkctr)->lock);
+		HA_RWLOCK_RDLOCK(STK_SESS_LOCK, &stkctr_entry(stkctr)->lock);
 
 		smp->data.u.sint = read_freq_ctr_period(&stktable_data_cast(ptr, bytes_in_rate),
 					       stkctr->table->data_arg[STKTABLE_DT_BYTES_IN_RATE].u);
 
-		RWLOCK_RDUNLOCK(STK_SESS_LOCK, &stkctr_entry(stkctr)->lock);
+		HA_RWLOCK_RDUNLOCK(STK_SESS_LOCK, &stkctr_entry(stkctr)->lock);
 
 		if (stkctr == &tmpstkctr)
 			stktable_release(stkctr->table, stkctr_entry(stkctr));
@@ -2592,11 +2592,11 @@
 			return 0; /* parameter not stored */
 		}
 
-		RWLOCK_RDLOCK(STK_SESS_LOCK, &stkctr_entry(stkctr)->lock);
+		HA_RWLOCK_RDLOCK(STK_SESS_LOCK, &stkctr_entry(stkctr)->lock);
 
 		smp->data.u.sint = stktable_data_cast(ptr, bytes_out_cnt) >> 10;
 
-		RWLOCK_RDUNLOCK(STK_SESS_LOCK, &stkctr_entry(stkctr)->lock);
+		HA_RWLOCK_RDUNLOCK(STK_SESS_LOCK, &stkctr_entry(stkctr)->lock);
 
 		if (stkctr == &tmpstkctr)
 			stktable_release(stkctr->table, stkctr_entry(stkctr));
@@ -2631,12 +2631,12 @@
 			return 0; /* parameter not stored */
 		}
 
-		RWLOCK_RDLOCK(STK_SESS_LOCK, &stkctr_entry(stkctr)->lock);
+		HA_RWLOCK_RDLOCK(STK_SESS_LOCK, &stkctr_entry(stkctr)->lock);
 
 		smp->data.u.sint = read_freq_ctr_period(&stktable_data_cast(ptr, bytes_out_rate),
 					       stkctr->table->data_arg[STKTABLE_DT_BYTES_OUT_RATE].u);
 
-		RWLOCK_RDUNLOCK(STK_SESS_LOCK, &stkctr_entry(stkctr)->lock);
+		HA_RWLOCK_RDUNLOCK(STK_SESS_LOCK, &stkctr_entry(stkctr)->lock);
 
 		if (stkctr == &tmpstkctr)
 			stktable_release(stkctr->table, stkctr_entry(stkctr));
@@ -2875,13 +2875,13 @@
 			stktable_release(&px->table, ts);
 			return 0;
 		}
-		RWLOCK_RDLOCK(STK_SESS_LOCK, &ts->lock);
+		HA_RWLOCK_RDLOCK(STK_SESS_LOCK, &ts->lock);
 		if (!table_dump_entry_to_buffer(&trash, si, px, ts)) {
-			RWLOCK_RDUNLOCK(STK_SESS_LOCK, &ts->lock);
+			HA_RWLOCK_RDUNLOCK(STK_SESS_LOCK, &ts->lock);
 			stktable_release(&px->table, ts);
 			return 0;
 		}
-		RWLOCK_RDUNLOCK(STK_SESS_LOCK, &ts->lock);
+		HA_RWLOCK_RDUNLOCK(STK_SESS_LOCK, &ts->lock);
 		stktable_release(&px->table, ts);
 		break;
 
@@ -2910,13 +2910,13 @@
 			return 1;
 		}
 
-		RWLOCK_WRLOCK(STK_SESS_LOCK, &ts->lock);
+		HA_RWLOCK_WRLOCK(STK_SESS_LOCK, &ts->lock);
 		for (cur_arg = 5; *args[cur_arg]; cur_arg += 2) {
 			if (strncmp(args[cur_arg], "data.", 5) != 0) {
 				appctx->ctx.cli.severity = LOG_ERR;
 				appctx->ctx.cli.msg = "\"data.<type>\" followed by a value expected\n";
 				appctx->st0 = CLI_ST_PRINT;
-				RWLOCK_WRUNLOCK(STK_SESS_LOCK, &ts->lock);
+				HA_RWLOCK_WRUNLOCK(STK_SESS_LOCK, &ts->lock);
 				stktable_touch_local(&px->table, ts, 1);
 				return 1;
 			}
@@ -2926,7 +2926,7 @@
 				appctx->ctx.cli.severity = LOG_ERR;
 				appctx->ctx.cli.msg = "Unknown data type\n";
 				appctx->st0 = CLI_ST_PRINT;
-				RWLOCK_WRUNLOCK(STK_SESS_LOCK, &ts->lock);
+				HA_RWLOCK_WRUNLOCK(STK_SESS_LOCK, &ts->lock);
 				stktable_touch_local(&px->table, ts, 1);
 				return 1;
 			}
@@ -2935,7 +2935,7 @@
 				appctx->ctx.cli.severity = LOG_ERR;
 				appctx->ctx.cli.msg = "Data type not stored in this table\n";
 				appctx->st0 = CLI_ST_PRINT;
-				RWLOCK_WRUNLOCK(STK_SESS_LOCK, &ts->lock);
+				HA_RWLOCK_WRUNLOCK(STK_SESS_LOCK, &ts->lock);
 				stktable_touch_local(&px->table, ts, 1);
 				return 1;
 			}
@@ -2944,7 +2944,7 @@
 				appctx->ctx.cli.severity = LOG_ERR;
 				appctx->ctx.cli.msg = "Require a valid integer value to store\n";
 				appctx->st0 = CLI_ST_PRINT;
-				RWLOCK_WRUNLOCK(STK_SESS_LOCK, &ts->lock);
+				HA_RWLOCK_WRUNLOCK(STK_SESS_LOCK, &ts->lock);
 				stktable_touch_local(&px->table, ts, 1);
 				return 1;
 			}
@@ -2978,7 +2978,7 @@
 				break;
 			}
 		}
-		RWLOCK_WRUNLOCK(STK_SESS_LOCK, &ts->lock);
+		HA_RWLOCK_WRUNLOCK(STK_SESS_LOCK, &ts->lock);
 		stktable_touch_local(&px->table, ts, 1);
 		break;
 
@@ -3155,16 +3155,16 @@
 				if (appctx->ctx.table.target &&
 				    (strm_li(s)->bind_conf->level & ACCESS_LVL_MASK) >= ACCESS_LVL_OPER) {
 					/* dump entries only if table explicitly requested */
-					SPIN_LOCK(STK_TABLE_LOCK, &appctx->ctx.table.proxy->table.lock);
+					HA_SPIN_LOCK(STK_TABLE_LOCK, &appctx->ctx.table.proxy->table.lock);
 					eb = ebmb_first(&appctx->ctx.table.proxy->table.keys);
 					if (eb) {
 						appctx->ctx.table.entry = ebmb_entry(eb, struct stksess, key);
 						appctx->ctx.table.entry->ref_cnt++;
 						appctx->st2 = STAT_ST_LIST;
-						SPIN_UNLOCK(STK_TABLE_LOCK, &appctx->ctx.table.proxy->table.lock);
+						HA_SPIN_UNLOCK(STK_TABLE_LOCK, &appctx->ctx.table.proxy->table.lock);
 						break;
 					}
-					SPIN_UNLOCK(STK_TABLE_LOCK, &appctx->ctx.table.proxy->table.lock);
+					HA_SPIN_UNLOCK(STK_TABLE_LOCK, &appctx->ctx.table.proxy->table.lock);
 				}
 			}
 			appctx->ctx.table.proxy = appctx->ctx.table.proxy->next;
@@ -3173,7 +3173,7 @@
 		case STAT_ST_LIST:
 			skip_entry = 0;
 
-			RWLOCK_RDLOCK(STK_SESS_LOCK, &appctx->ctx.table.entry->lock);
+			HA_RWLOCK_RDLOCK(STK_SESS_LOCK, &appctx->ctx.table.entry->lock);
 
 			if (appctx->ctx.table.data_type >= 0) {
 				/* we're filtering on some data contents */
@@ -3221,13 +3221,13 @@
 
 			if (show && !skip_entry &&
 			    !table_dump_entry_to_buffer(&trash, si, appctx->ctx.table.proxy, appctx->ctx.table.entry)) {
-				RWLOCK_RDUNLOCK(STK_SESS_LOCK, &appctx->ctx.table.entry->lock);
+				HA_RWLOCK_RDUNLOCK(STK_SESS_LOCK, &appctx->ctx.table.entry->lock);
 				return 0;
 			}
 
-			RWLOCK_RDUNLOCK(STK_SESS_LOCK, &appctx->ctx.table.entry->lock);
+			HA_RWLOCK_RDUNLOCK(STK_SESS_LOCK, &appctx->ctx.table.entry->lock);
 
-			SPIN_LOCK(STK_TABLE_LOCK, &appctx->ctx.table.proxy->table.lock);
+			HA_SPIN_LOCK(STK_TABLE_LOCK, &appctx->ctx.table.proxy->table.lock);
 			appctx->ctx.table.entry->ref_cnt--;
 
 			eb = ebmb_next(&appctx->ctx.table.entry->key);
@@ -3239,7 +3239,7 @@
 				else if (!skip_entry && !appctx->ctx.table.entry->ref_cnt)
 					__stksess_kill(&appctx->ctx.table.proxy->table, old);
 				appctx->ctx.table.entry->ref_cnt++;
-				SPIN_UNLOCK(STK_TABLE_LOCK, &appctx->ctx.table.proxy->table.lock);
+				HA_SPIN_UNLOCK(STK_TABLE_LOCK, &appctx->ctx.table.proxy->table.lock);
 				break;
 			}
 
@@ -3249,7 +3249,7 @@
 			else if (!skip_entry && !appctx->ctx.table.entry->ref_cnt)
 				__stksess_kill(&appctx->ctx.table.proxy->table, appctx->ctx.table.entry);
 
-			SPIN_UNLOCK(STK_TABLE_LOCK, &appctx->ctx.table.proxy->table.lock);
+			HA_SPIN_UNLOCK(STK_TABLE_LOCK, &appctx->ctx.table.proxy->table.lock);
 
 			appctx->ctx.table.proxy = appctx->ctx.table.proxy->next;
 			appctx->st2 = STAT_ST_INFO;
diff --git a/src/stream.c b/src/stream.c
index 12545fb..2d4f78a 100644
--- a/src/stream.c
+++ b/src/stream.c
@@ -253,9 +253,9 @@
 	s->txn = NULL;
 	s->hlua = NULL;
 
-	SPIN_LOCK(STRMS_LOCK, &streams_lock);
+	HA_SPIN_LOCK(STRMS_LOCK, &streams_lock);
 	LIST_ADDQ(&streams, &s->list);
-	SPIN_UNLOCK(STRMS_LOCK, &streams_lock);
+	HA_SPIN_UNLOCK(STRMS_LOCK, &streams_lock);
 
 	if (flt_stream_init(s) < 0 || flt_stream_start(s) < 0)
 		goto out_fail_accept;
@@ -326,10 +326,10 @@
 
 	/* We may still be present in the buffer wait queue */
 	if (!LIST_ISEMPTY(&s->buffer_wait.list)) {
-		SPIN_LOCK(BUF_WQ_LOCK, &buffer_wq_lock);
+		HA_SPIN_LOCK(BUF_WQ_LOCK, &buffer_wq_lock);
 		LIST_DEL(&s->buffer_wait.list);
 		LIST_INIT(&s->buffer_wait.list);
-		SPIN_UNLOCK(BUF_WQ_LOCK, &buffer_wq_lock);
+		HA_SPIN_UNLOCK(BUF_WQ_LOCK, &buffer_wq_lock);
 	}
 	if (s->req.buf->size || s->res.buf->size) {
 		b_drop(&s->req.buf);
@@ -373,7 +373,7 @@
 
 	stream_store_counters(s);
 
-	SPIN_LOCK(STRMS_LOCK, &streams_lock);
+	HA_SPIN_LOCK(STRMS_LOCK, &streams_lock);
 	list_for_each_entry_safe(bref, back, &s->back_refs, users) {
 		/* we have to unlink all watchers. We must not relink them if
 		 * this stream was the last one in the list.
@@ -385,7 +385,7 @@
 		bref->ref = s->list.n;
 	}
 	LIST_DEL(&s->list);
-	SPIN_UNLOCK(STRMS_LOCK, &streams_lock);
+	HA_SPIN_UNLOCK(STRMS_LOCK, &streams_lock);
 
 	si_release_endpoint(&s->si[1]);
 	si_release_endpoint(&s->si[0]);
@@ -423,18 +423,18 @@
 static int stream_alloc_work_buffer(struct stream *s)
 {
 	if (!LIST_ISEMPTY(&s->buffer_wait.list)) {
-		SPIN_LOCK(BUF_WQ_LOCK, &buffer_wq_lock);
+		HA_SPIN_LOCK(BUF_WQ_LOCK, &buffer_wq_lock);
 		LIST_DEL(&s->buffer_wait.list);
 		LIST_INIT(&s->buffer_wait.list);
-		SPIN_UNLOCK(BUF_WQ_LOCK, &buffer_wq_lock);
+		HA_SPIN_UNLOCK(BUF_WQ_LOCK, &buffer_wq_lock);
 	}
 
 	if (b_alloc_margin(&s->res.buf, 0))
 		return 1;
 
-	SPIN_LOCK(BUF_WQ_LOCK, &buffer_wq_lock);
+	HA_SPIN_LOCK(BUF_WQ_LOCK, &buffer_wq_lock);
 	LIST_ADDQ(&buffer_wq, &s->buffer_wait.list);
-	SPIN_UNLOCK(BUF_WQ_LOCK, &buffer_wq_lock);
+	HA_SPIN_UNLOCK(BUF_WQ_LOCK, &buffer_wq_lock);
 	return 0;
 }
 
@@ -468,7 +468,7 @@
 int init_stream()
 {
 	LIST_INIT(&streams);
-	SPIN_INIT(&streams_lock);
+	HA_SPIN_INIT(&streams_lock);
 	pool2_stream = create_pool("stream", sizeof(struct stream), MEM_F_SHARED);
 	return pool2_stream != NULL;
 }
@@ -504,7 +504,7 @@
 					continue;
 			}
 
-			RWLOCK_WRLOCK(STK_SESS_LOCK, &ts->lock);
+			HA_RWLOCK_WRLOCK(STK_SESS_LOCK, &ts->lock);
 			ptr1 = stktable_data_ptr(stkctr->table, ts, STKTABLE_DT_BYTES_IN_CNT);
 			if (ptr1)
 				stktable_data_cast(ptr1, bytes_in_cnt) += bytes;
@@ -513,7 +513,7 @@
 			if (ptr2)
 				update_freq_ctr_period(&stktable_data_cast(ptr2, bytes_in_rate),
 						       stkctr->table->data_arg[STKTABLE_DT_BYTES_IN_RATE].u, bytes);
-			RWLOCK_WRUNLOCK(STK_SESS_LOCK, &ts->lock);
+			HA_RWLOCK_WRUNLOCK(STK_SESS_LOCK, &ts->lock);
 
 			/* If data was modified, we need to touch to re-schedule sync */
 			if (ptr1 || ptr2)
@@ -544,7 +544,7 @@
 					continue;
 			}
 
-			RWLOCK_WRLOCK(STK_SESS_LOCK, &ts->lock);
+			HA_RWLOCK_WRLOCK(STK_SESS_LOCK, &ts->lock);
 			ptr1 = stktable_data_ptr(stkctr->table, ts, STKTABLE_DT_BYTES_OUT_CNT);
 			if (ptr1)
 				stktable_data_cast(ptr1, bytes_out_cnt) += bytes;
@@ -553,7 +553,7 @@
 			if (ptr2)
 				update_freq_ctr_period(&stktable_data_cast(ptr2, bytes_out_rate),
 						       stkctr->table->data_arg[STKTABLE_DT_BYTES_OUT_RATE].u, bytes);
-			RWLOCK_WRUNLOCK(STK_SESS_LOCK, &ts->lock);
+			HA_RWLOCK_WRUNLOCK(STK_SESS_LOCK, &ts->lock);
 
 			/* If data was modified, we need to touch to re-schedule sync */
 			if (ptr1 || ptr2)
@@ -1409,10 +1409,10 @@
 						void *ptr;
 
 						/* srv found in table */
-						RWLOCK_RDLOCK(STK_SESS_LOCK, &ts->lock);
+						HA_RWLOCK_RDLOCK(STK_SESS_LOCK, &ts->lock);
 						ptr = stktable_data_ptr(rule->table.t, ts, STKTABLE_DT_SERVER_ID);
 						node = eb32_lookup(&px->conf.used_server_id, stktable_data_cast(ptr, server_id));
-						RWLOCK_RDUNLOCK(STK_SESS_LOCK, &ts->lock);
+						HA_RWLOCK_RDUNLOCK(STK_SESS_LOCK, &ts->lock);
 						if (node) {
 							struct server *srv;
 
@@ -1536,10 +1536,10 @@
 		}
 		s->store[i].ts = NULL;
 
-		RWLOCK_WRLOCK(STK_SESS_LOCK, &ts->lock);
+		HA_RWLOCK_WRLOCK(STK_SESS_LOCK, &ts->lock);
 		ptr = stktable_data_ptr(s->store[i].table, ts, STKTABLE_DT_SERVER_ID);
 		stktable_data_cast(ptr, server_id) = objt_server(s->target)->puid;
-		RWLOCK_WRUNLOCK(STK_SESS_LOCK, &ts->lock);
+		HA_RWLOCK_WRUNLOCK(STK_SESS_LOCK, &ts->lock);
 		stktable_touch_local(s->store[i].table, ts, 1);
 	}
 	s->store_count = 0; /* everything is stored */
@@ -2536,12 +2536,12 @@
 		swrate_add(&srv->counters.d_time, TIME_STATS_SAMPLES, t_data);
 		swrate_add(&srv->counters.t_time, TIME_STATS_SAMPLES, t_close);
 	}
-	SPIN_LOCK(PROXY_LOCK, &s->be->lock);
+	HA_SPIN_LOCK(PROXY_LOCK, &s->be->lock);
 	swrate_add(&s->be->be_counters.q_time, TIME_STATS_SAMPLES, t_queue);
 	swrate_add(&s->be->be_counters.c_time, TIME_STATS_SAMPLES, t_connect);
 	swrate_add(&s->be->be_counters.d_time, TIME_STATS_SAMPLES, t_data);
 	swrate_add(&s->be->be_counters.t_time, TIME_STATS_SAMPLES, t_close);
-	SPIN_UNLOCK(PROXY_LOCK, &s->be->lock);
+	HA_SPIN_UNLOCK(PROXY_LOCK, &s->be->lock);
 }
 
 /*
@@ -3056,14 +3056,14 @@
 		 * pointer points back to the head of the streams list.
 		 */
 		LIST_INIT(&appctx->ctx.sess.bref.users);
-		SPIN_LOCK(STRMS_LOCK, &streams_lock);
+		HA_SPIN_LOCK(STRMS_LOCK, &streams_lock);
 		appctx->ctx.sess.bref.ref = streams.n;
-		SPIN_UNLOCK(STRMS_LOCK, &streams_lock);
+		HA_SPIN_UNLOCK(STRMS_LOCK, &streams_lock);
 		appctx->st2 = STAT_ST_LIST;
 		/* fall through */
 
 	case STAT_ST_LIST:
-		SPIN_LOCK(STRMS_LOCK, &streams_lock);
+		HA_SPIN_LOCK(STRMS_LOCK, &streams_lock);
 		/* first, let's detach the back-ref from a possible previous stream */
 		if (!LIST_ISEMPTY(&appctx->ctx.sess.bref.users)) {
 			LIST_DEL(&appctx->ctx.sess.bref.users);
@@ -3084,7 +3084,7 @@
 				LIST_ADDQ(&curr_strm->back_refs, &appctx->ctx.sess.bref.users);
 				/* call the proper dump() function and return if we're missing space */
 				if (!stats_dump_full_strm_to_buffer(si, curr_strm)) {
-					SPIN_UNLOCK(STRMS_LOCK, &streams_lock);
+					HA_SPIN_UNLOCK(STRMS_LOCK, &streams_lock);
 					return 0;
 				}
 
@@ -3212,7 +3212,7 @@
 				 */
 				si_applet_cant_put(si);
 				LIST_ADDQ(&curr_strm->back_refs, &appctx->ctx.sess.bref.users);
-				SPIN_UNLOCK(STRMS_LOCK, &streams_lock);
+				HA_SPIN_UNLOCK(STRMS_LOCK, &streams_lock);
 				return 0;
 			}
 
@@ -3229,17 +3229,17 @@
 
 			if (ci_putchk(si_ic(si), &trash) == -1) {
 				si_applet_cant_put(si);
-				SPIN_UNLOCK(STRMS_LOCK, &streams_lock);
+				HA_SPIN_UNLOCK(STRMS_LOCK, &streams_lock);
 				return 0;
 			}
 
 			appctx->ctx.sess.target = NULL;
 			appctx->ctx.sess.uid = 0;
-			SPIN_UNLOCK(STRMS_LOCK, &streams_lock);
+			HA_SPIN_UNLOCK(STRMS_LOCK, &streams_lock);
 			return 1;
 		}
 
-		SPIN_UNLOCK(STRMS_LOCK, &streams_lock);
+		HA_SPIN_UNLOCK(STRMS_LOCK, &streams_lock);
 		appctx->st2 = STAT_ST_FIN;
 		/* fall through */
 
@@ -3252,10 +3252,10 @@
 static void cli_release_show_sess(struct appctx *appctx)
 {
 	if (appctx->st2 == STAT_ST_LIST) {
-		SPIN_UNLOCK(STRMS_LOCK, &streams_lock);
+		HA_SPIN_UNLOCK(STRMS_LOCK, &streams_lock);
 		if (!LIST_ISEMPTY(&appctx->ctx.sess.bref.users))
 			LIST_DEL(&appctx->ctx.sess.bref.users);
-		SPIN_UNLOCK(STRMS_LOCK, &streams_lock);
+		HA_SPIN_UNLOCK(STRMS_LOCK, &streams_lock);
 	}
 }
 
@@ -3308,11 +3308,11 @@
 		return 1;
 
 	/* kill all the stream that are on this server */
-	SPIN_LOCK(SERVER_LOCK, &sv->lock);
+	HA_SPIN_LOCK(SERVER_LOCK, &sv->lock);
 	list_for_each_entry_safe(strm, strm_bck, &sv->actconns, by_srv)
 		if (strm->srv_conn == sv)
 			stream_shutdown(strm, SF_ERR_KILLED);
-	SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
+	HA_SPIN_UNLOCK(SERVER_LOCK, &sv->lock);
 	return 1;
 }
 
diff --git a/src/task.c b/src/task.c
index a466de6..4555f2f 100644
--- a/src/task.c
+++ b/src/task.c
@@ -121,7 +121,7 @@
 	int ret = TICK_ETERNITY;
 
 	while (1) {
-		SPIN_LOCK(TASK_WQ_LOCK, &wq_lock);
+		HA_SPIN_LOCK(TASK_WQ_LOCK, &wq_lock);
   lookup_next:
 		eb = eb32_lookup_ge(&timers, now_ms - TIMER_LOOK_BACK);
 		if (!eb) {
@@ -162,11 +162,11 @@
 				__task_queue(task);
 			goto lookup_next;
 		}
-		SPIN_UNLOCK(TASK_WQ_LOCK, &wq_lock);
+		HA_SPIN_UNLOCK(TASK_WQ_LOCK, &wq_lock);
 		task_wakeup(task, TASK_WOKEN_TIMER);
 	}
 
-	SPIN_UNLOCK(TASK_WQ_LOCK, &wq_lock);
+	HA_SPIN_UNLOCK(TASK_WQ_LOCK, &wq_lock);
 	return ret;
 }
 
@@ -251,7 +251,7 @@
 		return;
 	}
 
-	SPIN_LOCK(TASK_RQ_LOCK, &rq_lock);
+	HA_SPIN_LOCK(TASK_RQ_LOCK, &rq_lock);
 	rq_next = eb32sc_lookup_ge(&rqueue, rqueue_ticks - TIMER_LOOK_BACK, tid_bit);
 
 	do {
@@ -289,7 +289,7 @@
 		if (!local_tasks_count)
 			break;
 
-		SPIN_UNLOCK(TASK_RQ_LOCK, &rq_lock);
+		HA_SPIN_UNLOCK(TASK_RQ_LOCK, &rq_lock);
 
 		final_tasks_count = 0;
 		for (i = 0; i < local_tasks_count ; i++) {
@@ -305,7 +305,7 @@
 				local_tasks[final_tasks_count++] = t;
 		}
 
-		SPIN_LOCK(TASK_RQ_LOCK, &rq_lock);
+		HA_SPIN_LOCK(TASK_RQ_LOCK, &rq_lock);
 		for (i = 0; i < final_tasks_count ; i++) {
 			t = local_tasks[i];
 			t->state &= ~TASK_RUNNING;
@@ -321,7 +321,7 @@
 		}
 	} while (max_processed > 0);
 
-	SPIN_UNLOCK(TASK_RQ_LOCK, &rq_lock);
+	HA_SPIN_UNLOCK(TASK_RQ_LOCK, &rq_lock);
 }
 
 /* perform minimal intializations, report 0 in case of error, 1 if OK. */
@@ -329,8 +329,8 @@
 {
 	memset(&timers, 0, sizeof(timers));
 	memset(&rqueue, 0, sizeof(rqueue));
-	SPIN_INIT(&wq_lock);
-	SPIN_INIT(&rq_lock);
+	HA_SPIN_INIT(&wq_lock);
+	HA_SPIN_INIT(&rq_lock);
 	pool2_task = create_pool("task", sizeof(struct task), MEM_F_SHARED);
 	if (!pool2_task)
 		return 0;
diff --git a/src/vars.c b/src/vars.c
index 6e8e256..fef3685 100644
--- a/src/vars.c
+++ b/src/vars.c
@@ -118,11 +118,11 @@
 	struct var *var, *tmp;
 	unsigned int size = 0;
 
-	RWLOCK_WRLOCK(VARS_LOCK, &vars->rwlock);
+	HA_RWLOCK_WRLOCK(VARS_LOCK, &vars->rwlock);
 	list_for_each_entry_safe(var, tmp, &vars->head, l) {
 		size += var_clear(var);
 	}
-	RWLOCK_WRUNLOCK(VARS_LOCK, &vars->rwlock);
+	HA_RWLOCK_WRUNLOCK(VARS_LOCK, &vars->rwlock);
 	var_accounting_diff(vars, sess, strm, -size);
 }
 
@@ -134,11 +134,11 @@
 	struct var *var, *tmp;
 	unsigned int size = 0;
 
-	RWLOCK_WRLOCK(VARS_LOCK, &vars->rwlock);
+	HA_RWLOCK_WRLOCK(VARS_LOCK, &vars->rwlock);
 	list_for_each_entry_safe(var, tmp, &vars->head, l) {
 		size += var_clear(var);
 	}
-	RWLOCK_WRUNLOCK(VARS_LOCK, &vars->rwlock);
+	HA_RWLOCK_WRUNLOCK(VARS_LOCK, &vars->rwlock);
 
 	HA_ATOMIC_SUB(&vars->size, size);
 	HA_ATOMIC_SUB(&global.vars.size, size);
@@ -151,7 +151,7 @@
 	LIST_INIT(&vars->head);
 	vars->scope = scope;
 	vars->size = 0;
-	RWLOCK_INIT(&vars->rwlock);
+	HA_RWLOCK_INIT(&vars->rwlock);
 }
 
 /* This function declares a new variable name. It returns a pointer
@@ -214,9 +214,9 @@
 	}
 
 	if (alloc)
-		RWLOCK_WRLOCK(VARS_LOCK, &var_names_rwlock);
+		HA_RWLOCK_WRLOCK(VARS_LOCK, &var_names_rwlock);
 	else
-		RWLOCK_RDLOCK(VARS_LOCK, &var_names_rwlock);
+		HA_RWLOCK_RDLOCK(VARS_LOCK, &var_names_rwlock);
 
 
 	/* Look for existing variable name. */
@@ -263,9 +263,9 @@
 
   end:
 	if (alloc)
-		RWLOCK_WRUNLOCK(VARS_LOCK, &var_names_rwlock);
+		HA_RWLOCK_WRUNLOCK(VARS_LOCK, &var_names_rwlock);
 	else
-		RWLOCK_RDUNLOCK(VARS_LOCK, &var_names_rwlock);
+		HA_RWLOCK_RDUNLOCK(VARS_LOCK, &var_names_rwlock);
 
 	return res;
 }
@@ -312,12 +312,12 @@
 	if (vars->scope != var_desc->scope)
 		return 0;
 
-	RWLOCK_RDLOCK(VARS_LOCK, &vars->rwlock);
+	HA_RWLOCK_RDLOCK(VARS_LOCK, &vars->rwlock);
 	var = var_get(vars, var_desc->name);
 
 	/* check for the variable avalaibility */
 	if (!var) {
-		RWLOCK_RDUNLOCK(VARS_LOCK, &vars->rwlock);
+		HA_RWLOCK_RDUNLOCK(VARS_LOCK, &vars->rwlock);
 		return 0;
 	}
 
@@ -327,7 +327,7 @@
 	smp_dup(smp);
 	smp->flags |= SMP_F_CONST;
 
-	RWLOCK_RDUNLOCK(VARS_LOCK, &vars->rwlock);
+	HA_RWLOCK_RDUNLOCK(VARS_LOCK, &vars->rwlock);
 	return 1;
 }
 
@@ -438,9 +438,9 @@
 	if (vars->scope != scope)
 		return 0;
 
-	RWLOCK_WRLOCK(VARS_LOCK, &vars->rwlock);
+	HA_RWLOCK_WRLOCK(VARS_LOCK, &vars->rwlock);
 	ret = sample_store(vars, name, smp);
-	RWLOCK_WRUNLOCK(VARS_LOCK, &vars->rwlock);
+	HA_RWLOCK_WRUNLOCK(VARS_LOCK, &vars->rwlock);
 	return ret;
 }
 
@@ -463,13 +463,13 @@
 		return 0;
 
 	/* Look for existing variable name. */
-	RWLOCK_WRLOCK(VARS_LOCK, &vars->rwlock);
+	HA_RWLOCK_WRLOCK(VARS_LOCK, &vars->rwlock);
 	var = var_get(vars, name);
 	if (var) {
 		size = var_clear(var);
 		var_accounting_diff(vars, smp->sess, smp->strm, -size);
 	}
-	RWLOCK_WRUNLOCK(VARS_LOCK, &vars->rwlock);
+	HA_RWLOCK_WRUNLOCK(VARS_LOCK, &vars->rwlock);
 	return 1;
 }
 
@@ -914,5 +914,5 @@
 	http_res_keywords_register(&http_res_kws);
 	cfg_register_keywords(&cfg_kws);
 
-	RWLOCK_INIT(&var_names_rwlock);
+	HA_RWLOCK_INIT(&var_names_rwlock);
 }