OPTIM: stats: store fast sharded counters pointers at session and stream level

Following commit 75e480d10 ("MEDIUM: stats: avoid 1 indirection by storing
the shared stats directly in counters struct"), in order to minimize the
impact of the recent sharded counters work, we try to push things a bit
further in this patch by storing and using "fast" pointers at the session
and stream levels when available to avoid costly indirections and
systematic "tgid" resolution (which can not be cached by the CPU due to
its THREAD-local nature).

Indeed, we know that a session/stream is tied to a given CPU, thanks to
this we know that the tgid for a given session/stream will never change.

Given that, we are able to store sharded frontend and listener counters
pointer at the session level (namely sess->fe_tgcounters and
sess->li_tgcounters), and once the backend and the server are selected,
we are also able to store backend and server sharded counters
pointer at the stream level (namely s->be_tgcounters and s->sv_tgcounters)

Everywhere we rely on these counters and the stream or session context is
available, we use the fast pointers it instead of the indirect pointers
path to make the pointer resolution a bit faster.

This optimization proved to bring a few percents back, and together with
the previous 75e480d10 commit we now fixed the performance regression (we
are back to back with 3.2 stats performance)

diff --git a/include/haproxy/session-t.h b/include/haproxy/session-t.h
index 7f034dd5b3a9aca2af572bbbfb431210568060cc..8889916a8a33170253affb4efeeefab59a2652e3 100644 (file)
--- a/include/haproxy/session-t.h
+++ b/include/haproxy/session-t.h
@@ -61,6 +61,8 @@ struct session {
        struct list priv_conns;         /* list of private conns */
        struct sockaddr_storage *src; /* source address (pool), when known, otherwise NULL */
        struct sockaddr_storage *dst; /* destination address (pool), when known, otherwise NULL */
+       struct fe_counters_shared_tg *fe_tgcounters; /* pointer to current thread group shared frontend counters */
+       struct fe_counters_shared_tg *li_tgcounters; /* pointer to current thread group shared listener counters */
 };
 
 /*

diff --git a/include/haproxy/stream-t.h b/include/haproxy/stream-t.h
index 7f44202ab87acd0a1d369f2204eddca191eaf317..83db4cc20e3ee504894cfd735a0314a666ce9c1d 100644 (file)
--- a/include/haproxy/stream-t.h
+++ b/include/haproxy/stream-t.h
@@ -340,6 +340,8 @@ struct stream {
                int hostname_dn_len;            /* size of hostname_dn */
                /* 4 unused bytes here, recoverable via packing if needed */
        } resolv_ctx;                           /* context information for DNS resolution */
+       struct be_counters_shared_tg *be_tgcounters; /* pointer to current thread group shared backend counters */
+       struct be_counters_shared_tg *sv_tgcounters; /* pointer to current thread group shared server counters */
 };
 
 #endif /* _HAPROXY_STREAM_T_H */

diff --git a/include/haproxy/stream.h b/include/haproxy/stream.h
index 3f6635c7170440d6b2bc4508b74669396ef19676..fa71c32127a93e339db09e78d88c0b7b94f79b1f 100644 (file)
--- a/include/haproxy/stream.h
+++ b/include/haproxy/stream.h
@@ -362,8 +362,8 @@ static inline void stream_choose_redispatch(struct stream *s)
                s->scb->state = SC_ST_REQ;
        } else {
                if (objt_server(s->target))
-                       _HA_ATOMIC_INC(&__objt_server(s->target)->counters.shared.tg[tgid - 1]->retries);
-               _HA_ATOMIC_INC(&s->be->be_counters.shared.tg[tgid - 1]->retries);
+                       _HA_ATOMIC_INC(&s->sv_tgcounters->retries);
+               _HA_ATOMIC_INC(&s->be_tgcounters->retries);
                s->scb->state = SC_ST_ASS;
        }
 
@@ -432,6 +432,11 @@ static inline void stream_report_term_evt(struct stconn *sc, enum strm_term_even
        sc->term_evts_log = tevt_report_event(sc->term_evts_log, loc, type);
 }
 
+static inline void stream_set_srv_target(struct stream *s, struct server *srv)
+{
+       s->target = &srv->obj_type;
+       s->sv_tgcounters = srv->counters.shared.tg[tgid - 1];
+}
 
 int stream_set_timeout(struct stream *s, enum act_timeout_name name, int timeout);
 void stream_retnclose(struct stream *s, const struct buffer *msg);

diff --git a/src/backend.c b/src/backend.c
index ea9476088bc212aa0fa98a11380091e141f165d6..de16e680c0952c9c65b8fff21d028746d41a9ff8 100644 (file)
--- a/src/backend.c
+++ b/src/backend.c
@@ -660,7 +660,7 @@ int assign_server(struct stream *s)
                                list_for_each_entry(conn, &pconns->conn_list, sess_el) {
                                        if (!(conn->flags & CO_FL_WAIT_XPRT)) {
                                                srv = tmpsrv;
-                                               s->target = &srv->obj_type;
+                                               stream_set_srv_target(s, srv);
                                                if (conn->flags & CO_FL_SESS_IDLE) {
                                                        conn->flags &= ~CO_FL_SESS_IDLE;
                                                        s->sess->idle_conns--;
@@ -825,10 +825,10 @@ int assign_server(struct stream *s)
                        goto out;
                }
                else if (srv != prev_srv) {
-                       _HA_ATOMIC_INC(&s->be->be_counters.shared.tg[tgid - 1]->cum_lbconn);
+                       _HA_ATOMIC_INC(&s->be_tgcounters->cum_lbconn);
                        _HA_ATOMIC_INC(&srv->counters.shared.tg[tgid - 1]->cum_lbconn);
                }
-               s->target = &srv->obj_type;
+               stream_set_srv_target(s, srv);
        }
        else if (s->be->options & (PR_O_DISPATCH | PR_O_TRANSP)) {
                s->target = &s->be->obj_type;
@@ -1001,10 +1001,10 @@ int assign_server_and_queue(struct stream *s)
                                }
                                s->flags |= SF_REDISP;
                                _HA_ATOMIC_INC(&prev_srv->counters.shared.tg[tgid - 1]->redispatches);
-                               _HA_ATOMIC_INC(&s->be->be_counters.shared.tg[tgid - 1]->redispatches);
+                               _HA_ATOMIC_INC(&s->be_tgcounters->redispatches);
                        } else {
                                _HA_ATOMIC_INC(&prev_srv->counters.shared.tg[tgid - 1]->retries);
-                               _HA_ATOMIC_INC(&s->be->be_counters.shared.tg[tgid - 1]->retries);
+                               _HA_ATOMIC_INC(&s->be_tgcounters->retries);
                        }
                }
        }
@@ -1154,7 +1154,8 @@ int assign_server_and_queue(struct stream *s)
                                        pool_free(pool_head_pendconn, p);
 
                                        s->flags |= SF_ASSIGNED;
-                                       s->target = &newserv->obj_type;
+                                       stream_set_srv_target(s, newserv);
+
                                        s->pend_pos = NULL;
                                        sess_change_server(s, newserv);
                                        return SRV_STATUS_OK;
@@ -2091,13 +2092,13 @@ int connect_server(struct stream *s)
                s->scb->flags |= SC_FL_NOLINGER;
 
        if (s->flags & SF_SRV_REUSED) {
-               _HA_ATOMIC_INC(&s->be->be_counters.shared.tg[tgid - 1]->reuse);
+               _HA_ATOMIC_INC(&s->be_tgcounters->reuse);
                if (srv)
-                       _HA_ATOMIC_INC(&srv->counters.shared.tg[tgid - 1]->reuse);
+                       _HA_ATOMIC_INC(&s->sv_tgcounters->reuse);
        } else {
-               _HA_ATOMIC_INC(&s->be->be_counters.shared.tg[tgid - 1]->connect);
+               _HA_ATOMIC_INC(&s->be_tgcounters->connect);
                if (srv)
-                       _HA_ATOMIC_INC(&srv->counters.shared.tg[tgid - 1]->connect);
+                       _HA_ATOMIC_INC(&s->sv_tgcounters->connect);
        }
 
        err = do_connect_server(s, srv_conn);
@@ -2286,8 +2287,8 @@ int srv_redispatch_connect(struct stream *s)
                        s->conn_err_type = STRM_ET_QUEUE_ERR;
                }
 
-               _HA_ATOMIC_INC(&srv->counters.shared.tg[tgid - 1]->failed_conns);
-               _HA_ATOMIC_INC(&s->be->be_counters.shared.tg[tgid - 1]->failed_conns);
+               _HA_ATOMIC_INC(&s->sv_tgcounters->failed_conns);
+               _HA_ATOMIC_INC(&s->be_tgcounters->failed_conns);
                return 1;
 
        case SRV_STATUS_NOSRV:
@@ -2296,7 +2297,7 @@ int srv_redispatch_connect(struct stream *s)
                        s->conn_err_type = STRM_ET_CONN_ERR;
                }
 
-               _HA_ATOMIC_INC(&s->be->be_counters.shared.tg[tgid - 1]->failed_conns);
+               _HA_ATOMIC_INC(&s->be_tgcounters->failed_conns);
                return 1;
 
        case SRV_STATUS_QUEUED:
@@ -2325,8 +2326,8 @@ int srv_redispatch_connect(struct stream *s)
                if (srv)
                        srv_set_sess_last(srv);
                if (srv)
-                       _HA_ATOMIC_INC(&srv->counters.shared.tg[tgid - 1]->failed_conns);
-               _HA_ATOMIC_INC(&s->be->be_counters.shared.tg[tgid - 1]->failed_conns);
+                       _HA_ATOMIC_INC(&s->sv_tgcounters->failed_conns);
+               _HA_ATOMIC_INC(&s->be_tgcounters->failed_conns);
 
                /* release other streams waiting for this server */
                if (may_dequeue_tasks(srv, s->be))
@@ -2400,8 +2401,8 @@ void back_try_conn_req(struct stream *s)
                        if (srv)
                                srv_set_sess_last(srv);
                        if (srv)
-                               _HA_ATOMIC_INC(&srv->counters.shared.tg[tgid - 1]->failed_conns);
-                       _HA_ATOMIC_INC(&s->be->be_counters.shared.tg[tgid - 1]->failed_conns);
+                               _HA_ATOMIC_INC(&s->sv_tgcounters->failed_conns);
+                       _HA_ATOMIC_INC(&s->be_tgcounters->failed_conns);
 
                        /* release other streams waiting for this server */
                        sess_change_server(s, NULL);
@@ -2467,8 +2468,8 @@ void back_try_conn_req(struct stream *s)
                        pendconn_cond_unlink(s->pend_pos);
 
                        if (srv)
-                               _HA_ATOMIC_INC(&srv->counters.shared.tg[tgid - 1]->failed_conns);
-                       _HA_ATOMIC_INC(&s->be->be_counters.shared.tg[tgid - 1]->failed_conns);
+                               _HA_ATOMIC_INC(&s->sv_tgcounters->failed_conns);
+                       _HA_ATOMIC_INC(&s->be_tgcounters->failed_conns);
                        sc_abort(sc);
                        sc_shutdown(sc);
                        req->flags |= CF_WRITE_TIMEOUT;
@@ -2723,8 +2724,8 @@ void back_handle_st_cer(struct stream *s)
                }
 
                if (objt_server(s->target))
-                       _HA_ATOMIC_INC(&objt_server(s->target)->counters.shared.tg[tgid - 1]->failed_conns);
-               _HA_ATOMIC_INC(&s->be->be_counters.shared.tg[tgid - 1]->failed_conns);
+                       _HA_ATOMIC_INC(&s->sv_tgcounters->failed_conns);
+               _HA_ATOMIC_INC(&s->be_tgcounters->failed_conns);
                sess_change_server(s, NULL);
                if (may_dequeue_tasks(objt_server(s->target), s->be))
                        process_srv_queue(objt_server(s->target));
@@ -2756,8 +2757,8 @@ void back_handle_st_cer(struct stream *s)
                        s->conn_err_type = STRM_ET_CONN_OTHER;
 
                if (objt_server(s->target))
-                       _HA_ATOMIC_INC(&objt_server(s->target)->counters.shared.tg[tgid - 1]->internal_errors);
-               _HA_ATOMIC_INC(&s->be->be_counters.shared.tg[tgid - 1]->internal_errors);
+                       _HA_ATOMIC_INC(&s->sv_tgcounters->internal_errors);
+               _HA_ATOMIC_INC(&s->be_tgcounters->internal_errors);
                sess_change_server(s, NULL);
                if (may_dequeue_tasks(objt_server(s->target), s->be))
                        process_srv_queue(objt_server(s->target));
@@ -2953,7 +2954,7 @@ int tcp_persist_rdp_cookie(struct stream *s, struct channel *req, int an_bit)
                        if ((srv->cur_state != SRV_ST_STOPPED) || (px->options & PR_O_PERSIST)) {
                                /* we found the server and it is usable */
                                s->flags |= SF_DIRECT | SF_ASSIGNED;
-                               s->target = &srv->obj_type;
+                               stream_set_srv_target(s, srv);
                                break;
                        }
                }

diff --git a/src/cli.c b/src/cli.c
index 6ca73059d35b1eb4bec3b4256adb4d94acb5c766..9895b819ea1fb8fe9602319bc53044bd15105d2e 100644 (file)
--- a/src/cli.c
+++ b/src/cli.c
@@ -3364,6 +3364,8 @@ read_again:
                                target_pid = s->pcli_next_pid;
                        /* we can connect now */
                        s->target = pcli_pid_to_server(target_pid);
+                       if (objt_server(s->target))
+                               s->sv_tgcounters = __objt_server(s->target)->counters.shared.tg[tgid - 1];
 
                        if (!s->target)
                                goto server_disconnect;

diff --git a/src/dns.c b/src/dns.c
index bb4ffc6d8fff5743c84cd593d08b1d1386dbb2eb..16b3ef76ed4eeed46815fa7a9b8ff0ac6f1dcb58 100644 (file)
--- a/src/dns.c
+++ b/src/dns.c
@@ -833,7 +833,7 @@ static int dns_session_init(struct appctx *appctx)
        s = appctx_strm(appctx);
        s->scb->dst = addr;
        s->scb->flags |= (SC_FL_RCV_ONCE|SC_FL_NOLINGER);
-       s->target = &ds->dss->srv->obj_type;
+       stream_set_srv_target(s, ds->dss->srv);
        s->flags = SF_ASSIGNED;
 
        s->do_log = NULL;

diff --git a/src/fcgi-app.c b/src/fcgi-app.c
index 2dcf331ebe6edeffdc26133dc06ccd67f7222728..8bddd1c29b1b6f0b1f909eb430c9d8ab2c2b679a 100644 (file)
--- a/src/fcgi-app.c
+++ b/src/fcgi-app.c
@@ -446,12 +446,12 @@ static int fcgi_flt_http_headers(struct stream *s, struct filter *filter, struct
        goto end;
 
   rewrite_err:
-       _HA_ATOMIC_INC(&sess->fe->fe_counters.shared.tg[tgid - 1]->failed_rewrites);
-       _HA_ATOMIC_INC(&s->be->be_counters.shared.tg[tgid - 1]->failed_rewrites);
+       _HA_ATOMIC_INC(&sess->fe_tgcounters->failed_rewrites);
+       _HA_ATOMIC_INC(&s->be_tgcounters->failed_rewrites);
        if (sess->listener && sess->listener->counters)
-               _HA_ATOMIC_INC(&sess->listener->counters->shared.tg[tgid - 1]->failed_rewrites);
+               _HA_ATOMIC_INC(&sess->li_tgcounters->failed_rewrites);
        if (objt_server(s->target))
-               _HA_ATOMIC_INC(&__objt_server(s->target)->counters.shared.tg[tgid - 1]->failed_rewrites);
+               _HA_ATOMIC_INC(&s->sv_tgcounters->failed_rewrites);
   hdr_rule_err:
        node = ebpt_first(&hdr_rules);
        while (node) {

diff --git a/src/flt_http_comp.c b/src/flt_http_comp.c
index bc9a3cea21a1453b81a337e5c21acc7ffe5db691..9862f7d0de42d8a8b13ac72110c865508a5029de 100644 (file)
--- a/src/flt_http_comp.c
+++ b/src/flt_http_comp.c
@@ -393,14 +393,14 @@ comp_http_payload(struct stream *s, struct filter *filter, struct http_msg *msg,
 
        if (st->comp_ctx[dir] && st->comp_ctx[dir]->cur_lvl > 0) {
                update_freq_ctr(&global.comp_bps_in, consumed);
-               _HA_ATOMIC_ADD(&strm_fe(s)->fe_counters.shared.tg[tgid - 1]->comp_in[dir], consumed);
-               _HA_ATOMIC_ADD(&s->be->be_counters.shared.tg[tgid - 1]->comp_in[dir], consumed);
+               _HA_ATOMIC_ADD(&s->sess->fe_tgcounters->comp_in[dir], consumed);
+               _HA_ATOMIC_ADD(&s->be_tgcounters->comp_in[dir], consumed);
                update_freq_ctr(&global.comp_bps_out, to_forward);
-               _HA_ATOMIC_ADD(&strm_fe(s)->fe_counters.shared.tg[tgid - 1]->comp_out[dir], to_forward);
-               _HA_ATOMIC_ADD(&s->be->be_counters.shared.tg[tgid - 1]->comp_out[dir], to_forward);
+               _HA_ATOMIC_ADD(&s->sess->fe_tgcounters->comp_out[dir], to_forward);
+               _HA_ATOMIC_ADD(&s->be_tgcounters->comp_out[dir], to_forward);
        } else {
-               _HA_ATOMIC_ADD(&strm_fe(s)->fe_counters.shared.tg[tgid - 1]->comp_byp[dir], consumed);
-               _HA_ATOMIC_ADD(&s->be->be_counters.shared.tg[tgid - 1]->comp_byp[dir], consumed);
+               _HA_ATOMIC_ADD(&s->sess->fe_tgcounters->comp_byp[dir], consumed);
+               _HA_ATOMIC_ADD(&s->be_tgcounters->comp_byp[dir], consumed);
        }
        return to_forward;
 
@@ -419,9 +419,9 @@ comp_http_end(struct stream *s, struct filter *filter,
                goto end;
 
        if (strm_fe(s)->mode == PR_MODE_HTTP)
-               _HA_ATOMIC_INC(&strm_fe(s)->fe_counters.shared.tg[tgid - 1]->p.http.comp_rsp);
+               _HA_ATOMIC_INC(&s->sess->fe_tgcounters->p.http.comp_rsp);
        if ((s->flags & SF_BE_ASSIGNED) && (s->be->mode == PR_MODE_HTTP))
-               _HA_ATOMIC_INC(&s->be->be_counters.shared.tg[tgid - 1]->p.http.comp_rsp);
+               _HA_ATOMIC_INC(&s->be_tgcounters->p.http.comp_rsp);
  end:
        return 1;
 }

diff --git a/src/hlua.c b/src/hlua.c
index c3435e651bea61658317e20b123feae536e82bf8..22eb0db286cef70b7dc6466061c5ff3bbf48e471 100644 (file)
--- a/src/hlua.c
+++ b/src/hlua.c
@@ -2727,7 +2727,7 @@ static int hlua_socket_init(struct appctx *appctx)
 
        /* Force destination server. */
        s->flags |= SF_DIRECT | SF_ASSIGNED | SF_BE_ASSIGNED;
-       s->target = &csk_ctx->srv->obj_type;
+       stream_set_srv_target(s, csk_ctx->srv);
 
        if (csk_ctx->timeout) {
                s->sess->fe->timeout.connect = csk_ctx->timeout;
@@ -8922,7 +8922,7 @@ __LJMP static int hlua_txn_done(lua_State *L)
                /* let's log the request time */
                s->logs.request_ts = now_ns;
                if (s->sess->fe == s->be) /* report it if the request was intercepted by the frontend */
-                       _HA_ATOMIC_INC(&s->sess->fe->fe_counters.shared.tg[tgid - 1]->intercepted_req);
+                       _HA_ATOMIC_INC(&s->sess->fe_tgcounters->intercepted_req);
        }
 
   done:

diff --git a/src/http_act.c b/src/http_act.c
index 112fbd891dee7d9e5f529ff50b0696bae2dc9a9e..c583d9bd23d6d4c7d4a2ebe9d952badc69ce12b7 100644 (file)
--- a/src/http_act.c
+++ b/src/http_act.c
@@ -116,13 +116,13 @@ static enum act_return http_action_set_req_line(struct act_rule *rule, struct pr
        goto leave;
 
   fail_rewrite:
-       _HA_ATOMIC_INC(&sess->fe->fe_counters.shared.tg[tgid - 1]->failed_rewrites);
+       _HA_ATOMIC_INC(&sess->fe_tgcounters->failed_rewrites);
        if (s->flags & SF_BE_ASSIGNED)
-               _HA_ATOMIC_INC(&s->be->be_counters.shared.tg[tgid - 1]->failed_rewrites);
+               _HA_ATOMIC_INC(&s->be_tgcounters->failed_rewrites);
        if (sess->listener && sess->listener->counters)
-               _HA_ATOMIC_INC(&sess->listener->counters->shared.tg[tgid - 1]->failed_rewrites);
+               _HA_ATOMIC_INC(&sess->li_tgcounters->failed_rewrites);
        if (objt_server(s->target))
-               _HA_ATOMIC_INC(&__objt_server(s->target)->counters.shared.tg[tgid - 1]->failed_rewrites);
+               _HA_ATOMIC_INC(&s->sv_tgcounters->failed_rewrites);
 
        if (!(s->txn->req.flags & HTTP_MSGF_SOFT_RW)) {
                ret = ACT_RET_ERR;
@@ -386,13 +386,13 @@ static enum act_return http_action_normalize_uri(struct act_rule *rule, struct p
        goto leave;
 
   fail_rewrite:
-       _HA_ATOMIC_ADD(&sess->fe->fe_counters.shared.tg[tgid - 1]->failed_rewrites, 1);
+       _HA_ATOMIC_ADD(&sess->fe_tgcounters->failed_rewrites, 1);
        if (s->flags & SF_BE_ASSIGNED)
-               _HA_ATOMIC_ADD(&s->be->be_counters.shared.tg[tgid - 1]->failed_rewrites, 1);
+               _HA_ATOMIC_ADD(&s->be_tgcounters->failed_rewrites, 1);
        if (sess->listener && sess->listener->counters)
-               _HA_ATOMIC_ADD(&sess->listener->counters->shared.tg[tgid - 1]->failed_rewrites, 1);
+               _HA_ATOMIC_ADD(&sess->li_tgcounters->failed_rewrites, 1);
        if (objt_server(s->target))
-               _HA_ATOMIC_ADD(&__objt_server(s->target)->counters.shared.tg[tgid - 1]->failed_rewrites, 1);
+               _HA_ATOMIC_ADD(&s->sv_tgcounters->failed_rewrites, 1);
 
        if (!(s->txn->req.flags & HTTP_MSGF_SOFT_RW)) {
                ret = ACT_RET_ERR;
@@ -562,13 +562,13 @@ static enum act_return http_action_replace_uri(struct act_rule *rule, struct pro
        goto leave;
 
   fail_rewrite:
-       _HA_ATOMIC_INC(&sess->fe->fe_counters.shared.tg[tgid - 1]->failed_rewrites);
+       _HA_ATOMIC_INC(&sess->fe_tgcounters->failed_rewrites);
        if (s->flags & SF_BE_ASSIGNED)
-               _HA_ATOMIC_INC(&s->be->be_counters.shared.tg[tgid - 1]->failed_rewrites);
+               _HA_ATOMIC_INC(&s->be_tgcounters->failed_rewrites);
        if (sess->listener && sess->listener->counters)
-               _HA_ATOMIC_INC(&sess->listener->counters->shared.tg[tgid - 1]->failed_rewrites);
+               _HA_ATOMIC_INC(&sess->li_tgcounters->failed_rewrites);
        if (objt_server(s->target))
-               _HA_ATOMIC_INC(&__objt_server(s->target)->counters.shared.tg[tgid - 1]->failed_rewrites);
+               _HA_ATOMIC_INC(&s->sv_tgcounters->failed_rewrites);
 
        if (!(s->txn->req.flags & HTTP_MSGF_SOFT_RW)) {
                ret = ACT_RET_ERR;
@@ -642,13 +642,13 @@ static enum act_return action_http_set_status(struct act_rule *rule, struct prox
                                               struct session *sess, struct stream *s, int flags)
 {
        if (http_res_set_status(rule->arg.http.i, rule->arg.http.str, s) == -1) {
-               _HA_ATOMIC_INC(&sess->fe->fe_counters.shared.tg[tgid - 1]->failed_rewrites);
+               _HA_ATOMIC_INC(&sess->fe_tgcounters->failed_rewrites);
                if (s->flags & SF_BE_ASSIGNED)
-                       _HA_ATOMIC_INC(&s->be->be_counters.shared.tg[tgid - 1]->failed_rewrites);
+                       _HA_ATOMIC_INC(&s->be_tgcounters->failed_rewrites);
                if (sess->listener && sess->listener->counters)
-                       _HA_ATOMIC_INC(&sess->listener->counters->shared.tg[tgid - 1]->failed_rewrites);
+                       _HA_ATOMIC_INC(&sess->li_tgcounters->failed_rewrites);
                if (objt_server(s->target))
-                       _HA_ATOMIC_INC(&__objt_server(s->target)->counters.shared.tg[tgid - 1]->failed_rewrites);
+                       _HA_ATOMIC_INC(&s->sv_tgcounters->failed_rewrites);
 
                if (!(s->txn->req.flags & HTTP_MSGF_SOFT_RW)) {
                        if (!(s->flags & SF_ERR_MASK))
@@ -717,10 +717,10 @@ static enum act_return http_action_reject(struct act_rule *rule, struct proxy *p
        s->req.analysers &= AN_REQ_FLT_END;
        s->res.analysers &= AN_RES_FLT_END;
 
-       _HA_ATOMIC_INC(&s->be->be_counters.shared.tg[tgid - 1]->denied_req);
-       _HA_ATOMIC_INC(&sess->fe->fe_counters.shared.tg[tgid - 1]->denied_req);
+       _HA_ATOMIC_INC(&s->be_tgcounters->denied_req);
+       _HA_ATOMIC_INC(&sess->fe_tgcounters->denied_req);
        if (sess->listener && sess->listener->counters)
-               _HA_ATOMIC_INC(&sess->listener->counters->shared.tg[tgid - 1]->denied_req);
+               _HA_ATOMIC_INC(&sess->li_tgcounters->denied_req);
 
        if (!(s->flags & SF_ERR_MASK))
                s->flags |= SF_ERR_PRXCOND;
@@ -1281,7 +1281,7 @@ static enum act_return http_action_auth(struct act_rule *rule, struct proxy *px,
        req->analysers &= AN_REQ_FLT_END;
 
        if (s->sess->fe == s->be) /* report it if the request was intercepted by the frontend */
-               _HA_ATOMIC_INC(&s->sess->fe->fe_counters.shared.tg[tgid - 1]->intercepted_req);
+               _HA_ATOMIC_INC(&s->sess->fe_tgcounters->intercepted_req);
 
        if (!(s->flags & SF_ERR_MASK))
                s->flags |= SF_ERR_LOCAL;
@@ -1449,13 +1449,13 @@ static enum act_return http_action_set_header(struct act_rule *rule, struct prox
        goto leave;
 
   fail_rewrite:
-       _HA_ATOMIC_INC(&sess->fe->fe_counters.shared.tg[tgid - 1]->failed_rewrites);
+       _HA_ATOMIC_INC(&sess->fe_tgcounters->failed_rewrites);
        if (s->flags & SF_BE_ASSIGNED)
-               _HA_ATOMIC_INC(&s->be->be_counters.shared.tg[tgid - 1]->failed_rewrites);
+               _HA_ATOMIC_INC(&s->be_tgcounters->failed_rewrites);
        if (sess->listener && sess->listener->counters)
-               _HA_ATOMIC_INC(&sess->listener->counters->shared.tg[tgid - 1]->failed_rewrites);
+               _HA_ATOMIC_INC(&sess->li_tgcounters->failed_rewrites);
        if (objt_server(s->target))
-               _HA_ATOMIC_INC(&__objt_server(s->target)->counters.shared.tg[tgid - 1]->failed_rewrites);
+               _HA_ATOMIC_INC(&s->sv_tgcounters->failed_rewrites);
 
        if (!(msg->flags & HTTP_MSGF_SOFT_RW)) {
                ret = ACT_RET_ERR;
@@ -1581,13 +1581,13 @@ static enum act_return http_action_replace_header(struct act_rule *rule, struct
        goto leave;
 
   fail_rewrite:
-       _HA_ATOMIC_INC(&sess->fe->fe_counters.shared.tg[tgid - 1]->failed_rewrites);
+       _HA_ATOMIC_INC(&sess->fe_tgcounters->failed_rewrites);
        if (s->flags & SF_BE_ASSIGNED)
-               _HA_ATOMIC_INC(&s->be->be_counters.shared.tg[tgid - 1]->failed_rewrites);
+               _HA_ATOMIC_INC(&s->be_tgcounters->failed_rewrites);
        if (sess->listener && sess->listener->counters)
-               _HA_ATOMIC_INC(&sess->listener->counters->shared.tg[tgid - 1]->failed_rewrites);
+               _HA_ATOMIC_INC(&sess->li_tgcounters->failed_rewrites);
        if (objt_server(s->target))
-               _HA_ATOMIC_INC(&__objt_server(s->target)->counters.shared.tg[tgid - 1]->failed_rewrites);
+               _HA_ATOMIC_INC(&s->sv_tgcounters->failed_rewrites);
 
        if (!(msg->flags & HTTP_MSGF_SOFT_RW)) {
                ret = ACT_RET_ERR;
@@ -2319,7 +2319,7 @@ static enum act_return http_action_return(struct act_rule *rule, struct proxy *p
                req->analysers &= AN_REQ_FLT_END;
 
                if (s->sess->fe == s->be) /* report it if the request was intercepted by the frontend */
-                       _HA_ATOMIC_INC(&s->sess->fe->fe_counters.shared.tg[tgid - 1]->intercepted_req);
+                       _HA_ATOMIC_INC(&s->sess->fe_tgcounters->intercepted_req);
        }
 
        return ACT_RET_ABRT;

diff --git a/src/http_ana.c b/src/http_ana.c
index ad2c7c190d06b325ef642da39dabcdb3add59842..bda8fe2409d0dbfd6449fb9bb75d96b4488272e6 100644 (file)
--- a/src/http_ana.c
+++ b/src/http_ana.c
@@ -233,7 +233,7 @@ int http_wait_for_request(struct stream *s, struct channel *req, int an_bit)
                        struct acl_cond *cond;
 
                        s->flags |= SF_MONITOR;
-                       _HA_ATOMIC_INC(&sess->fe->fe_counters.shared.tg[tgid - 1]->intercepted_req);
+                       _HA_ATOMIC_INC(&sess->fe_tgcounters->intercepted_req);
 
                        /* Check if we want to fail this monitor request or not */
                        list_for_each_entry(cond, &sess->fe->mon_fail_cond, list) {
@@ -342,17 +342,17 @@ int http_wait_for_request(struct stream *s, struct channel *req, int an_bit)
        txn->status = 500;
        if (!(s->flags & SF_ERR_MASK))
                s->flags |= SF_ERR_INTERNAL;
-       _HA_ATOMIC_INC(&sess->fe->fe_counters.shared.tg[tgid - 1]->internal_errors);
+       _HA_ATOMIC_INC(&sess->fe_tgcounters->internal_errors);
        if (sess->listener && sess->listener->counters)
-               _HA_ATOMIC_INC(&sess->listener->counters->shared.tg[tgid - 1]->internal_errors);
+               _HA_ATOMIC_INC(&sess->li_tgcounters->internal_errors);
        stream_report_term_evt(s->scb, strm_tevt_type_internal_err);
        goto return_prx_cond;
 
  return_bad_req:
        txn->status = 400;
-       _HA_ATOMIC_INC(&sess->fe->fe_counters.shared.tg[tgid - 1]->failed_req);
+       _HA_ATOMIC_INC(&sess->fe_tgcounters->failed_req);
        if (sess->listener && sess->listener->counters)
-               _HA_ATOMIC_INC(&sess->listener->counters->shared.tg[tgid - 1]->failed_req);
+               _HA_ATOMIC_INC(&sess->li_tgcounters->failed_req);
        stream_report_term_evt(s->scb, strm_tevt_type_proto_err);
        /* fall through */
 
@@ -486,7 +486,7 @@ int http_process_req_common(struct stream *s, struct channel *req, int an_bit, s
        /* Proceed with the applets now. */
        if (unlikely(objt_applet(s->target))) {
                if (sess->fe == s->be) /* report it if the request was intercepted by the frontend */
-                       _HA_ATOMIC_INC(&sess->fe->fe_counters.shared.tg[tgid - 1]->intercepted_req);
+                       _HA_ATOMIC_INC(&sess->fe_tgcounters->intercepted_req);
 
                if (http_handle_expect_hdr(s, htx, msg) == -1)
                        goto return_int_err;
@@ -562,11 +562,11 @@ int http_process_req_common(struct stream *s, struct channel *req, int an_bit, s
        if (!req->analyse_exp)
                req->analyse_exp = tick_add(now_ms, 0);
        stream_inc_http_err_ctr(s);
-       _HA_ATOMIC_INC(&sess->fe->fe_counters.shared.tg[tgid - 1]->denied_req);
+       _HA_ATOMIC_INC(&sess->fe_tgcounters->denied_req);
        if (s->flags & SF_BE_ASSIGNED)
-               _HA_ATOMIC_INC(&s->be->be_counters.shared.tg[tgid - 1]->denied_req);
+               _HA_ATOMIC_INC(&s->be_tgcounters->denied_req);
        if (sess->listener && sess->listener->counters)
-               _HA_ATOMIC_INC(&sess->listener->counters->shared.tg[tgid - 1]->denied_req);
+               _HA_ATOMIC_INC(&sess->li_tgcounters->denied_req);
        stream_report_term_evt(s->scf, strm_tevt_type_intercepted);
        goto done_without_exp;
 
@@ -579,43 +579,43 @@ int http_process_req_common(struct stream *s, struct channel *req, int an_bit, s
 
        s->logs.request_ts = now_ns;
        stream_inc_http_err_ctr(s);
-       _HA_ATOMIC_INC(&sess->fe->fe_counters.shared.tg[tgid - 1]->denied_req);
+       _HA_ATOMIC_INC(&sess->fe_tgcounters->denied_req);
        if (s->flags & SF_BE_ASSIGNED)
-               _HA_ATOMIC_INC(&s->be->be_counters.shared.tg[tgid - 1]->denied_req);
+               _HA_ATOMIC_INC(&s->be_tgcounters->denied_req);
        if (sess->listener && sess->listener->counters)
-               _HA_ATOMIC_INC(&sess->listener->counters->shared.tg[tgid - 1]->denied_req);
+               _HA_ATOMIC_INC(&sess->li_tgcounters->denied_req);
        stream_report_term_evt(s->scf, strm_tevt_type_intercepted);
        goto return_prx_err;
 
  return_fail_rewrite:
        if (!(s->flags & SF_ERR_MASK))
                s->flags |= SF_ERR_PRXCOND;
-       _HA_ATOMIC_INC(&sess->fe->fe_counters.shared.tg[tgid - 1]->failed_rewrites);
+       _HA_ATOMIC_INC(&sess->fe_tgcounters->failed_rewrites);
        if (s->flags & SF_BE_ASSIGNED)
-               _HA_ATOMIC_INC(&s->be->be_counters.shared.tg[tgid - 1]->failed_rewrites);
+               _HA_ATOMIC_INC(&s->be_tgcounters->failed_rewrites);
        if (sess->listener && sess->listener->counters)
-               _HA_ATOMIC_INC(&sess->listener->counters->shared.tg[tgid - 1]->failed_rewrites);
+               _HA_ATOMIC_INC(&sess->li_tgcounters->failed_rewrites);
        if (objt_server(s->target))
-               _HA_ATOMIC_INC(&__objt_server(s->target)->counters.shared.tg[tgid - 1]->failed_rewrites);
+               _HA_ATOMIC_INC(&s->sv_tgcounters->failed_rewrites);
        /* fall through */
 
  return_int_err:
        txn->status = 500;
        if (!(s->flags & SF_ERR_MASK))
                s->flags |= SF_ERR_INTERNAL;
-       _HA_ATOMIC_INC(&sess->fe->fe_counters.shared.tg[tgid - 1]->internal_errors);
+       _HA_ATOMIC_INC(&sess->fe_tgcounters->internal_errors);
        if (s->flags & SF_BE_ASSIGNED)
-               _HA_ATOMIC_INC(&s->be->be_counters.shared.tg[tgid - 1]->internal_errors);
+               _HA_ATOMIC_INC(&s->be_tgcounters->internal_errors);
        if (sess->listener && sess->listener->counters)
-               _HA_ATOMIC_INC(&sess->listener->counters->shared.tg[tgid - 1]->internal_errors);
+               _HA_ATOMIC_INC(&sess->li_tgcounters->internal_errors);
        stream_report_term_evt(s->scf, strm_tevt_type_internal_err);
        goto return_prx_err;
 
  return_bad_req:
        txn->status = 400;
-       _HA_ATOMIC_INC(&sess->fe->fe_counters.shared.tg[tgid - 1]->failed_req);
+       _HA_ATOMIC_INC(&sess->fe_tgcounters->failed_req);
        if (sess->listener && sess->listener->counters)
-               _HA_ATOMIC_INC(&sess->listener->counters->shared.tg[tgid - 1]->failed_req);
+               _HA_ATOMIC_INC(&sess->li_tgcounters->failed_req);
        stream_report_term_evt(s->scf, strm_tevt_type_proto_err);
        /* fall through */
 
@@ -748,24 +748,24 @@ int http_process_request(struct stream *s, struct channel *req, int an_bit)
  return_fail_rewrite:
        if (!(s->flags & SF_ERR_MASK))
                s->flags |= SF_ERR_PRXCOND;
-       _HA_ATOMIC_INC(&sess->fe->fe_counters.shared.tg[tgid - 1]->failed_rewrites);
+       _HA_ATOMIC_INC(&sess->fe_tgcounters->failed_rewrites);
        if (s->flags & SF_BE_ASSIGNED)
-               _HA_ATOMIC_INC(&s->be->be_counters.shared.tg[tgid - 1]->failed_rewrites);
+               _HA_ATOMIC_INC(&s->be_tgcounters->failed_rewrites);
        if (sess->listener && sess->listener->counters)
-               _HA_ATOMIC_INC(&sess->listener->counters->shared.tg[tgid - 1]->failed_rewrites);
+               _HA_ATOMIC_INC(&sess->li_tgcounters->failed_rewrites);
        if (objt_server(s->target))
-               _HA_ATOMIC_INC(&__objt_server(s->target)->counters.shared.tg[tgid - 1]->failed_rewrites);
+               _HA_ATOMIC_INC(&s->sv_tgcounters->failed_rewrites);
        /* fall through */
 
  return_int_err:
        txn->status = 500;
        if (!(s->flags & SF_ERR_MASK))
                s->flags |= SF_ERR_INTERNAL;
-       _HA_ATOMIC_INC(&sess->fe->fe_counters.shared.tg[tgid - 1]->internal_errors);
+       _HA_ATOMIC_INC(&sess->fe_tgcounters->internal_errors);
        if (s->flags & SF_BE_ASSIGNED)
-               _HA_ATOMIC_INC(&s->be->be_counters.shared.tg[tgid - 1]->internal_errors);
+               _HA_ATOMIC_INC(&s->be_tgcounters->internal_errors);
        if (sess->listener && sess->listener->counters)
-               _HA_ATOMIC_INC(&sess->listener->counters->shared.tg[tgid - 1]->internal_errors);
+               _HA_ATOMIC_INC(&sess->li_tgcounters->internal_errors);
        stream_report_term_evt(s->scf, strm_tevt_type_internal_err);
 
        http_set_term_flags(s);
@@ -871,19 +871,19 @@ int http_wait_for_request_body(struct stream *s, struct channel *req, int an_bit
        txn->status = 500;
        if (!(s->flags & SF_ERR_MASK))
                s->flags |= SF_ERR_INTERNAL;
-       _HA_ATOMIC_INC(&sess->fe->fe_counters.shared.tg[tgid - 1]->internal_errors);
+       _HA_ATOMIC_INC(&sess->fe_tgcounters->internal_errors);
        if (s->flags & SF_BE_ASSIGNED)
-               _HA_ATOMIC_INC(&s->be->be_counters.shared.tg[tgid - 1]->internal_errors);
+               _HA_ATOMIC_INC(&s->be_tgcounters->internal_errors);
        if (sess->listener && sess->listener->counters)
-               _HA_ATOMIC_INC(&sess->listener->counters->shared.tg[tgid - 1]->internal_errors);
+               _HA_ATOMIC_INC(&sess->li_tgcounters->internal_errors);
        stream_report_term_evt(s->scf, strm_tevt_type_internal_err);
        goto return_prx_err;
 
  return_bad_req: /* let's centralize all bad requests */
        txn->status = 400;
-       _HA_ATOMIC_INC(&sess->fe->fe_counters.shared.tg[tgid - 1]->failed_req);
+       _HA_ATOMIC_INC(&sess->fe_tgcounters->failed_req);
        if (sess->listener && sess->listener->counters)
-               _HA_ATOMIC_INC(&sess->listener->counters->shared.tg[tgid - 1]->failed_req);
+               _HA_ATOMIC_INC(&sess->li_tgcounters->failed_req);
        stream_report_term_evt(s->scf, strm_tevt_type_proto_err);
        /* fall through */
 
@@ -1100,24 +1100,24 @@ int http_request_forward_body(struct stream *s, struct channel *req, int an_bit)
        return 0;
 
   return_cli_abort:
-       _HA_ATOMIC_INC(&sess->fe->fe_counters.shared.tg[tgid - 1]->cli_aborts);
-       _HA_ATOMIC_INC(&s->be->be_counters.shared.tg[tgid - 1]->cli_aborts);
+       _HA_ATOMIC_INC(&sess->fe_tgcounters->cli_aborts);
+       _HA_ATOMIC_INC(&s->be_tgcounters->cli_aborts);
        if (sess->listener && sess->listener->counters)
-               _HA_ATOMIC_INC(&sess->listener->counters->shared.tg[tgid - 1]->cli_aborts);
+               _HA_ATOMIC_INC(&sess->li_tgcounters->cli_aborts);
        if (objt_server(s->target))
-               _HA_ATOMIC_INC(&__objt_server(s->target)->counters.shared.tg[tgid - 1]->cli_aborts);
+               _HA_ATOMIC_INC(&s->sv_tgcounters->cli_aborts);
        if (!(s->flags & SF_ERR_MASK))
                s->flags |= ((req->flags & CF_READ_TIMEOUT) ? SF_ERR_CLITO : SF_ERR_CLICL);
        status = 400;
        goto return_prx_cond;
 
   return_srv_abort:
-       _HA_ATOMIC_INC(&sess->fe->fe_counters.shared.tg[tgid - 1]->srv_aborts);
-       _HA_ATOMIC_INC(&s->be->be_counters.shared.tg[tgid - 1]->srv_aborts);
+       _HA_ATOMIC_INC(&sess->fe_tgcounters->srv_aborts);
+       _HA_ATOMIC_INC(&s->be_tgcounters->srv_aborts);
        if (sess->listener && sess->listener->counters)
-               _HA_ATOMIC_INC(&sess->listener->counters->shared.tg[tgid - 1]->srv_aborts);
+               _HA_ATOMIC_INC(&sess->li_tgcounters->srv_aborts);
        if (objt_server(s->target))
-               _HA_ATOMIC_INC(&__objt_server(s->target)->counters.shared.tg[tgid - 1]->srv_aborts);
+               _HA_ATOMIC_INC(&s->sv_tgcounters->srv_aborts);
        if (!(s->flags & SF_ERR_MASK))
                s->flags |= ((req->flags & CF_WRITE_TIMEOUT) ? SF_ERR_SRVTO : SF_ERR_SRVCL);
        status = 502;
@@ -1126,20 +1126,20 @@ int http_request_forward_body(struct stream *s, struct channel *req, int an_bit)
   return_int_err:
        if (!(s->flags & SF_ERR_MASK))
                s->flags |= SF_ERR_INTERNAL;
-       _HA_ATOMIC_INC(&sess->fe->fe_counters.shared.tg[tgid - 1]->internal_errors);
-       _HA_ATOMIC_INC(&s->be->be_counters.shared.tg[tgid - 1]->internal_errors);
+       _HA_ATOMIC_INC(&sess->fe_tgcounters->internal_errors);
+       _HA_ATOMIC_INC(&s->be_tgcounters->internal_errors);
        if (sess->listener && sess->listener->counters)
-               _HA_ATOMIC_INC(&sess->listener->counters->shared.tg[tgid - 1]->internal_errors);
+               _HA_ATOMIC_INC(&sess->li_tgcounters->internal_errors);
        if (objt_server(s->target))
-               _HA_ATOMIC_INC(&__objt_server(s->target)->counters.shared.tg[tgid - 1]->internal_errors);
+               _HA_ATOMIC_INC(&s->sv_tgcounters->internal_errors);
        stream_report_term_evt(s->scf, strm_tevt_type_internal_err);
        status = 500;
        goto return_prx_cond;
 
   return_bad_req:
-       _HA_ATOMIC_INC(&sess->fe->fe_counters.shared.tg[tgid - 1]->failed_req);
+       _HA_ATOMIC_INC(&sess->fe_tgcounters->failed_req);
        if (sess->listener && sess->listener->counters)
-               _HA_ATOMIC_INC(&sess->listener->counters->shared.tg[tgid - 1]->failed_req);
+               _HA_ATOMIC_INC(&sess->li_tgcounters->failed_req);
        stream_report_term_evt(s->scf, strm_tevt_type_proto_err);
        status = 400;
        /* fall through */
@@ -1173,9 +1173,9 @@ static __inline int do_l7_retry(struct stream *s, struct stconn *sc)
                        s->flags &= ~SF_CURR_SESS;
                        _HA_ATOMIC_DEC(&__objt_server(s->target)->cur_sess);
                }
-               _HA_ATOMIC_INC(&__objt_server(s->target)->counters.shared.tg[tgid - 1]->retries);
+               _HA_ATOMIC_INC(&s->sv_tgcounters->retries);
        }
-       _HA_ATOMIC_INC(&s->be->be_counters.shared.tg[tgid - 1]->retries);
+       _HA_ATOMIC_INC(&s->be_tgcounters->retries);
 
        req = &s->req;
        res = &s->res;
@@ -1292,9 +1292,9 @@ int http_wait_for_response(struct stream *s, struct channel *rep, int an_bit)
                        if (s->flags & SF_SRV_REUSED)
                                goto abort_keep_alive;
 
-                       _HA_ATOMIC_INC(&s->be->be_counters.shared.tg[tgid - 1]->failed_resp);
+                       _HA_ATOMIC_INC(&s->be_tgcounters->failed_resp);
                        if (objt_server(s->target))
-                               _HA_ATOMIC_INC(&__objt_server(s->target)->counters.shared.tg[tgid - 1]->failed_resp);
+                               _HA_ATOMIC_INC(&s->sv_tgcounters->failed_resp);
 
                        /* if the server refused the early data, just send a 425 */
                        if (conn && conn->err_code == CO_ER_SSL_EARLY_FAILED)
@@ -1329,9 +1329,9 @@ int http_wait_for_response(struct stream *s, struct channel *rep, int an_bit)
                                        return 0;
                                }
                        }
-                       _HA_ATOMIC_INC(&s->be->be_counters.shared.tg[tgid - 1]->failed_resp);
+                       _HA_ATOMIC_INC(&s->be_tgcounters->failed_resp);
                        if (objt_server(s->target))
-                               _HA_ATOMIC_INC(&__objt_server(s->target)->counters.shared.tg[tgid - 1]->failed_resp);
+                               _HA_ATOMIC_INC(&s->sv_tgcounters->failed_resp);
 
                        txn->status = 504;
                        stream_inc_http_fail_ctr(s);
@@ -1350,12 +1350,12 @@ int http_wait_for_response(struct stream *s, struct channel *rep, int an_bit)
                /* 3: client abort with an abortonclose */
                else if ((s->scb->flags & (SC_FL_EOS|SC_FL_ABRT_DONE)) && (s->scb->flags & SC_FL_SHUT_DONE) &&
                         (s->scf->flags & (SC_FL_EOS|SC_FL_ABRT_DONE))) {
-                       _HA_ATOMIC_INC(&sess->fe->fe_counters.shared.tg[tgid - 1]->cli_aborts);
-                       _HA_ATOMIC_INC(&s->be->be_counters.shared.tg[tgid - 1]->cli_aborts);
+                       _HA_ATOMIC_INC(&sess->fe_tgcounters->cli_aborts);
+                       _HA_ATOMIC_INC(&s->be_tgcounters->cli_aborts);
                        if (sess->listener && sess->listener->counters)
-                               _HA_ATOMIC_INC(&sess->listener->counters->shared.tg[tgid - 1]->cli_aborts);
+                               _HA_ATOMIC_INC(&sess->li_tgcounters->cli_aborts);
                        if (objt_server(s->target))
-                               _HA_ATOMIC_INC(&__objt_server(s->target)->counters.shared.tg[tgid - 1]->cli_aborts);
+                               _HA_ATOMIC_INC(&s->sv_tgcounters->cli_aborts);
 
                        txn->status = 400;
 
@@ -1388,9 +1388,9 @@ int http_wait_for_response(struct stream *s, struct channel *rep, int an_bit)
                        if (s->flags & SF_SRV_REUSED)
                                goto abort_keep_alive;
 
-                       _HA_ATOMIC_INC(&s->be->be_counters.shared.tg[tgid - 1]->failed_resp);
+                       _HA_ATOMIC_INC(&s->be_tgcounters->failed_resp);
                        if (objt_server(s->target))
-                               _HA_ATOMIC_INC(&__objt_server(s->target)->counters.shared.tg[tgid - 1]->failed_resp);
+                               _HA_ATOMIC_INC(&s->sv_tgcounters->failed_resp);
 
                        txn->status = 502;
                        stream_inc_http_fail_ctr(s);
@@ -1411,9 +1411,9 @@ int http_wait_for_response(struct stream *s, struct channel *rep, int an_bit)
                        if (s->flags & SF_SRV_REUSED)
                                goto abort_keep_alive;
 
-                       _HA_ATOMIC_INC(&s->be->be_counters.shared.tg[tgid - 1]->failed_resp);
+                       _HA_ATOMIC_INC(&s->be_tgcounters->failed_resp);
                        if (objt_server(s->target))
-                               _HA_ATOMIC_INC(&__objt_server(s->target)->counters.shared.tg[tgid - 1]->failed_resp);
+                               _HA_ATOMIC_INC(&s->sv_tgcounters->failed_resp);
                        rep->analysers &= AN_RES_FLT_END;
 
                        if (!(s->flags & SF_ERR_MASK))
@@ -1517,8 +1517,8 @@ int http_wait_for_response(struct stream *s, struct channel *rep, int an_bit)
                if (n < 1 || n > 5)
                        n = 0;
 
-               _HA_ATOMIC_INC(&__objt_server(s->target)->counters.shared.tg[tgid - 1]->p.http.rsp[n]);
-               _HA_ATOMIC_INC(&__objt_server(s->target)->counters.shared.tg[tgid - 1]->p.http.cum_req);
+               _HA_ATOMIC_INC(&s->sv_tgcounters->p.http.rsp[n]);
+               _HA_ATOMIC_INC(&s->sv_tgcounters->p.http.cum_req);
        }
 
        /*
@@ -1662,12 +1662,12 @@ int http_wait_for_response(struct stream *s, struct channel *rep, int an_bit)
        return 1;
 
  return_int_err:
-       _HA_ATOMIC_INC(&sess->fe->fe_counters.shared.tg[tgid - 1]->internal_errors);
-       _HA_ATOMIC_INC(&s->be->be_counters.shared.tg[tgid - 1]->internal_errors);
+       _HA_ATOMIC_INC(&sess->fe_tgcounters->internal_errors);
+       _HA_ATOMIC_INC(&s->be_tgcounters->internal_errors);
        if (sess->listener && sess->listener->counters)
-               _HA_ATOMIC_INC(&sess->listener->counters->shared.tg[tgid - 1]->internal_errors);
+               _HA_ATOMIC_INC(&sess->li_tgcounters->internal_errors);
        if (objt_server(s->target))
-               _HA_ATOMIC_INC(&__objt_server(s->target)->counters.shared.tg[tgid - 1]->internal_errors);
+               _HA_ATOMIC_INC(&s->sv_tgcounters->internal_errors);
        txn->status = 500;
        if (!(s->flags & SF_ERR_MASK))
                s->flags |= SF_ERR_INTERNAL;
@@ -1683,9 +1683,9 @@ int http_wait_for_response(struct stream *s, struct channel *rep, int an_bit)
                return 0;
        }
 
-       _HA_ATOMIC_INC(&s->be->be_counters.shared.tg[tgid - 1]->failed_resp);
+       _HA_ATOMIC_INC(&s->be_tgcounters->failed_resp);
        if (objt_server(s->target))
-               _HA_ATOMIC_INC(&__objt_server(s->target)->counters.shared.tg[tgid - 1]->failed_resp);
+               _HA_ATOMIC_INC(&s->sv_tgcounters->failed_resp);
 
        txn->status = 502;
        stream_inc_http_fail_ctr(s);
@@ -1982,36 +1982,36 @@ int http_process_res_common(struct stream *s, struct channel *rep, int an_bit, s
        return 1;
 
  deny:
-       _HA_ATOMIC_INC(&sess->fe->fe_counters.shared.tg[tgid - 1]->denied_resp);
-       _HA_ATOMIC_INC(&s->be->be_counters.shared.tg[tgid - 1]->denied_resp);
+       _HA_ATOMIC_INC(&sess->fe_tgcounters->denied_resp);
+       _HA_ATOMIC_INC(&s->be_tgcounters->denied_resp);
        if (sess->listener && sess->listener->counters)
-               _HA_ATOMIC_INC(&sess->listener->counters->shared.tg[tgid - 1]->denied_resp);
+               _HA_ATOMIC_INC(&sess->li_tgcounters->denied_resp);
        if (objt_server(s->target))
-               _HA_ATOMIC_INC(&__objt_server(s->target)->counters.shared.tg[tgid - 1]->denied_resp);
+               _HA_ATOMIC_INC(&s->sv_tgcounters->denied_resp);
        stream_report_term_evt(s->scb, strm_tevt_type_intercepted);
        goto return_prx_err;
 
  return_fail_rewrite:
        if (!(s->flags & SF_ERR_MASK))
                s->flags |= SF_ERR_PRXCOND;
-       _HA_ATOMIC_INC(&sess->fe->fe_counters.shared.tg[tgid - 1]->failed_rewrites);
-       _HA_ATOMIC_INC(&s->be->be_counters.shared.tg[tgid - 1]->failed_rewrites);
+       _HA_ATOMIC_INC(&sess->fe_tgcounters->failed_rewrites);
+       _HA_ATOMIC_INC(&s->be_tgcounters->failed_rewrites);
        if (sess->listener && sess->listener->counters)
-               _HA_ATOMIC_INC(&sess->listener->counters->shared.tg[tgid - 1]->failed_rewrites);
+               _HA_ATOMIC_INC(&sess->li_tgcounters->failed_rewrites);
        if (objt_server(s->target))
-               _HA_ATOMIC_INC(&__objt_server(s->target)->counters.shared.tg[tgid - 1]->failed_rewrites);
+               _HA_ATOMIC_INC(&s->sv_tgcounters->failed_rewrites);
        /* fall through */
 
  return_int_err:
        txn->status = 500;
        if (!(s->flags & SF_ERR_MASK))
                s->flags |= SF_ERR_INTERNAL;
-       _HA_ATOMIC_INC(&sess->fe->fe_counters.shared.tg[tgid - 1]->internal_errors);
-       _HA_ATOMIC_INC(&s->be->be_counters.shared.tg[tgid - 1]->internal_errors);
+       _HA_ATOMIC_INC(&sess->fe_tgcounters->internal_errors);
+       _HA_ATOMIC_INC(&s->be_tgcounters->internal_errors);
        if (sess->listener && sess->listener->counters)
-               _HA_ATOMIC_INC(&sess->listener->counters->shared.tg[tgid - 1]->internal_errors);
+               _HA_ATOMIC_INC(&sess->li_tgcounters->internal_errors);
        if (objt_server(s->target))
-               _HA_ATOMIC_INC(&__objt_server(s->target)->counters.shared.tg[tgid - 1]->internal_errors);
+               _HA_ATOMIC_INC(&s->sv_tgcounters->internal_errors);
        stream_report_term_evt(s->scb, strm_tevt_type_internal_err);
        goto return_prx_err;
 
@@ -2019,9 +2019,9 @@ int http_process_res_common(struct stream *s, struct channel *rep, int an_bit, s
        s->logs.t_data = -1; /* was not a valid response */
        txn->status = 502;
        stream_inc_http_fail_ctr(s);
-       _HA_ATOMIC_INC(&s->be->be_counters.shared.tg[tgid - 1]->failed_resp);
+       _HA_ATOMIC_INC(&s->be_tgcounters->failed_resp);
        if (objt_server(s->target)) {
-               _HA_ATOMIC_INC(&__objt_server(s->target)->counters.shared.tg[tgid - 1]->failed_resp);
+               _HA_ATOMIC_INC(&s->sv_tgcounters->failed_resp);
                health_adjust(__objt_server(s->target), HANA_STATUS_HTTP_RSP);
        }
        stream_report_term_evt(s->scb, strm_tevt_type_proto_err);
@@ -2251,44 +2251,44 @@ int http_response_forward_body(struct stream *s, struct channel *res, int an_bit
        return 0;
 
   return_srv_abort:
-       _HA_ATOMIC_INC(&sess->fe->fe_counters.shared.tg[tgid - 1]->srv_aborts);
-       _HA_ATOMIC_INC(&s->be->be_counters.shared.tg[tgid - 1]->srv_aborts);
+       _HA_ATOMIC_INC(&sess->fe_tgcounters->srv_aborts);
+       _HA_ATOMIC_INC(&s->be_tgcounters->srv_aborts);
        if (sess->listener && sess->listener->counters)
-               _HA_ATOMIC_INC(&sess->listener->counters->shared.tg[tgid - 1]->srv_aborts);
+               _HA_ATOMIC_INC(&sess->li_tgcounters->srv_aborts);
        if (objt_server(s->target))
-               _HA_ATOMIC_INC(&__objt_server(s->target)->counters.shared.tg[tgid - 1]->srv_aborts);
+               _HA_ATOMIC_INC(&s->sv_tgcounters->srv_aborts);
        stream_inc_http_fail_ctr(s);
        if (!(s->flags & SF_ERR_MASK))
                s->flags |= ((res->flags & CF_READ_TIMEOUT) ? SF_ERR_SRVTO : SF_ERR_SRVCL);
        goto return_error;
 
   return_cli_abort:
-       _HA_ATOMIC_INC(&sess->fe->fe_counters.shared.tg[tgid - 1]->cli_aborts);
-       _HA_ATOMIC_INC(&s->be->be_counters.shared.tg[tgid - 1]->cli_aborts);
+       _HA_ATOMIC_INC(&sess->fe_tgcounters->cli_aborts);
+       _HA_ATOMIC_INC(&s->be_tgcounters->cli_aborts);
        if (sess->listener && sess->listener->counters)
-               _HA_ATOMIC_INC(&sess->listener->counters->shared.tg[tgid - 1]->cli_aborts);
+               _HA_ATOMIC_INC(&sess->li_tgcounters->cli_aborts);
        if (objt_server(s->target))
-               _HA_ATOMIC_INC(&__objt_server(s->target)->counters.shared.tg[tgid - 1]->cli_aborts);
+               _HA_ATOMIC_INC(&s->sv_tgcounters->cli_aborts);
        if (!(s->flags & SF_ERR_MASK))
                s->flags |= ((res->flags & CF_WRITE_TIMEOUT) ? SF_ERR_CLITO : SF_ERR_CLICL);
        goto return_error;
 
   return_int_err:
-       _HA_ATOMIC_INC(&sess->fe->fe_counters.shared.tg[tgid - 1]->internal_errors);
-       _HA_ATOMIC_INC(&s->be->be_counters.shared.tg[tgid - 1]->internal_errors);
+       _HA_ATOMIC_INC(&sess->fe_tgcounters->internal_errors);
+       _HA_ATOMIC_INC(&s->be_tgcounters->internal_errors);
        if (sess->listener && sess->listener->counters)
-               _HA_ATOMIC_INC(&sess->listener->counters->shared.tg[tgid - 1]->internal_errors);
+               _HA_ATOMIC_INC(&sess->li_tgcounters->internal_errors);
        if (objt_server(s->target))
-               _HA_ATOMIC_INC(&__objt_server(s->target)->counters.shared.tg[tgid - 1]->internal_errors);
+               _HA_ATOMIC_INC(&s->sv_tgcounters->internal_errors);
        if (!(s->flags & SF_ERR_MASK))
                s->flags |= SF_ERR_INTERNAL;
        stream_report_term_evt(s->scb, strm_tevt_type_internal_err);
        goto return_error;
 
   return_bad_res:
-       _HA_ATOMIC_INC(&s->be->be_counters.shared.tg[tgid - 1]->failed_resp);
+       _HA_ATOMIC_INC(&s->be_tgcounters->failed_resp);
        if (objt_server(s->target)) {
-               _HA_ATOMIC_INC(&__objt_server(s->target)->counters.shared.tg[tgid - 1]->failed_resp);
+               _HA_ATOMIC_INC(&s->sv_tgcounters->failed_resp);
                health_adjust(__objt_server(s->target), HANA_STATUS_HTTP_RSP);
        }
        stream_inc_http_fail_ctr(s);
@@ -2571,7 +2571,7 @@ int http_apply_redirect_rule(struct redirect_rule *rule, struct stream *s, struc
                req->analysers &= AN_REQ_FLT_END;
 
                if (s->sess->fe == s->be) /* report it if the request was intercepted by the frontend */
-                       _HA_ATOMIC_INC(&s->sess->fe->fe_counters.shared.tg[tgid - 1]->intercepted_req);
+                       _HA_ATOMIC_INC(&s->sess->fe_tgcounters->intercepted_req);
        }
 
   out:
@@ -3446,7 +3446,7 @@ static void http_manage_client_side_cookies(struct stream *s, struct channel *re
                                                        txn->flags &= ~TX_CK_MASK;
                                                        txn->flags |= (srv->cur_state != SRV_ST_STOPPED) ? TX_CK_VALID : TX_CK_DOWN;
                                                        s->flags |= SF_DIRECT | SF_ASSIGNED;
-                                                       s->target = &srv->obj_type;
+                                                       stream_set_srv_target(s, srv);
                                                        break;
                                                } else {
                                                        /* we found a server, but it's down,
@@ -4282,9 +4282,9 @@ enum rule_result http_wait_for_msg_body(struct stream *s, struct channel *chn,
        txn->status = 408;
        if (!(s->flags & SF_ERR_MASK))
                s->flags |= SF_ERR_CLITO;
-       _HA_ATOMIC_INC(&sess->fe->fe_counters.shared.tg[tgid - 1]->failed_req);
+       _HA_ATOMIC_INC(&sess->fe_tgcounters->failed_req);
        if (sess->listener && sess->listener->counters)
-               _HA_ATOMIC_INC(&sess->listener->counters->shared.tg[tgid - 1]->failed_req);
+               _HA_ATOMIC_INC(&sess->li_tgcounters->failed_req);
        goto abort;
 
   abort_res:

diff --git a/src/http_client.c b/src/http_client.c
index 33490bae9eb940d85446b4c2ee057d811241805e..875be1199301a83b1d610102f3a569d4b4b0c26b 100644 (file)
--- a/src/http_client.c
+++ b/src/http_client.c
@@ -951,6 +951,9 @@ int httpclient_applet_init(struct appctx *appctx)
 
        s = appctx_strm(appctx);
        s->target = target;
+       if (objt_server(s->target))
+               s->sv_tgcounters = __objt_server(s->target)->counters.shared.tg[tgid - 1];
+
        /* set the "timeout server" */
        s->scb->ioto = hc->timeout_server;
 

diff --git a/src/log.c b/src/log.c
index a2eeff67a30163201c99da3475b1ad63682ec403..0d1e9a35b04601f04cc4d13815564dbaa5fad20a 100644 (file)
--- a/src/log.c
+++ b/src/log.c
@@ -5947,15 +5947,15 @@ missing_budget:
 
 parse_error:
        if (l->counters)
-               _HA_ATOMIC_INC(&l->counters->shared.tg[tgid - 1]->failed_req);
-       _HA_ATOMIC_INC(&frontend->fe_counters.shared.tg[tgid - 1]->failed_req);
+               _HA_ATOMIC_INC(&s->sess->li_tgcounters->failed_req);
+       _HA_ATOMIC_INC(&s->sess->fe_tgcounters->failed_req);
 
        goto error;
 
 cli_abort:
        if (l->counters)
-               _HA_ATOMIC_INC(&l->counters->shared.tg[tgid - 1]->cli_aborts);
-       _HA_ATOMIC_INC(&frontend->fe_counters.shared.tg[tgid - 1]->cli_aborts);
+               _HA_ATOMIC_INC(&s->sess->li_tgcounters->cli_aborts);
+       _HA_ATOMIC_INC(&s->sess->fe_tgcounters->cli_aborts);
 
 error:
        applet_set_eos(appctx);

diff --git a/src/mux_h1.c b/src/mux_h1.c
index a3bb11207241fbcb1cab4cd51b7e3dfa3bdb2109..6f1e95273c2a9ad7ccc634ab30684a3d47b26610 100644 (file)
--- a/src/mux_h1.c
+++ b/src/mux_h1.c
@@ -3735,10 +3735,10 @@ static int h1_handle_internal_err(struct h1c *h1c)
        }
        session_inc_http_req_ctr(sess);
        proxy_inc_fe_req_ctr(sess->listener, sess->fe, 1);
-       _HA_ATOMIC_INC(&sess->fe->fe_counters.shared.tg[tgid - 1]->p.http.rsp[5]);
-       _HA_ATOMIC_INC(&sess->fe->fe_counters.shared.tg[tgid - 1]->internal_errors);
+       _HA_ATOMIC_INC(&sess->fe_tgcounters->p.http.rsp[5]);
+       _HA_ATOMIC_INC(&sess->fe_tgcounters->internal_errors);
        if (sess->listener && sess->listener->counters)
-               _HA_ATOMIC_INC(&sess->listener->counters->shared.tg[tgid - 1]->internal_errors);
+               _HA_ATOMIC_INC(&sess->li_tgcounters->internal_errors);
 
        h1c->errcode = 500;
        ret = h1_send_error(h1c);
@@ -3771,10 +3771,10 @@ static int h1_handle_parsing_error(struct h1c *h1c)
        session_inc_http_req_ctr(sess);
        session_inc_http_err_ctr(sess);
        proxy_inc_fe_req_ctr(sess->listener, sess->fe, 1);
-       _HA_ATOMIC_INC(&sess->fe->fe_counters.shared.tg[tgid - 1]->p.http.rsp[4]);
-       _HA_ATOMIC_INC(&sess->fe->fe_counters.shared.tg[tgid - 1]->failed_req);
+       _HA_ATOMIC_INC(&sess->fe_tgcounters->p.http.rsp[4]);
+       _HA_ATOMIC_INC(&sess->fe_tgcounters->failed_req);
        if (sess->listener && sess->listener->counters)
-               _HA_ATOMIC_INC(&sess->listener->counters->shared.tg[tgid - 1]->failed_req);
+               _HA_ATOMIC_INC(&sess->li_tgcounters->failed_req);
 
        if (!h1c->errcode)
                h1c->errcode = 400;
@@ -3808,10 +3808,10 @@ static int h1_handle_not_impl_err(struct h1c *h1c)
 
        session_inc_http_req_ctr(sess);
        proxy_inc_fe_req_ctr(sess->listener, sess->fe, 1);
-       _HA_ATOMIC_INC(&sess->fe->fe_counters.shared.tg[tgid - 1]->p.http.rsp[4]);
-       _HA_ATOMIC_INC(&sess->fe->fe_counters.shared.tg[tgid - 1]->failed_req);
+       _HA_ATOMIC_INC(&sess->fe_tgcounters->p.http.rsp[4]);
+       _HA_ATOMIC_INC(&sess->fe_tgcounters->failed_req);
        if (sess->listener && sess->listener->counters)
-               _HA_ATOMIC_INC(&sess->listener->counters->shared.tg[tgid - 1]->failed_req);
+               _HA_ATOMIC_INC(&sess->li_tgcounters->failed_req);
 
        h1c->errcode = 501;
        ret = h1_send_error(h1c);
@@ -3843,10 +3843,10 @@ static int h1_handle_req_tout(struct h1c *h1c)
 
        session_inc_http_req_ctr(sess);
        proxy_inc_fe_req_ctr(sess->listener, sess->fe, 1);
-       _HA_ATOMIC_INC(&sess->fe->fe_counters.shared.tg[tgid - 1]->p.http.rsp[4]);
-       _HA_ATOMIC_INC(&sess->fe->fe_counters.shared.tg[tgid - 1]->failed_req);
+       _HA_ATOMIC_INC(&sess->fe_tgcounters->p.http.rsp[4]);
+       _HA_ATOMIC_INC(&sess->fe_tgcounters->failed_req);
        if (sess->listener && sess->listener->counters)
-               _HA_ATOMIC_INC(&sess->listener->counters->shared.tg[tgid - 1]->failed_req);
+               _HA_ATOMIC_INC(&sess->li_tgcounters->failed_req);
 
        h1c->errcode = 408;
        ret = h1_send_error(h1c);

diff --git a/src/peers.c b/src/peers.c
index efb2ac0a68499dffbbc0f9ea321ce805f331cb9e..dd6988c623ce41b4b03863a10d50c41e574c4fb3 100644 (file)
--- a/src/peers.c
+++ b/src/peers.c
@@ -1080,7 +1080,7 @@ static int peer_session_init(struct appctx *appctx)
        s->scb->dst = addr;
        s->scb->flags |= (SC_FL_RCV_ONCE|SC_FL_NOLINGER);
        s->flags = SF_ASSIGNED;
-       s->target = &peer->srv->obj_type;
+       stream_set_srv_target(s, peer->srv);
 
        s->do_log = NULL;
        s->uniq_id = 0;

diff --git a/src/proxy.c b/src/proxy.c
index 754c9fccfdb0030ff5a86c74fe6c75053fe07ecc..b2d1f07b1da3a0afceb13d6943b0c0d91ce88d34 100644 (file)
--- a/src/proxy.c
+++ b/src/proxy.c
@@ -2590,6 +2590,7 @@ int stream_set_backend(struct stream *s, struct proxy *be)
                return 0;
 
        s->be = be;
+       s->be_tgcounters = be->be_counters.shared.tg[tgid - 1];
        HA_ATOMIC_UPDATE_MAX(&be->be_counters.conn_max,
                             HA_ATOMIC_ADD_FETCH(&be->beconn, 1));
        proxy_inc_be_ctr(be);

diff --git a/src/session.c b/src/session.c
index b862628de6fd710367905779d6e24b669ed78332..21aff4ed81dac96d56f1346b0077cd6dfd3a74ff 100644 (file)
--- a/src/session.c
+++ b/src/session.c
@@ -99,6 +99,9 @@ struct session *session_new(struct proxy *fe, struct listener *li, enum obj_type
                sess->flags = SESS_FL_NONE;
                sess->src = NULL;
                sess->dst = NULL;
+               sess->fe_tgcounters = sess->fe->fe_counters.shared.tg[tgid - 1];
+               if (sess->listener && sess->listener->counters)
+                       sess->li_tgcounters = sess->listener->counters->shared.tg[tgid - 1];
                TRACE_STATE("new session", SESS_EV_NEW, sess);
        }
        TRACE_LEAVE(SESS_EV_NEW);

diff --git a/src/sink.c b/src/sink.c
index 22e5a3636c4ff4e44d35dc865d36e42f93e767d4..69bb63b76ec42424f06df525e9b662d929a21095 100644 (file)
--- a/src/sink.c
+++ b/src/sink.c
@@ -565,7 +565,7 @@ static int sink_forward_session_init(struct appctx *appctx)
        s->scb->dst = addr;
        s->scb->flags |= (SC_FL_RCV_ONCE);
 
-       s->target = &sft->srv->obj_type;
+       stream_set_srv_target(s, sft->srv);
        s->flags = SF_ASSIGNED;
 
        s->do_log = NULL;

diff --git a/src/stream.c b/src/stream.c
index 7f3e5874265168ec5d7475c48f746e8a35a76796..06d1cd86e52055739f26a0a3ce6017245c0301c1 100644 (file)
--- a/src/stream.c
+++ b/src/stream.c
@@ -450,6 +450,8 @@ struct stream *stream_new(struct session *sess, struct stconn *sc, struct buffer
         * when the default backend is assigned.
         */
        s->be  = sess->fe;
+       s->be_tgcounters = sess->fe->be_counters.shared.tg[tgid - 1];
+
        s->req_cap = NULL;
        s->res_cap = NULL;
 
@@ -823,14 +825,14 @@ void stream_process_counters(struct stream *s)
        bytes = s->req.total - s->logs.bytes_in;
        s->logs.bytes_in = s->req.total;
        if (bytes) {
-               _HA_ATOMIC_ADD(&sess->fe->fe_counters.shared.tg[tgid - 1]->bytes_in, bytes);
-               _HA_ATOMIC_ADD(&s->be->be_counters.shared.tg[tgid - 1]->bytes_in,    bytes);
+               _HA_ATOMIC_ADD(&sess->fe_tgcounters->bytes_in, bytes);
+               _HA_ATOMIC_ADD(&s->be_tgcounters->bytes_in,    bytes);
 
                if (objt_server(s->target))
-                       _HA_ATOMIC_ADD(&__objt_server(s->target)->counters.shared.tg[tgid - 1]->bytes_in, bytes);
+                       _HA_ATOMIC_ADD(&s->sv_tgcounters->bytes_in, bytes);
 
                if (sess->listener && sess->listener->counters)
-                       _HA_ATOMIC_ADD(&sess->listener->counters->shared.tg[tgid - 1]->bytes_in, bytes);
+                       _HA_ATOMIC_ADD(&sess->li_tgcounters->bytes_in, bytes);
 
                for (i = 0; i < global.tune.nb_stk_ctr; i++) {
                        if (!stkctr_inc_bytes_in_ctr(&s->stkctr[i], bytes))
@@ -841,14 +843,14 @@ void stream_process_counters(struct stream *s)
        bytes = s->res.total - s->logs.bytes_out;
        s->logs.bytes_out = s->res.total;
        if (bytes) {
-               _HA_ATOMIC_ADD(&sess->fe->fe_counters.shared.tg[tgid - 1]->bytes_out, bytes);
-               _HA_ATOMIC_ADD(&s->be->be_counters.shared.tg[tgid - 1]->bytes_out,    bytes);
+               _HA_ATOMIC_ADD(&sess->fe_tgcounters->bytes_out, bytes);
+               _HA_ATOMIC_ADD(&s->be_tgcounters->bytes_out,    bytes);
 
                if (objt_server(s->target))
-                       _HA_ATOMIC_ADD(&__objt_server(s->target)->counters.shared.tg[tgid - 1]->bytes_out, bytes);
+                       _HA_ATOMIC_ADD(&s->sv_tgcounters->bytes_out, bytes);
 
                if (sess->listener && sess->listener->counters)
-                       _HA_ATOMIC_ADD(&sess->listener->counters->shared.tg[tgid - 1]->bytes_out, bytes);
+                       _HA_ATOMIC_ADD(&sess->li_tgcounters->bytes_out, bytes);
 
                for (i = 0; i < global.tune.nb_stk_ctr; i++) {
                        if (!stkctr_inc_bytes_out_ctr(&s->stkctr[i], bytes))
@@ -1012,9 +1014,9 @@ void sess_set_term_flags(struct stream *s)
        if (!(s->flags & SF_FINST_MASK)) {
                if (s->scb->state == SC_ST_INI) {
                        /* anything before REQ in fact */
-                       _HA_ATOMIC_INC(&strm_fe(s)->fe_counters.shared.tg[tgid - 1]->failed_req);
+                       _HA_ATOMIC_INC(&s->sess->fe_tgcounters->failed_req);
                        if (strm_li(s) && strm_li(s)->counters)
-                               _HA_ATOMIC_INC(&strm_li(s)->counters->shared.tg[tgid - 1]->failed_req);
+                               _HA_ATOMIC_INC(&s->sess->li_tgcounters->failed_req);
 
                        s->flags |= SF_FINST_R;
                }
@@ -1061,7 +1063,7 @@ enum act_return process_use_service(struct act_rule *rule, struct proxy *px,
 
        if (rule->from != ACT_F_HTTP_REQ) {
                if (sess->fe == s->be) /* report it if the request was intercepted by the frontend */
-                       _HA_ATOMIC_INC(&sess->fe->fe_counters.shared.tg[tgid - 1]->intercepted_req);
+                       _HA_ATOMIC_INC(&sess->fe_tgcounters->intercepted_req);
 
                /* The flag SF_ASSIGNED prevent from server assignment. */
                s->flags |= SF_ASSIGNED;
@@ -1231,7 +1233,7 @@ static int process_server_rules(struct stream *s, struct channel *req, int an_bi
                            (px->options & PR_O_PERSIST) ||
                            (s->flags & SF_FORCE_PRST)) {
                                s->flags |= SF_DIRECT | SF_ASSIGNED;
-                               s->target = &srv->obj_type;
+                               stream_set_srv_target(s, srv);
                                break;
                        }
                        /* if the server is not UP, let's go on with next rules
@@ -1285,7 +1287,7 @@ static inline void sticking_rule_find_target(struct stream *s,
        if ((srv->cur_state != SRV_ST_STOPPED) ||
            (px->options & PR_O_PERSIST) || (s->flags & SF_FORCE_PRST)) {
                s->flags |= SF_DIRECT | SF_ASSIGNED;
-               s->target = &srv->obj_type;
+               stream_set_srv_target(s, srv);
        }
 }
 
@@ -1846,12 +1848,12 @@ struct task *process_stream(struct task *t, void *context, unsigned int state)
                        sc_shutdown(scf);
                        if (!(req->analysers) && !(res->analysers)) {
                                COUNT_IF(1, "Report a client abort (no analysers)");
-                               _HA_ATOMIC_INC(&s->be->be_counters.shared.tg[tgid - 1]->cli_aborts);
-                               _HA_ATOMIC_INC(&sess->fe->fe_counters.shared.tg[tgid - 1]->cli_aborts);
+                               _HA_ATOMIC_INC(&s->be_tgcounters->cli_aborts);
+                               _HA_ATOMIC_INC(&sess->fe_tgcounters->cli_aborts);
                                if (sess->listener && sess->listener->counters)
-                                       _HA_ATOMIC_INC(&sess->listener->counters->shared.tg[tgid - 1]->cli_aborts);
+                                       _HA_ATOMIC_INC(&sess->li_tgcounters->cli_aborts);
                                if (srv)
-                                       _HA_ATOMIC_INC(&srv->counters.shared.tg[tgid - 1]->cli_aborts);
+                                       _HA_ATOMIC_INC(&s->sv_tgcounters->cli_aborts);
                                if (!(s->flags & SF_ERR_MASK))
                                        s->flags |= SF_ERR_CLICL;
                                if (!(s->flags & SF_FINST_MASK))
@@ -1864,17 +1866,17 @@ struct task *process_stream(struct task *t, void *context, unsigned int state)
                if (sc_state_in(scb->state, SC_SB_EST|SC_SB_DIS)) {
                        sc_abort(scb);
                        sc_shutdown(scb);
-                       _HA_ATOMIC_INC(&s->be->be_counters.shared.tg[tgid - 1]->failed_resp);
+                       _HA_ATOMIC_INC(&s->be_tgcounters->failed_resp);
                        if (srv)
-                               _HA_ATOMIC_INC(&srv->counters.shared.tg[tgid - 1]->failed_resp);
+                               _HA_ATOMIC_INC(&s->sv_tgcounters->failed_resp);
                        if (!(req->analysers) && !(res->analysers)) {
                                COUNT_IF(1, "Report a client abort (no analysers)");
-                               _HA_ATOMIC_INC(&s->be->be_counters.shared.tg[tgid - 1]->srv_aborts);
-                               _HA_ATOMIC_INC(&sess->fe->fe_counters.shared.tg[tgid - 1]->srv_aborts);
+                               _HA_ATOMIC_INC(&s->be_tgcounters->srv_aborts);
+                               _HA_ATOMIC_INC(&sess->fe_tgcounters->srv_aborts);
                                if (sess->listener && sess->listener->counters)
-                                       _HA_ATOMIC_INC(&sess->listener->counters->shared.tg[tgid - 1]->srv_aborts);
+                                       _HA_ATOMIC_INC(&sess->li_tgcounters->srv_aborts);
                                if (srv)
-                                       _HA_ATOMIC_INC(&srv->counters.shared.tg[tgid - 1]->srv_aborts);
+                                       _HA_ATOMIC_INC(&s->sv_tgcounters->srv_aborts);
                                if (!(s->flags & SF_ERR_MASK))
                                        s->flags |= SF_ERR_SRVCL;
                                if (!(s->flags & SF_FINST_MASK))
@@ -2178,32 +2180,32 @@ struct task *process_stream(struct task *t, void *context, unsigned int state)
                        req->analysers &= AN_REQ_FLT_END;
                        channel_auto_close(req);
                        if (scf->flags & SC_FL_ERROR) {
-                               _HA_ATOMIC_INC(&s->be->be_counters.shared.tg[tgid - 1]->cli_aborts);
-                               _HA_ATOMIC_INC(&sess->fe->fe_counters.shared.tg[tgid - 1]->cli_aborts);
+                               _HA_ATOMIC_INC(&s->be_tgcounters->cli_aborts);
+                               _HA_ATOMIC_INC(&sess->fe_tgcounters->cli_aborts);
                                if (sess->listener && sess->listener->counters)
-                                       _HA_ATOMIC_INC(&sess->listener->counters->shared.tg[tgid - 1]->cli_aborts);
+                                       _HA_ATOMIC_INC(&sess->li_tgcounters->cli_aborts);
                                if (srv)
-                                       _HA_ATOMIC_INC(&srv->counters.shared.tg[tgid - 1]->cli_aborts);
+                                       _HA_ATOMIC_INC(&s->sv_tgcounters->cli_aborts);
                                s->flags |= SF_ERR_CLICL;
                                COUNT_IF(1, "Report unhandled client error");
                        }
                        else if (req->flags & CF_READ_TIMEOUT) {
-                               _HA_ATOMIC_INC(&s->be->be_counters.shared.tg[tgid - 1]->cli_aborts);
-                               _HA_ATOMIC_INC(&sess->fe->fe_counters.shared.tg[tgid - 1]->cli_aborts);
+                               _HA_ATOMIC_INC(&s->be_tgcounters->cli_aborts);
+                               _HA_ATOMIC_INC(&sess->fe_tgcounters->cli_aborts);
                                if (sess->listener && sess->listener->counters)
-                                       _HA_ATOMIC_INC(&sess->listener->counters->shared.tg[tgid - 1]->cli_aborts);
+                                       _HA_ATOMIC_INC(&sess->li_tgcounters->cli_aborts);
                                if (srv)
-                                       _HA_ATOMIC_INC(&srv->counters.shared.tg[tgid - 1]->cli_aborts);
+                                       _HA_ATOMIC_INC(&s->sv_tgcounters->cli_aborts);
                                s->flags |= SF_ERR_CLITO;
                                COUNT_IF(1, "Report unhandled client timeout (RD)");
                        }
                        else {
-                               _HA_ATOMIC_INC(&s->be->be_counters.shared.tg[tgid - 1]->srv_aborts);
-                               _HA_ATOMIC_INC(&sess->fe->fe_counters.shared.tg[tgid - 1]->srv_aborts);
+                               _HA_ATOMIC_INC(&s->be_tgcounters->srv_aborts);
+                               _HA_ATOMIC_INC(&sess->fe_tgcounters->srv_aborts);
                                if (sess->listener && sess->listener->counters)
-                                       _HA_ATOMIC_INC(&sess->listener->counters->shared.tg[tgid - 1]->srv_aborts);
+                                       _HA_ATOMIC_INC(&sess->li_tgcounters->srv_aborts);
                                if (srv)
-                                       _HA_ATOMIC_INC(&srv->counters.shared.tg[tgid - 1]->srv_aborts);
+                                       _HA_ATOMIC_INC(&s->sv_tgcounters->srv_aborts);
                                s->flags |= SF_ERR_SRVTO;
                                COUNT_IF(1, "Report unhandled server timeout (WR)");
                        }
@@ -2227,32 +2229,32 @@ struct task *process_stream(struct task *t, void *context, unsigned int state)
                        res->analysers &= AN_RES_FLT_END;
                        channel_auto_close(res);
                        if (scb->flags & SC_FL_ERROR) {
-                               _HA_ATOMIC_INC(&s->be->be_counters.shared.tg[tgid - 1]->srv_aborts);
-                               _HA_ATOMIC_INC(&sess->fe->fe_counters.shared.tg[tgid - 1]->srv_aborts);
+                               _HA_ATOMIC_INC(&s->be_tgcounters->srv_aborts);
+                               _HA_ATOMIC_INC(&sess->fe_tgcounters->srv_aborts);
                                if (sess->listener && sess->listener->counters)
-                                       _HA_ATOMIC_INC(&sess->listener->counters->shared.tg[tgid - 1]->srv_aborts);
+                                       _HA_ATOMIC_INC(&sess->li_tgcounters->srv_aborts);
                                if (srv)
-                                       _HA_ATOMIC_INC(&srv->counters.shared.tg[tgid - 1]->srv_aborts);
+                                       _HA_ATOMIC_INC(&s->sv_tgcounters->srv_aborts);
                                s->flags |= SF_ERR_SRVCL;
                                COUNT_IF(1, "Report unhandled server error");
                        }
                        else if (res->flags & CF_READ_TIMEOUT) {
-                               _HA_ATOMIC_INC(&s->be->be_counters.shared.tg[tgid - 1]->srv_aborts);
-                               _HA_ATOMIC_INC(&sess->fe->fe_counters.shared.tg[tgid - 1]->srv_aborts);
+                               _HA_ATOMIC_INC(&s->be_tgcounters->srv_aborts);
+                               _HA_ATOMIC_INC(&sess->fe_tgcounters->srv_aborts);
                                if (sess->listener && sess->listener->counters)
-                                       _HA_ATOMIC_INC(&sess->listener->counters->shared.tg[tgid - 1]->srv_aborts);
+                                       _HA_ATOMIC_INC(&sess->li_tgcounters->srv_aborts);
                                if (srv)
-                                       _HA_ATOMIC_INC(&srv->counters.shared.tg[tgid - 1]->srv_aborts);
+                                       _HA_ATOMIC_INC(&s->sv_tgcounters->srv_aborts);
                                s->flags |= SF_ERR_SRVTO;
                                COUNT_IF(1, "Report unhandled server timeout (RD)");
                        }
                        else {
-                               _HA_ATOMIC_INC(&s->be->be_counters.shared.tg[tgid - 1]->cli_aborts);
-                               _HA_ATOMIC_INC(&sess->fe->fe_counters.shared.tg[tgid - 1]->cli_aborts);
+                               _HA_ATOMIC_INC(&s->be_tgcounters->cli_aborts);
+                               _HA_ATOMIC_INC(&sess->fe_tgcounters->cli_aborts);
                                if (sess->listener && sess->listener->counters)
-                                       _HA_ATOMIC_INC(&sess->listener->counters->shared.tg[tgid - 1]->cli_aborts);
+                                       _HA_ATOMIC_INC(&sess->li_tgcounters->cli_aborts);
                                if (srv)
-                                       _HA_ATOMIC_INC(&srv->counters.shared.tg[tgid - 1]->cli_aborts);
+                                       _HA_ATOMIC_INC(&s->sv_tgcounters->cli_aborts);
                                s->flags |= SF_ERR_CLITO;
                                COUNT_IF(1, "Report unhandled client timeout (WR)");
                        }
@@ -2623,12 +2625,12 @@ struct task *process_stream(struct task *t, void *context, unsigned int state)
                                n = 0;
 
                        if (sess->fe->mode == PR_MODE_HTTP) {
-                               _HA_ATOMIC_INC(&sess->fe->fe_counters.shared.tg[tgid - 1]->p.http.rsp[n]);
+                               _HA_ATOMIC_INC(&sess->fe_tgcounters->p.http.rsp[n]);
                        }
                        if ((s->flags & SF_BE_ASSIGNED) &&
                            (s->be->mode == PR_MODE_HTTP)) {
-                               _HA_ATOMIC_INC(&s->be->be_counters.shared.tg[tgid - 1]->p.http.rsp[n]);
-                               _HA_ATOMIC_INC(&s->be->be_counters.shared.tg[tgid - 1]->p.http.cum_req);
+                               _HA_ATOMIC_INC(&s->be_tgcounters->p.http.rsp[n]);
+                               _HA_ATOMIC_INC(&s->be_tgcounters->p.http.cum_req);
                        }
                }
 
@@ -2693,7 +2695,7 @@ void stream_update_time_stats(struct stream *s)
        srv = objt_server(s->target);
        if (srv) {
                samples_window = (((s->be->mode == PR_MODE_HTTP) ?
-                       HA_ATOMIC_LOAD(&srv->counters.shared.tg[tgid - 1]->p.http.cum_req) : HA_ATOMIC_LOAD(&srv->counters.shared.tg[tgid - 1]->cum_lbconn)) > TIME_STATS_SAMPLES) ? TIME_STATS_SAMPLES : 0;
+                       HA_ATOMIC_LOAD(&s->sv_tgcounters->p.http.cum_req) : HA_ATOMIC_LOAD(&s->sv_tgcounters->cum_lbconn)) > TIME_STATS_SAMPLES) ? TIME_STATS_SAMPLES : 0;
                swrate_add_dynamic(&srv->counters.q_time, samples_window, t_queue);
                swrate_add_dynamic(&srv->counters.c_time, samples_window, t_connect);
                swrate_add_dynamic(&srv->counters.d_time, samples_window, t_data);
@@ -2704,7 +2706,7 @@ void stream_update_time_stats(struct stream *s)
                HA_ATOMIC_UPDATE_MAX(&srv->counters.ttime_max, t_close);
        }
        samples_window = (((s->be->mode == PR_MODE_HTTP) ?
-               HA_ATOMIC_LOAD(&s->be->be_counters.shared.tg[tgid - 1]->p.http.cum_req) : HA_ATOMIC_LOAD(&s->be->be_counters.shared.tg[tgid - 1]->cum_lbconn)) > TIME_STATS_SAMPLES) ? TIME_STATS_SAMPLES : 0;
+               HA_ATOMIC_LOAD(&s->be_tgcounters->p.http.cum_req) : HA_ATOMIC_LOAD(&s->be_tgcounters->cum_lbconn)) > TIME_STATS_SAMPLES) ? TIME_STATS_SAMPLES : 0;
        swrate_add_dynamic(&s->be->be_counters.q_time, samples_window, t_queue);
        swrate_add_dynamic(&s->be->be_counters.c_time, samples_window, t_connect);
        swrate_add_dynamic(&s->be->be_counters.d_time, samples_window, t_data);

diff --git a/src/tcp_act.c b/src/tcp_act.c
index 47c011c233fdac5637b7bbdc86ade1c7cb2675e9..d5e69793bcd11c80ac07cff217e1788138e0b991 100644 (file)
--- a/src/tcp_act.c
+++ b/src/tcp_act.c
@@ -397,16 +397,16 @@ static enum act_return tcp_exec_action_silent_drop(struct act_rule *rule, struct
                strm->req.analysers &= AN_REQ_FLT_END;
                strm->res.analysers &= AN_RES_FLT_END;
                if (strm->flags & SF_BE_ASSIGNED)
-                       _HA_ATOMIC_INC(&strm->be->be_counters.shared.tg[tgid - 1]->denied_req);
+                       _HA_ATOMIC_INC(&strm->be_tgcounters->denied_req);
                if (!(strm->flags & SF_ERR_MASK))
                        strm->flags |= SF_ERR_PRXCOND;
                if (!(strm->flags & SF_FINST_MASK))
                        strm->flags |= SF_FINST_R;
        }
 
-       _HA_ATOMIC_INC(&sess->fe->fe_counters.shared.tg[tgid - 1]->denied_req);
+       _HA_ATOMIC_INC(&sess->fe_tgcounters->denied_req);
        if (sess->listener && sess->listener->counters)
-               _HA_ATOMIC_INC(&sess->listener->counters->shared.tg[tgid - 1]->denied_req);
+               _HA_ATOMIC_INC(&sess->li_tgcounters->denied_req);
 
        return ACT_RET_ABRT;
 }

diff --git a/src/tcp_rules.c b/src/tcp_rules.c
index 70f5269cf62af1ec678583c85f3cc788c93db0f8..5b354404085f4e0b2bcb92c099db9fefad63364a 100644 (file)
--- a/src/tcp_rules.c
+++ b/src/tcp_rules.c
@@ -264,25 +264,25 @@ resume_execution:
        return 0;
 
  deny:
-       _HA_ATOMIC_INC(&sess->fe->fe_counters.shared.tg[tgid - 1]->denied_req);
+       _HA_ATOMIC_INC(&sess->fe_tgcounters->denied_req);
        if (sess->listener && sess->listener->counters)
-               _HA_ATOMIC_INC(&sess->listener->counters->shared.tg[tgid - 1]->denied_req);
+               _HA_ATOMIC_INC(&sess->li_tgcounters->denied_req);
        stream_report_term_evt(s->scf, strm_tevt_type_intercepted);
        goto reject;
 
  internal:
-       _HA_ATOMIC_INC(&sess->fe->fe_counters.shared.tg[tgid - 1]->internal_errors);
+       _HA_ATOMIC_INC(&sess->fe_tgcounters->internal_errors);
        if (sess->listener && sess->listener->counters)
-               _HA_ATOMIC_INC(&sess->listener->counters->shared.tg[tgid - 1]->internal_errors);
+               _HA_ATOMIC_INC(&sess->li_tgcounters->internal_errors);
        if (!(s->flags & SF_ERR_MASK))
                s->flags |= SF_ERR_INTERNAL;
        stream_report_term_evt(s->scf, strm_tevt_type_internal_err);
        goto reject;
 
  invalid:
-       _HA_ATOMIC_INC(&sess->fe->fe_counters.shared.tg[tgid - 1]->failed_req);
+       _HA_ATOMIC_INC(&sess->fe_tgcounters->failed_req);
        if (sess->listener && sess->listener->counters)
-               _HA_ATOMIC_INC(&sess->listener->counters->shared.tg[tgid - 1]->failed_req);
+               _HA_ATOMIC_INC(&sess->li_tgcounters->failed_req);
        stream_report_term_evt(s->scf, strm_tevt_type_proto_err);
 
  reject:
@@ -486,31 +486,31 @@ resume_execution:
        return 0;
 
   deny:
-       _HA_ATOMIC_INC(&s->sess->fe->fe_counters.shared.tg[tgid - 1]->denied_resp);
-       _HA_ATOMIC_INC(&s->be->be_counters.shared.tg[tgid - 1]->denied_resp);
+       _HA_ATOMIC_INC(&s->sess->fe_tgcounters->denied_resp);
+       _HA_ATOMIC_INC(&s->be_tgcounters->denied_resp);
        if (s->sess->listener && s->sess->listener->counters)
-               _HA_ATOMIC_INC(&s->sess->listener->counters->shared.tg[tgid - 1]->denied_resp);
+               _HA_ATOMIC_INC(&s->sess->li_tgcounters->denied_resp);
        if (objt_server(s->target))
-               _HA_ATOMIC_INC(&__objt_server(s->target)->counters.shared.tg[tgid - 1]->denied_resp);
+               _HA_ATOMIC_INC(&s->sv_tgcounters->denied_resp);
        stream_report_term_evt(s->scb, strm_tevt_type_intercepted);
        goto reject;
 
  internal:
-       _HA_ATOMIC_INC(&s->sess->fe->fe_counters.shared.tg[tgid - 1]->internal_errors);
-       _HA_ATOMIC_INC(&s->be->be_counters.shared.tg[tgid - 1]->internal_errors);
+       _HA_ATOMIC_INC(&s->sess->fe_tgcounters->internal_errors);
+       _HA_ATOMIC_INC(&s->be_tgcounters->internal_errors);
        if (s->sess->listener && s->sess->listener->counters)
-               _HA_ATOMIC_INC(&s->sess->listener->counters->shared.tg[tgid - 1]->internal_errors);
+               _HA_ATOMIC_INC(&s->sess->li_tgcounters->internal_errors);
        if (objt_server(s->target))
-               _HA_ATOMIC_INC(&__objt_server(s->target)->counters.shared.tg[tgid - 1]->internal_errors);
+               _HA_ATOMIC_INC(&s->sv_tgcounters->internal_errors);
        if (!(s->flags & SF_ERR_MASK))
                s->flags |= SF_ERR_INTERNAL;
        stream_report_term_evt(s->scf, strm_tevt_type_internal_err);
        goto reject;
 
  invalid:
-       _HA_ATOMIC_INC(&s->be->be_counters.shared.tg[tgid - 1]->failed_resp);
+       _HA_ATOMIC_INC(&s->be_tgcounters->failed_resp);
        if (objt_server(s->target))
-               _HA_ATOMIC_INC(&__objt_server(s->target)->counters.shared.tg[tgid - 1]->failed_resp);
+               _HA_ATOMIC_INC(&s->sv_tgcounters->failed_resp);
        stream_report_term_evt(s->scf, strm_tevt_type_proto_err);
 
  reject:
@@ -585,9 +585,9 @@ int tcp_exec_l4_rules(struct session *sess)
                        goto end;
                }
                else if (rule->action == ACT_ACTION_DENY) {
-                       _HA_ATOMIC_INC(&sess->fe->fe_counters.shared.tg[tgid - 1]->denied_conn);
+                       _HA_ATOMIC_INC(&sess->fe_tgcounters->denied_conn);
                        if (sess->listener && sess->listener->counters)
-                               _HA_ATOMIC_INC(&sess->listener->counters->shared.tg[tgid - 1]->denied_conn);
+                               _HA_ATOMIC_INC(&sess->li_tgcounters->denied_conn);
 
                        result = 0;
                        goto end;
@@ -673,9 +673,9 @@ int tcp_exec_l5_rules(struct session *sess)
                        goto end;
                }
                else if (rule->action == ACT_ACTION_DENY) {
-                       _HA_ATOMIC_INC(&sess->fe->fe_counters.shared.tg[tgid - 1]->denied_sess);
+                       _HA_ATOMIC_INC(&sess->fe_tgcounters->denied_sess);
                        if (sess->listener && sess->listener->counters)
-                               _HA_ATOMIC_INC(&sess->listener->counters->shared.tg[tgid - 1]->denied_sess);
+                               _HA_ATOMIC_INC(&sess->li_tgcounters->denied_sess);
 
                        result = 0;
                        goto end;