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 */
 
