diff --git a/include/proto/proxy.h b/include/proto/proxy.h
index 597c03b..ed29f14 100644
--- a/include/proto/proxy.h
+++ b/include/proto/proxy.h
@@ -71,42 +71,42 @@
 /* increase the number of cumulated connections received on the designated frontend */
 static void inline proxy_inc_fe_conn_ctr(struct listener *l, struct proxy *fe)
 {
-	fe->counters.cum_feconn++;
+	fe->fe_counters.cum_conn++;
 	if (l->counters)
 		l->counters->cum_conn++;
 
 	update_freq_ctr(&fe->fe_conn_per_sec, 1);
-	if (fe->fe_conn_per_sec.curr_ctr > fe->counters.fe_cps_max)
-		fe->counters.fe_cps_max = fe->fe_conn_per_sec.curr_ctr;
+	if (fe->fe_conn_per_sec.curr_ctr > fe->fe_counters.cps_max)
+		fe->fe_counters.cps_max = fe->fe_conn_per_sec.curr_ctr;
 }
 
 /* increase the number of cumulated connections accepted by the designated frontend */
 static void inline proxy_inc_fe_sess_ctr(struct listener *l, struct proxy *fe)
 {
-	fe->counters.cum_fesess++;
+	fe->fe_counters.cum_sess++;
 	if (l->counters)
 		l->counters->cum_sess++;
 	update_freq_ctr(&fe->fe_sess_per_sec, 1);
-	if (fe->fe_sess_per_sec.curr_ctr > fe->counters.fe_sps_max)
-		fe->counters.fe_sps_max = fe->fe_sess_per_sec.curr_ctr;
+	if (fe->fe_sess_per_sec.curr_ctr > fe->fe_counters.sps_max)
+		fe->fe_counters.sps_max = fe->fe_sess_per_sec.curr_ctr;
 }
 
 /* increase the number of cumulated connections on the designated backend */
 static void inline proxy_inc_be_ctr(struct proxy *be)
 {
-	be->counters.cum_beconn++;
+	be->be_counters.cum_conn++;
 	update_freq_ctr(&be->be_sess_per_sec, 1);
-	if (be->be_sess_per_sec.curr_ctr > be->counters.be_sps_max)
-		be->counters.be_sps_max = be->be_sess_per_sec.curr_ctr;
+	if (be->be_sess_per_sec.curr_ctr > be->be_counters.sps_max)
+		be->be_counters.sps_max = be->be_sess_per_sec.curr_ctr;
 }
 
 /* increase the number of cumulated requests on the designated frontend */
 static void inline proxy_inc_fe_req_ctr(struct proxy *fe)
 {
-	fe->counters.cum_fe_req++;
+	fe->fe_counters.p.http.cum_req++;
 	update_freq_ctr(&fe->fe_req_per_sec, 1);
-	if (fe->fe_req_per_sec.curr_ctr > fe->counters.fe_rps_max)
-		fe->counters.fe_rps_max = fe->fe_req_per_sec.curr_ctr;
+	if (fe->fe_req_per_sec.curr_ctr > fe->fe_counters.p.http.rps_max)
+		fe->fe_counters.p.http.rps_max = fe->fe_req_per_sec.curr_ctr;
 }
 
 #endif /* _PROTO_PROXY_H */
diff --git a/include/types/counters.h b/include/types/counters.h
index a333219..e3e051f 100644
--- a/include/types/counters.h
+++ b/include/types/counters.h
@@ -1,56 +1,61 @@
 /*
-  include/types/counters.h
-  This file contains structure declarations for statistics counters.
-
-  Copyright 2008-2009 Krzysztof Piotr Oledzki <ole@ans.pl>
-
-  This library is free software; you can redistribute it and/or
-  modify it under the terms of the GNU Lesser General Public
-  License as published by the Free Software Foundation, version 2.1
-  exclusively.
-
-  This library is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-  Lesser General Public License for more details.
-
-  You should have received a copy of the GNU Lesser General Public
-  License along with this library; if not, write to the Free Software
-  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
-*/
+ * include/types/counters.h
+ * This file contains structure declarations for statistics counters.
+ *
+ * Copyright 2008-2009 Krzysztof Piotr Oledzki <ole@ans.pl>
+ * Copyright 2011 Willy Tarreau <w@1wt.eu>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation, version 2.1
+ * exclusively.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ */
 
 #ifndef _TYPES_COUNTERS_H
 #define _TYPES_COUNTERS_H
 
+/* maybe later we might thing about having a different struct for FE and BE */
 struct pxcounters {
-	unsigned int feconn_max, beconn_max;	/* max # of active frontend and backend sessions */
+	unsigned int conn_max;                  /* max # of active sessions */
+	long long    cum_conn;                  /* cumulated number of received connections */
+	long long    cum_sess;                  /* cumulated number of accepted connections */
+	long long  cum_lbconn;                  /* cumulated number of sessions processed by load balancing (BE only) */
 
-	long long cum_fe_req;			/* cumulated number of processed HTTP requests */
-	long long cum_feconn, cum_fesess;	/* cumulated number of received/accepted connections */
-	long long cum_beconn, cum_lbconn;	/* cumulated number of sessions processed by load balancing */
+	unsigned int cps_max;                   /* maximum of new connections received per second */
+	unsigned int sps_max;                   /* maximum of new connections accepted per second (sessions) */
+	unsigned int nbpend_max;                /* max number of pending connections with no server assigned yet (BE only) */
 
-	unsigned int fe_rps_max;		/* maximum of new sessions per second seen on the frontend */
-	unsigned int fe_cps_max;		/* maximum of new connections per second received on the frontend */
-	unsigned int fe_sps_max;		/* maximum of new sessions per second accepted on the frontend */
-	unsigned int be_sps_max;		/* maximum of new sessions per second seen on the backend */
-	unsigned int nbpend_max;		/* max number of pending connections with no server assigned yet */
+	long long bytes_in;                     /* number of bytes transferred from the client to the server */
+	long long bytes_out;                    /* number of bytes transferred from the server to the client */
 
-	long long bytes_in;			/* number of bytes transferred from the client to the server */
-	long long bytes_out;			/* number of bytes transferred from the server to the client */
+	long long denied_req;                   /* blocked requests/responses because of security concerns */
+	long long denied_resp;                  /* blocked requests/responses because of security concerns */
+	long long failed_req;                   /* failed requests (eg: invalid or timeout) */
+	long long denied_conn;                  /* denied connection requests (tcp-req rules) */
 
-	long long denied_req, denied_resp;	/* blocked requests/responses because of security concerns */
-	long long failed_req;			/* failed requests (eg: invalid or timeout) */
-	long long denied_conn;			/* denied connection requests (tcp-req rules) */
+	long long failed_conns;                 /* failed connect() attempts (BE only) */
+	long long failed_resp;                  /* failed responses (BE only) */
+	long long cli_aborts;                   /* aborted responses during DATA phase caused by the client */
+	long long srv_aborts;                   /* aborted responses during DATA phase caused by the server */
+	long long retries;                      /* retried and redispatched connections (BE only) */
+	long long redispatches;                 /* retried and redispatched connections (BE only) */
 
 	union {
 		struct {
-			long long rsp[6];	/* http response codes */
+			long long cum_req;      /* cumulated number of processed HTTP requests */
+			unsigned int rps_max;   /* maximum of new HTTP requests second observed */
+			long long rsp[6];       /* http response codes */
 		} http;
-	} fe, be;				/* FE and BE stats */
-
-	long long failed_conns, failed_resp;	/* failed connect() and responses */
-	long long cli_aborts, srv_aborts;	/* aborted responses during DATA phase due to client or server */
-	long long retries, redispatches;	/* retried and redispatched connections */
+	} p;                                    /* protocol-specific stats */
 };
 
 struct licounters {
diff --git a/include/types/proxy.h b/include/types/proxy.h
index 95736b1..6208d7b 100644
--- a/include/types/proxy.h
+++ b/include/types/proxy.h
@@ -297,7 +297,8 @@
 	                 *rsp_cap_pool;
 	struct pool_head *hdr_idx_pool;         /* pools of pre-allocated int* used for headers indexing */
 	struct list req_add, rsp_add;           /* headers to be added */
-	struct pxcounters counters;		/* statistics counters */
+	struct pxcounters be_counters;		/* backend statistics counters */
+	struct pxcounters fe_counters;		/* frontend statistics counters */
 
 	struct stktable table;			/* table for storing sticking sessions */
 
diff --git a/src/backend.c b/src/backend.c
index e2ad5b2..93a8fc8 100644
--- a/src/backend.c
+++ b/src/backend.c
@@ -613,7 +613,7 @@
 			goto out;
 		}
 		else if (srv != prev_srv) {
-			s->be->counters.cum_lbconn++;
+			s->be->be_counters.cum_lbconn++;
 			srv->counters.cum_lbconn++;
 		}
 		set_target_server(&s->target, srv);
@@ -800,10 +800,10 @@
 				}
 				s->flags |= SN_REDISP;
 				prev_srv->counters.redispatches++;
-				s->be->counters.redispatches++;
+				s->be->be_counters.redispatches++;
 			} else {
 				prev_srv->counters.retries++;
-				s->be->counters.retries++;
+				s->be->be_counters.retries++;
 			}
 		}
 	}
@@ -1036,7 +1036,7 @@
 		}
 
 		srv->counters.failed_conns++;
-		t->be->counters.failed_conns++;
+		t->be->be_counters.failed_conns++;
 		return 1;
 
 	case SRV_STATUS_NOSRV:
@@ -1046,7 +1046,7 @@
 			t->req->cons->err_loc = NULL;
 		}
 
-		t->be->counters.failed_conns++;
+		t->be->be_counters.failed_conns++;
 		return 1;
 
 	case SRV_STATUS_QUEUED:
@@ -1066,7 +1066,7 @@
 			srv_inc_sess_ctr(srv);
 		if (srv)
 			srv->counters.failed_conns++;
-		t->be->counters.failed_conns++;
+		t->be->be_counters.failed_conns++;
 
 		/* release other sessions waiting for this server */
 		if (may_dequeue_tasks(srv, t->be))
diff --git a/src/dumpstats.c b/src/dumpstats.c
index b04b297..34f0901 100644
--- a/src/dumpstats.c
+++ b/src/dumpstats.c
@@ -493,16 +493,22 @@
 			}
 
 			for (px = proxy; px; px = px->next) {
-				if (clrall)
-					memset(&px->counters, 0, sizeof(px->counters));
+				if (clrall) {
+					memset(&px->be_counters, 0, sizeof(px->be_counters));
+					memset(&px->fe_counters, 0, sizeof(px->fe_counters));
+				}
 				else {
-					px->counters.feconn_max = 0;
-					px->counters.beconn_max = 0;
-					px->counters.fe_rps_max = 0;
-					px->counters.fe_sps_max = 0;
-					px->counters.fe_cps_max = 0;
-					px->counters.be_sps_max = 0;
-					px->counters.nbpend_max = 0;
+					px->be_counters.conn_max = 0;
+					px->be_counters.p.http.rps_max = 0;
+					px->be_counters.sps_max = 0;
+					px->be_counters.cps_max = 0;
+					px->be_counters.nbpend_max = 0;
+
+					px->fe_counters.conn_max = 0;
+					px->fe_counters.p.http.rps_max = 0;
+					px->fe_counters.sps_max = 0;
+					px->fe_counters.cps_max = 0;
+					px->fe_counters.nbpend_max = 0;
 				}
 
 				for (sv = px->srv; sv; sv = sv->next)
@@ -1761,8 +1767,8 @@
 						     "",
 						     read_freq_ctr(&px->fe_req_per_sec),
 						     U2H0(read_freq_ctr(&px->fe_sess_per_sec)),
-						     px->counters.fe_rps_max,
-						     U2H1(px->counters.fe_sps_max),
+						     px->fe_counters.p.http.rps_max,
+						     U2H1(px->fe_counters.sps_max),
 						     LIM2A2(px->fe_sps_lim, "-"));
 				} else {
 					chunk_printf(&msg,
@@ -1770,7 +1776,7 @@
 						     "<td>%s</td><td>%s</td><td>%s</td>"
 						     "",
 						     U2H0(read_freq_ctr(&px->fe_sess_per_sec)),
-						     U2H1(px->counters.fe_sps_max), LIM2A2(px->fe_sps_lim, "-"));
+						     U2H1(px->fe_counters.sps_max), LIM2A2(px->fe_sps_lim, "-"));
 				}
 
 				chunk_printf(&msg,
@@ -1778,18 +1784,18 @@
 				     "<td>%s</td><td>%s</td><td>%s</td>"
 				     "<td"
 				     "",
-				     U2H3(px->feconn), U2H4(px->counters.feconn_max), U2H5(px->maxconn));
+				     U2H3(px->feconn), U2H4(px->fe_counters.conn_max), U2H5(px->maxconn));
 
 				/* http response (via td title): 1xx, 2xx, 3xx, 4xx, 5xx, other */
 				if (px->mode == PR_MODE_HTTP) {
 					int i;
 
-					chunk_printf(&msg, " title=\"%lld requests:", px->counters.cum_fe_req);
+					chunk_printf(&msg, " title=\"%lld requests:", px->fe_counters.p.http.cum_req);
 
 					for (i = 1; i < 6; i++)
-						chunk_printf(&msg, " %dxx=%lld,", i, px->counters.fe.http.rsp[i]);
+						chunk_printf(&msg, " %dxx=%lld,", i, px->fe_counters.p.http.rsp[i]);
 
-					chunk_printf(&msg, " other=%lld\"", px->counters.fe.http.rsp[0]);
+					chunk_printf(&msg, " other=%lld\"", px->fe_counters.p.http.rsp[0]);
 				}
 
 				chunk_printf(&msg,
@@ -1799,9 +1805,9 @@
 				     "<td>%s</td><td>%s</td>"
 				     "",
 				     (px->mode == PR_MODE_HTTP)?"<u>":"",
-				     U2H6(px->counters.cum_fesess),
+				     U2H6(px->fe_counters.cum_sess),
 				     (px->mode == PR_MODE_HTTP)?"</u>":"",
-				     U2H7(px->counters.bytes_in), U2H8(px->counters.bytes_out));
+				     U2H7(px->fe_counters.bytes_in), U2H8(px->fe_counters.bytes_out));
 
 				chunk_printf(&msg,
 				     /* denied: req, resp */
@@ -1815,8 +1821,8 @@
 				     /* rest of server: nothing */
 				     "<td class=ac colspan=8></td></tr>"
 				     "",
-				     U2H0(px->counters.denied_req), U2H1(px->counters.denied_resp),
-				     U2H2(px->counters.failed_req),
+				     U2H0(px->fe_counters.denied_req), U2H1(px->fe_counters.denied_resp),
+				     U2H2(px->fe_counters.failed_req),
 				     px->state == PR_STRUN ? "OPEN" :
 				     px->state == PR_STIDLE ? "FULL" : "STOP");
 			} else {
@@ -1844,24 +1850,24 @@
 				     /* check_status, check_code, check_duration */
 				     ",,,",
 				     px->id,
-				     px->feconn, px->counters.feconn_max, px->maxconn, px->counters.cum_fesess,
-				     px->counters.bytes_in, px->counters.bytes_out,
-				     px->counters.denied_req, px->counters.denied_resp,
-				     px->counters.failed_req,
+				     px->feconn, px->fe_counters.conn_max, px->maxconn, px->fe_counters.cum_sess,
+				     px->fe_counters.bytes_in, px->fe_counters.bytes_out,
+				     px->fe_counters.denied_req, px->fe_counters.denied_resp,
+				     px->fe_counters.failed_req,
 				     px->state == PR_STRUN ? "OPEN" :
 				     px->state == PR_STIDLE ? "FULL" : "STOP",
 				     relative_pid, px->uuid, STATS_TYPE_FE,
 				     read_freq_ctr(&px->fe_sess_per_sec),
-				     px->fe_sps_lim, px->counters.fe_sps_max);
+				     px->fe_sps_lim, px->fe_counters.sps_max);
 
 				/* http response: 1xx, 2xx, 3xx, 4xx, 5xx, other */
 				if (px->mode == PR_MODE_HTTP) {
 					int i;
 
 					for (i=1; i<6; i++)
-						chunk_printf(&msg, "%lld,", px->counters.fe.http.rsp[i]);
+						chunk_printf(&msg, "%lld,", px->fe_counters.p.http.rsp[i]);
 
-					chunk_printf(&msg, "%lld,", px->counters.fe.http.rsp[0]);
+					chunk_printf(&msg, "%lld,", px->fe_counters.p.http.rsp[0]);
 				} else {
 					chunk_printf(&msg, ",,,,,,");
 				}
@@ -1872,7 +1878,7 @@
 				/* requests : req_rate, req_rate_max, req_tot, */
 				chunk_printf(&msg, "%u,%u,%lld,",
 					     read_freq_ctr(&px->fe_req_per_sec),
-					     px->counters.fe_rps_max, px->counters.cum_fe_req);
+					     px->fe_counters.p.http.rps_max, px->fe_counters.p.http.cum_req);
 
 				/* errors: cli_aborts, srv_aborts */
 				chunk_printf(&msg, ",,");
@@ -2485,15 +2491,15 @@
 				     (uri->flags & ST_SHLGNDS)?"<u>":"",
 				     px->id, px->id,
 				     (uri->flags & ST_SHLGNDS)?"</u>":"",
-				     U2H0(px->nbpend) /* or px->totpend ? */, U2H1(px->counters.nbpend_max),
-				     U2H2(read_freq_ctr(&px->be_sess_per_sec)), U2H3(px->counters.be_sps_max));
+				     U2H0(px->nbpend) /* or px->totpend ? */, U2H1(px->be_counters.nbpend_max),
+				     U2H2(read_freq_ctr(&px->be_sess_per_sec)), U2H3(px->be_counters.sps_max));
 
 				chunk_printf(&msg,
 				     /* sessions: current, max, limit */
 				     "<td>%s</td><td>%s</td><td>%s</td>"
 				     "<td"
 				     "",
-				     U2H2(px->beconn), U2H3(px->counters.beconn_max), U2H4(px->fullconn));
+				     U2H2(px->beconn), U2H3(px->be_counters.conn_max), U2H4(px->fullconn));
 
 				/* http response (via td title): 1xx, 2xx, 3xx, 4xx, 5xx, other */
 				if (px->mode == PR_MODE_HTTP) {
@@ -2502,9 +2508,9 @@
 					chunk_printf(&msg, " title=\"rsp codes:");
 
 					for (i = 1; i < 6; i++)
-						chunk_printf(&msg, " %dxx=%lld", i, px->counters.be.http.rsp[i]);
+						chunk_printf(&msg, " %dxx=%lld", i, px->be_counters.p.http.rsp[i]);
 
-					chunk_printf(&msg, " other=%lld\"", px->counters.be.http.rsp[0]);
+					chunk_printf(&msg, " other=%lld\"", px->be_counters.p.http.rsp[0]);
 				}
 
 				chunk_printf(&msg,
@@ -2514,10 +2520,10 @@
 				     "<td>%s</td><td>%s</td>"
 				     "",
 				     (px->mode == PR_MODE_HTTP)?"<u>":"",
-				     U2H6(px->counters.cum_beconn),
+				     U2H6(px->be_counters.cum_conn),
 				     (px->mode == PR_MODE_HTTP)?"</u>":"",
-				     U2H7(px->counters.cum_lbconn),
-				     U2H8(px->counters.bytes_in), U2H9(px->counters.bytes_out));
+				     U2H7(px->be_counters.cum_lbconn),
+				     U2H8(px->be_counters.bytes_in), U2H9(px->be_counters.bytes_out));
 
 				chunk_printf(&msg,
 				     /* denied: req, resp */
@@ -2535,12 +2541,12 @@
 				     "<td class=ac>%s %s</td><td class=ac>&nbsp;</td><td class=ac>%d</td>"
 				     "<td class=ac>%d</td><td class=ac>%d</td>"
 				     "",
-				     U2H0(px->counters.denied_req), U2H1(px->counters.denied_resp),
-				     U2H2(px->counters.failed_conns),
-				     px->counters.cli_aborts,
-				     px->counters.srv_aborts,
-				     U2H5(px->counters.failed_resp),
-				     px->counters.retries, px->counters.redispatches,
+				     U2H0(px->be_counters.denied_req), U2H1(px->be_counters.denied_resp),
+				     U2H2(px->be_counters.failed_conns),
+				     px->be_counters.cli_aborts,
+				     px->be_counters.srv_aborts,
+				     U2H5(px->be_counters.failed_resp),
+				     px->be_counters.retries, px->be_counters.redispatches,
 				     human_time(now.tv_sec - px->last_change, 1),
 				     (px->lbprm.tot_weight > 0 || !px->srv) ? "UP" :
 					     "<font color=\"red\"><b>DOWN</b></font>",
@@ -2586,30 +2592,30 @@
 				     /* check_status, check_code, check_duration */
 				     ",,,",
 				     px->id,
-				     px->nbpend /* or px->totpend ? */, px->counters.nbpend_max,
-				     px->beconn, px->counters.beconn_max, px->fullconn, px->counters.cum_beconn,
-				     px->counters.bytes_in, px->counters.bytes_out,
-				     px->counters.denied_req, px->counters.denied_resp,
-				     px->counters.failed_conns, px->counters.failed_resp,
-				     px->counters.retries, px->counters.redispatches,
+				     px->nbpend /* or px->totpend ? */, px->be_counters.nbpend_max,
+				     px->beconn, px->be_counters.conn_max, px->fullconn, px->be_counters.cum_conn,
+				     px->be_counters.bytes_in, px->be_counters.bytes_out,
+				     px->be_counters.denied_req, px->be_counters.denied_resp,
+				     px->be_counters.failed_conns, px->be_counters.failed_resp,
+				     px->be_counters.retries, px->be_counters.redispatches,
 				     (px->lbprm.tot_weight > 0 || !px->srv) ? "UP" : "DOWN",
 				     (px->lbprm.tot_weight * px->lbprm.wmult + px->lbprm.wdiv - 1) / px->lbprm.wdiv,
 				     px->srv_act, px->srv_bck,
 				     px->down_trans, (int)(now.tv_sec - px->last_change),
 				     px->srv?be_downtime(px):0,
 				     relative_pid, px->uuid,
-				     px->counters.cum_lbconn, STATS_TYPE_BE,
+				     px->be_counters.cum_lbconn, STATS_TYPE_BE,
 				     read_freq_ctr(&px->be_sess_per_sec),
-				     px->counters.be_sps_max);
+				     px->be_counters.sps_max);
 
 				/* http response: 1xx, 2xx, 3xx, 4xx, 5xx, other */
 				if (px->mode == PR_MODE_HTTP) {
 					int i;
 
 					for (i=1; i<6; i++)
-						chunk_printf(&msg, "%lld,", px->counters.be.http.rsp[i]);
+						chunk_printf(&msg, "%lld,", px->be_counters.p.http.rsp[i]);
 
-					chunk_printf(&msg, "%lld,", px->counters.be.http.rsp[0]);
+					chunk_printf(&msg, "%lld,", px->be_counters.p.http.rsp[0]);
 				} else {
 					chunk_printf(&msg, ",,,,,,");
 				}
@@ -2622,7 +2628,7 @@
 
 				/* errors: cli_aborts, srv_aborts */
 				chunk_printf(&msg, "%lld,%lld,",
-					     px->counters.cli_aborts, px->counters.srv_aborts);
+					     px->be_counters.cli_aborts, px->be_counters.srv_aborts);
 
 				/* finish with EOL */
 				chunk_printf(&msg, "\n");
diff --git a/src/frontend.c b/src/frontend.c
index 9c6ff0b..75218df 100644
--- a/src/frontend.c
+++ b/src/frontend.c
@@ -449,7 +449,7 @@
 	buffer_abort(s->rep);
 	req->analysers = 0;
 
-	s->fe->counters.failed_req++;
+	s->fe->fe_counters.failed_req++;
 	if (s->listener->counters)
 		s->listener->counters->failed_req++;
 
diff --git a/src/haproxy.c b/src/haproxy.c
index d1f7195..064c49c 100644
--- a/src/haproxy.c
+++ b/src/haproxy.c
@@ -1,6 +1,6 @@
 /*
  * HA-Proxy : High Availability-enabled HTTP/TCP proxy
- * Copyright 2000-2010  Willy Tarreau <w@1wt.eu>.
+ * Copyright 2000-2011  Willy Tarreau <w@1wt.eu>.
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
@@ -310,19 +310,19 @@
 			snprintf(trash, sizeof(trash),
 				 "SIGHUP: Proxy %s has no servers. Conn: act(FE+BE): %d+%d, %d pend (%d unass), tot(FE+BE): %lld+%lld.",
 				 p->id,
-				 p->feconn, p->beconn, p->totpend, p->nbpend, p->counters.cum_feconn, p->counters.cum_beconn);
+				 p->feconn, p->beconn, p->totpend, p->nbpend, p->fe_counters.cum_conn, p->be_counters.cum_conn);
 		} else if (p->srv_act == 0) {
 			snprintf(trash, sizeof(trash),
 				 "SIGHUP: Proxy %s %s ! Conn: act(FE+BE): %d+%d, %d pend (%d unass), tot(FE+BE): %lld+%lld.",
 				 p->id,
 				 (p->srv_bck) ? "is running on backup servers" : "has no server available",
-				 p->feconn, p->beconn, p->totpend, p->nbpend, p->counters.cum_feconn, p->counters.cum_beconn);
+				 p->feconn, p->beconn, p->totpend, p->nbpend, p->fe_counters.cum_conn, p->be_counters.cum_conn);
 		} else {
 			snprintf(trash, sizeof(trash),
 				 "SIGHUP: Proxy %s has %d active servers and %d backup servers available."
 				 " Conn: act(FE+BE): %d+%d, %d pend (%d unass), tot(FE+BE): %lld+%lld.",
 				 p->id, p->srv_act, p->srv_bck,
-				 p->feconn, p->beconn, p->totpend, p->nbpend, p->counters.cum_feconn, p->counters.cum_beconn);
+				 p->feconn, p->beconn, p->totpend, p->nbpend, p->fe_counters.cum_conn, p->be_counters.cum_conn);
 		}
 		Warning("%s\n", trash);
 		send_log(p, LOG_NOTICE, "%s\n", trash);
diff --git a/src/proto_http.c b/src/proto_http.c
index ff2f44c..c72cddf 100644
--- a/src/proto_http.c
+++ b/src/proto_http.c
@@ -2530,7 +2530,7 @@
 
 			session_inc_http_req_ctr(s);
 			proxy_inc_fe_req_ctr(s->fe);
-			s->fe->counters.failed_req++;
+			s->fe->fe_counters.failed_req++;
 			if (s->listener->counters)
 				s->listener->counters->failed_req++;
 
@@ -2559,7 +2559,7 @@
 
 			session_inc_http_req_ctr(s);
 			proxy_inc_fe_req_ctr(s->fe);
-			s->fe->counters.failed_req++;
+			s->fe->fe_counters.failed_req++;
 			if (s->listener->counters)
 				s->listener->counters->failed_req++;
 
@@ -2586,7 +2586,7 @@
 			session_inc_http_err_ctr(s);
 			session_inc_http_req_ctr(s);
 			proxy_inc_fe_req_ctr(s->fe);
-			s->fe->counters.failed_req++;
+			s->fe->fe_counters.failed_req++;
 			if (s->listener->counters)
 				s->listener->counters->failed_req++;
 
@@ -2862,7 +2862,7 @@
 	txn->status = 400;
 	stream_int_retnclose(req->prod, error_message(s, HTTP_ERR_400));
 
-	s->fe->counters.failed_req++;
+	s->fe->fe_counters.failed_req++;
 	if (s->listener->counters)
 		s->listener->counters->failed_req++;
 
@@ -3433,7 +3433,7 @@
 	txn->status = 400;
 	stream_int_retnclose(req->prod, error_message(s, HTTP_ERR_400));
 
-	s->fe->counters.failed_req++;
+	s->fe->fe_counters.failed_req++;
 	if (s->listener->counters)
 		s->listener->counters->failed_req++;
 
@@ -3683,7 +3683,7 @@
 	req->analysers = 0;
 	stream_int_retnclose(req->prod, error_message(s, HTTP_ERR_400));
 
-	s->fe->counters.failed_req++;
+	s->fe->fe_counters.failed_req++;
 	if (s->listener->counters)
 		s->listener->counters->failed_req++;
 
@@ -3727,7 +3727,7 @@
 	req->analysers = 0;
 	req->analyse_exp = TICK_ETERNITY;
 
-	s->fe->counters.failed_req++;
+	s->fe->fe_counters.failed_req++;
 	if (s->listener->counters)
 		s->listener->counters->failed_req++;
 
@@ -3867,7 +3867,7 @@
 
  return_err_msg:
 	req->analysers = 0;
-	s->fe->counters.failed_req++;
+	s->fe->fe_counters.failed_req++;
 	if (s->listener->counters)
 		s->listener->counters->failed_req++;
 	return 0;
@@ -3906,11 +3906,11 @@
 			n = 0;
 
 		if (s->fe->mode == PR_MODE_HTTP)
-			s->fe->counters.fe.http.rsp[n]++;
+			s->fe->fe_counters.p.http.rsp[n]++;
 
 		if ((s->flags & SN_BE_ASSIGNED) &&
 		    (s->be->mode == PR_MODE_HTTP))
-			s->be->counters.be.http.rsp[n]++;
+			s->be->be_counters.p.http.rsp[n]++;
 	}
 
 	/* don't count other requests' data */
@@ -4232,7 +4232,7 @@
 		}
 		else if (buf->flags & BF_SHUTW) {
 			txn->rsp.msg_state = HTTP_MSG_ERROR;
-			s->be->counters.cli_aborts++;
+			s->be->be_counters.cli_aborts++;
 			if (target_srv(&s->target))
 				target_srv(&s->target)->counters.cli_aborts++;
 			goto wait_other_side;
@@ -4513,9 +4513,8 @@
 				s->flags |= SN_FINST_D;
 		}
 
-		s->fe->counters.cli_aborts++;
-		if (s->fe != s->be)
-			s->be->counters.cli_aborts++;
+		s->fe->fe_counters.cli_aborts++;
+		s->be->be_counters.cli_aborts++;
 		if (target_srv(&s->target))
 			target_srv(&s->target)->counters.cli_aborts++;
 
@@ -4536,7 +4535,7 @@
 	return 0;
 
  return_bad_req: /* let's centralize all bad requests */
-	s->fe->counters.failed_req++;
+	s->fe->fe_counters.failed_req++;
 	if (s->listener->counters)
 		s->listener->counters->failed_req++;
  return_bad_req_stats_ok:
@@ -4573,9 +4572,8 @@
 	req->analysers = 0;
 	s->rep->analysers = 0; /* we're in data phase, we want to abort both directions */
 
-	s->fe->counters.srv_aborts++;
-	if (s->fe != s->be)
-		s->be->counters.srv_aborts++;
+	s->fe->fe_counters.srv_aborts++;
+	s->be->be_counters.srv_aborts++;
 	if (target_srv(&s->target))
 		target_srv(&s->target)->counters.srv_aborts++;
 
@@ -4702,7 +4700,7 @@
 			if (msg->msg_state == HTTP_MSG_ERROR || msg->err_pos >= 0)
 				http_capture_bad_message(&s->be->invalid_rep, s, rep, msg, msg->msg_state, s->fe);
 
-			s->be->counters.failed_resp++;
+			s->be->be_counters.failed_resp++;
 			if (target_srv(&s->target)) {
 				target_srv(&s->target)->counters.failed_resp++;
 				health_adjust(target_srv(&s->target), HANA_STATUS_HTTP_HDRRSP);
@@ -4733,7 +4731,7 @@
 			if (msg->err_pos >= 0)
 				http_capture_bad_message(&s->be->invalid_rep, s, rep, msg, msg->msg_state, s->fe);
 
-			s->be->counters.failed_resp++;
+			s->be->be_counters.failed_resp++;
 			if (target_srv(&s->target)) {
 				target_srv(&s->target)->counters.failed_resp++;
 				health_adjust(target_srv(&s->target), HANA_STATUS_HTTP_READ_ERROR);
@@ -4758,7 +4756,7 @@
 			if (msg->err_pos >= 0)
 				http_capture_bad_message(&s->be->invalid_rep, s, rep, msg, msg->msg_state, s->fe);
 
-			s->be->counters.failed_resp++;
+			s->be->be_counters.failed_resp++;
 			if (target_srv(&s->target)) {
 				target_srv(&s->target)->counters.failed_resp++;
 				health_adjust(target_srv(&s->target), HANA_STATUS_HTTP_READ_TIMEOUT);
@@ -4783,7 +4781,7 @@
 			if (msg->err_pos >= 0)
 				http_capture_bad_message(&s->be->invalid_rep, s, rep, msg, msg->msg_state, s->fe);
 
-			s->be->counters.failed_resp++;
+			s->be->be_counters.failed_resp++;
 			if (target_srv(&s->target)) {
 				target_srv(&s->target)->counters.failed_resp++;
 				health_adjust(target_srv(&s->target), HANA_STATUS_HTTP_BROKEN_PIPE);
@@ -4808,7 +4806,7 @@
 			if (msg->err_pos >= 0)
 				http_capture_bad_message(&s->be->invalid_rep, s, rep, msg, msg->msg_state, s->fe);
 
-			s->be->counters.failed_resp++;
+			s->be->be_counters.failed_resp++;
 			rep->analysers = 0;
 			buffer_auto_close(rep);
 
@@ -5130,7 +5128,7 @@
 						target_srv(&t->target)->counters.failed_resp++;
 						health_adjust(target_srv(&t->target), HANA_STATUS_HTTP_RSP);
 					}
-					cur_proxy->counters.failed_resp++;
+					t->be->be_counters.failed_resp++;
 				return_srv_prx_502:
 					rep->analysers = 0;
 					txn->status = 502;
@@ -5150,7 +5148,8 @@
 				if (target_srv(&t->target))
 					target_srv(&t->target)->counters.failed_secu++;
 
-				cur_proxy->counters.denied_resp++;
+				t->be->be_counters.denied_resp++;
+				t->fe->fe_counters.denied_resp++;
 				if (t->listener->counters)
 					t->listener->counters->denied_resp++;
 
@@ -5302,7 +5301,8 @@
 			if (target_srv(&t->target))
 				target_srv(&t->target)->counters.failed_secu++;
 
-			cur_proxy->counters.denied_resp++;
+			t->be->be_counters.denied_resp++;
+			t->fe->fe_counters.denied_resp++;
 			if (t->listener->counters)
 				t->listener->counters->denied_resp++;
 
@@ -5527,7 +5527,7 @@
 	if (res->flags & BF_SHUTR) {
 		if (!(s->flags & SN_ERR_MASK))
 			s->flags |= SN_ERR_SRVCL;
-		s->be->counters.srv_aborts++;
+		s->be->be_counters.srv_aborts++;
 		if (target_srv(&s->target))
 			target_srv(&s->target)->counters.srv_aborts++;
 		goto return_bad_res_stats_ok;
@@ -5565,7 +5565,7 @@
 	return 0;
 
  return_bad_res: /* let's centralize all bad responses */
-	s->be->counters.failed_resp++;
+	s->be->be_counters.failed_resp++;
 	if (target_srv(&s->target))
 		target_srv(&s->target)->counters.failed_resp++;
 
@@ -5591,9 +5591,8 @@
 	res->analysers = 0;
 	s->req->analysers = 0; /* we're in data phase, we want to abort both directions */
 
-	s->fe->counters.cli_aborts++;
-	if (s->fe != s->be)
-		s->be->counters.cli_aborts++;
+	s->fe->fe_counters.cli_aborts++;
+	s->be->be_counters.cli_aborts++;
 	if (target_srv(&s->target))
 		target_srv(&s->target)->counters.cli_aborts++;
 
@@ -5677,7 +5676,9 @@
 				txn->flags |= TX_CLDENY;
 				last_hdr = 1;
 
-				t->be->counters.denied_req++;
+				t->fe->fe_counters.denied_req++;
+				if (t->fe != t->be)
+					t->be->be_counters.denied_req++;
 				if (t->listener->counters)
 					t->listener->counters->denied_req++;
 
@@ -5687,7 +5688,9 @@
 				txn->flags |= TX_CLTARPIT;
 				last_hdr = 1;
 
-				t->be->counters.denied_req++;
+				t->fe->fe_counters.denied_req++;
+				if (t->fe != t->be)
+					t->be->be_counters.denied_req++;
 				if (t->listener->counters)
 					t->listener->counters->denied_req++;
 
@@ -5796,7 +5799,9 @@
 		case ACT_DENY:
 			txn->flags |= TX_CLDENY;
 
-			t->be->counters.denied_req++;
+			t->fe->fe_counters.denied_req++;
+			if (t->fe != t->be)
+				t->be->be_counters.denied_req++;
 			if (t->listener->counters)
 				t->listener->counters->denied_req++;
 
@@ -5806,7 +5811,9 @@
 		case ACT_TARPIT:
 			txn->flags |= TX_CLTARPIT;
 
-			t->be->counters.denied_req++;
+			t->fe->fe_counters.denied_req++;
+			if (t->fe != t->be)
+				t->be->be_counters.denied_req++;
 			if (t->listener->counters)
 				t->listener->counters->denied_req++;
 
diff --git a/src/proto_tcp.c b/src/proto_tcp.c
index 04562f1..d40f85c 100644
--- a/src/proto_tcp.c
+++ b/src/proto_tcp.c
@@ -726,7 +726,8 @@
 				buffer_abort(s->rep);
 				req->analysers = 0;
 
-				s->be->counters.denied_req++;
+				s->be->be_counters.denied_req++;
+				s->fe->fe_counters.denied_req++;
 				if (s->listener->counters)
 					s->listener->counters->denied_req++;
 
@@ -842,7 +843,8 @@
 				buffer_abort(s->req);
 				rep->analysers = 0;
 
-				s->be->counters.denied_resp++;
+				s->be->be_counters.denied_resp++;
+				s->fe->fe_counters.denied_resp++;
 				if (s->listener->counters)
 					s->listener->counters->denied_resp++;
 
@@ -894,7 +896,7 @@
 		if (ret) {
 			/* we have a matching rule. */
 			if (rule->action == TCP_ACT_REJECT) {
-				s->fe->counters.denied_conn++;
+				s->fe->fe_counters.denied_conn++;
 				if (s->listener->counters)
 					s->listener->counters->denied_conn++;
 
diff --git a/src/proxy.c b/src/proxy.c
index 0c6640e..0129b12 100644
--- a/src/proxy.c
+++ b/src/proxy.c
@@ -536,9 +536,9 @@
 				t = tick_remain(now_ms, p->stop_time);
 				if (t == 0) {
 					Warning("Proxy %s stopped (FE: %lld conns, BE: %lld conns).\n",
-						p->id, p->counters.cum_feconn, p->counters.cum_beconn);
+						p->id, p->fe_counters.cum_conn, p->be_counters.cum_conn);
 					send_log(p, LOG_WARNING, "Proxy %s stopped (FE: %lld conns, BE: %lld conns).\n",
-						 p->id, p->counters.cum_feconn, p->counters.cum_beconn);
+						 p->id, p->fe_counters.cum_conn, p->be_counters.cum_conn);
 					stop_proxy(p);
 					/* try to free more memory */
 					pool_gc2();
@@ -766,8 +766,8 @@
 		return 1;
 	s->be = be;
 	be->beconn++;
-	if (be->beconn > be->counters.beconn_max)
-		be->counters.beconn_max = be->beconn;
+	if (be->beconn > be->be_counters.conn_max)
+		be->be_counters.conn_max = be->beconn;
 	proxy_inc_be_ctr(be);
 
 	/* assign new parameters to the session from the new backend */
diff --git a/src/queue.c b/src/queue.c
index ae99284..48380fc 100644
--- a/src/queue.c
+++ b/src/queue.c
@@ -159,8 +159,8 @@
 		LIST_ADDQ(&sess->be->pendconns, &p->list);
 		sess->be->nbpend++;
 		sess->logs.prx_queue_size += sess->be->nbpend;
-		if (sess->be->nbpend > sess->be->counters.nbpend_max)
-			sess->be->counters.nbpend_max = sess->be->nbpend;
+		if (sess->be->nbpend > sess->be->be_counters.nbpend_max)
+			sess->be->be_counters.nbpend_max = sess->be->nbpend;
 	}
 	sess->be->totpend++;
 	return p;
diff --git a/src/session.c b/src/session.c
index 5cd0853..2127576 100644
--- a/src/session.c
+++ b/src/session.c
@@ -130,8 +130,8 @@
 	}
 
 	/* This session was accepted, count it now */
-	if (p->feconn > p->counters.feconn_max)
-		p->counters.feconn_max = p->feconn;
+	if (p->feconn > p->fe_counters.conn_max)
+		p->fe_counters.conn_max = p->feconn;
 
 	proxy_inc_fe_sess_ctr(l, p);
 	if (s->stkctr1_entry) {
@@ -410,10 +410,9 @@
 		bytes = s->req->total - s->logs.bytes_in;
 		s->logs.bytes_in = s->req->total;
 		if (bytes) {
-			s->fe->counters.bytes_in			+= bytes;
+			s->fe->fe_counters.bytes_in			+= bytes;
 
-			if (s->be != s->fe)
-				s->be->counters.bytes_in		+= bytes;
+			s->be->be_counters.bytes_in			+= bytes;
 
 			if (target_srv(&s->target))
 				target_srv(&s->target)->counters.bytes_in		+= bytes;
@@ -461,10 +460,9 @@
 		bytes = s->rep->total - s->logs.bytes_out;
 		s->logs.bytes_out = s->rep->total;
 		if (bytes) {
-			s->fe->counters.bytes_out			+= bytes;
+			s->fe->fe_counters.bytes_out			+= bytes;
 
-			if (s->be != s->fe)
-				s->be->counters.bytes_out		+= bytes;
+			s->be->be_counters.bytes_out			+= bytes;
 
 			if (target_srv(&s->target))
 				target_srv(&s->target)->counters.bytes_out		+= bytes;
@@ -606,7 +604,7 @@
 
 		if (target_srv(&s->target))
 			target_srv(&s->target)->counters.failed_conns++;
-		s->be->counters.failed_conns++;
+		s->be->be_counters.failed_conns++;
 		sess_change_server(s, NULL);
 		if (may_dequeue_tasks(target_srv(&s->target), s->be))
 			process_srv_queue(target_srv(&s->target));
@@ -639,7 +637,7 @@
 	} else {
 		if (target_srv(&s->target))
 			target_srv(&s->target)->counters.retries++;
-		s->be->counters.retries++;
+		s->be->be_counters.retries++;
 		si->state = SI_ST_ASS;
 	}
 
@@ -743,7 +741,7 @@
 				srv_inc_sess_ctr(srv);
 			if (srv)
 				srv->counters.failed_conns++;
-			s->be->counters.failed_conns++;
+			s->be->be_counters.failed_conns++;
 
 			/* release other sessions waiting for this server */
 			sess_change_server(s, NULL);
@@ -799,7 +797,7 @@
 			s->logs.t_queue = tv_ms_elapsed(&s->logs.tv_accept, &now);
 			if (srv)
 				srv->counters.failed_conns++;
-			s->be->counters.failed_conns++;
+			s->be->be_counters.failed_conns++;
 			si->shutr(si);
 			si->shutw(si);
 			si->ob->flags |= BF_WRITE_TIMEOUT;
@@ -1279,7 +1277,8 @@
 			s->si[0].shutw(&s->si[0]);
 			stream_int_report_error(&s->si[0]);
 			if (!(s->req->analysers) && !(s->rep->analysers)) {
-				s->be->counters.cli_aborts++;
+				s->be->be_counters.cli_aborts++;
+				s->fe->fe_counters.cli_aborts++;
 				if (srv)
 					srv->counters.cli_aborts++;
 				if (!(s->flags & SN_ERR_MASK))
@@ -1295,11 +1294,12 @@
 			s->si[1].shutr(&s->si[1]);
 			s->si[1].shutw(&s->si[1]);
 			stream_int_report_error(&s->si[1]);
-			s->be->counters.failed_resp++;
+			s->be->be_counters.failed_resp++;
 			if (srv)
 				srv->counters.failed_resp++;
 			if (!(s->req->analysers) && !(s->rep->analysers)) {
-				s->be->counters.srv_aborts++;
+				s->be->be_counters.srv_aborts++;
+				s->fe->fe_counters.srv_aborts++;
 				if (srv)
 					srv->counters.srv_aborts++;
 				if (!(s->flags & SN_ERR_MASK))
@@ -1659,25 +1659,29 @@
 			/* Report it if the client got an error or a read timeout expired */
 			s->req->analysers = 0;
 			if (s->req->flags & BF_READ_ERROR) {
-				s->be->counters.cli_aborts++;
+				s->be->be_counters.cli_aborts++;
+				s->fe->fe_counters.cli_aborts++;
 				if (srv)
 					srv->counters.cli_aborts++;
 				s->flags |= SN_ERR_CLICL;
 			}
 			else if (s->req->flags & BF_READ_TIMEOUT) {
-				s->be->counters.cli_aborts++;
+				s->be->be_counters.cli_aborts++;
+				s->fe->fe_counters.cli_aborts++;
 				if (srv)
 					srv->counters.cli_aborts++;
 				s->flags |= SN_ERR_CLITO;
 			}
 			else if (s->req->flags & BF_WRITE_ERROR) {
-				s->be->counters.srv_aborts++;
+				s->be->be_counters.srv_aborts++;
+				s->fe->fe_counters.srv_aborts++;
 				if (srv)
 					srv->counters.srv_aborts++;
 				s->flags |= SN_ERR_SRVCL;
 			}
 			else {
-				s->be->counters.srv_aborts++;
+				s->be->be_counters.srv_aborts++;
+				s->fe->fe_counters.srv_aborts++;
 				if (srv)
 					srv->counters.srv_aborts++;
 				s->flags |= SN_ERR_SRVTO;
@@ -1688,25 +1692,29 @@
 			/* Report it if the server got an error or a read timeout expired */
 			s->rep->analysers = 0;
 			if (s->rep->flags & BF_READ_ERROR) {
-				s->be->counters.srv_aborts++;
+				s->be->be_counters.srv_aborts++;
+				s->fe->fe_counters.srv_aborts++;
 				if (srv)
 					srv->counters.srv_aborts++;
 				s->flags |= SN_ERR_SRVCL;
 			}
 			else if (s->rep->flags & BF_READ_TIMEOUT) {
-				s->be->counters.srv_aborts++;
+				s->be->be_counters.srv_aborts++;
+				s->fe->fe_counters.srv_aborts++;
 				if (srv)
 					srv->counters.srv_aborts++;
 				s->flags |= SN_ERR_SRVTO;
 			}
 			else if (s->rep->flags & BF_WRITE_ERROR) {
-				s->be->counters.cli_aborts++;
+				s->be->be_counters.cli_aborts++;
+				s->fe->fe_counters.cli_aborts++;
 				if (srv)
 					srv->counters.cli_aborts++;
 				s->flags |= SN_ERR_CLICL;
 			}
 			else {
-				s->be->counters.cli_aborts++;
+				s->be->be_counters.cli_aborts++;
+				s->fe->fe_counters.cli_aborts++;
 				if (srv)
 					srv->counters.cli_aborts++;
 				s->flags |= SN_ERR_CLITO;
@@ -2063,11 +2071,11 @@
 			n = 0;
 
 		if (s->fe->mode == PR_MODE_HTTP)
-			s->fe->counters.fe.http.rsp[n]++;
+			s->fe->fe_counters.p.http.rsp[n]++;
 
 		if ((s->flags & SN_BE_ASSIGNED) &&
 		    (s->be->mode == PR_MODE_HTTP))
-			s->be->counters.be.http.rsp[n]++;
+			s->be->be_counters.p.http.rsp[n]++;
 	}
 
 	/* let's do a final log if we need it */
@@ -2120,7 +2128,7 @@
 	if (!(s->flags & SN_FINST_MASK)) {
 		if (s->si[1].state < SI_ST_REQ) {
 
-			s->fe->counters.failed_req++;
+			s->fe->fe_counters.failed_req++;
 			if (s->listener->counters)
 				s->listener->counters->failed_req++;