From c24de077bdc779a1570999463175af34d0673ae8 Mon Sep 17 00:00:00 2001 From: Aurelien DARRAGON Date: Thu, 24 Jul 2025 19:46:36 +0200 Subject: [PATCH] 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) --- include/haproxy/session-t.h | 2 + include/haproxy/stream-t.h | 2 + include/haproxy/stream.h | 9 +- src/backend.c | 49 ++++----- src/cli.c | 2 + src/dns.c | 2 +- src/fcgi-app.c | 8 +- src/flt_http_comp.c | 16 +-- src/hlua.c | 4 +- src/http_act.c | 58 +++++------ src/http_ana.c | 202 ++++++++++++++++++------------------ src/http_client.c | 3 + src/log.c | 8 +- src/mux_h1.c | 24 ++--- src/peers.c | 2 +- src/proxy.c | 1 + src/session.c | 3 + src/sink.c | 2 +- src/stream.c | 106 +++++++++---------- src/tcp_act.c | 6 +- src/tcp_rules.c | 40 +++---- 21 files changed, 285 insertions(+), 264 deletions(-) diff --git a/include/haproxy/session-t.h b/include/haproxy/session-t.h index 7f034dd5b3..8889916a8a 100644 --- 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 7f44202ab8..83db4cc20e 100644 --- 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 3f6635c717..fa71c32127 100644 --- 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 ea9476088b..de16e680c0 100644 --- 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 6ca73059d3..9895b819ea 100644 --- 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 bb4ffc6d8f..16b3ef76ed 100644 --- 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 2dcf331ebe..8bddd1c29b 100644 --- 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 bc9a3cea21..9862f7d0de 100644 --- 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 c3435e651b..22eb0db286 100644 --- 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 112fbd891d..c583d9bd23 100644 --- 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 ad2c7c190d..bda8fe2409 100644 --- 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 33490bae9e..875be11993 100644 --- 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 a2eeff67a3..0d1e9a35b0 100644 --- 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 a3bb112072..6f1e95273c 100644 --- 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 efb2ac0a68..dd6988c623 100644 --- 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 754c9fccfd..b2d1f07b1d 100644 --- 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 b862628de6..21aff4ed81 100644 --- 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 22e5a3636c..69bb63b76e 100644 --- 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 7f3e587426..06d1cd86e5 100644 --- 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 47c011c233..d5e69793bc 100644 --- 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 70f5269cf6..5b35440408 100644 --- 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; -- 2.47.2