From: Aurelien DARRAGON Date: Thu, 24 Jul 2025 17:46:36 +0000 (+0200) Subject: OPTIM: stats: store fast sharded counters pointers at session and stream level X-Git-Tag: v3.3-dev4~1 X-Git-Url: http://git.ipfire.org/?a=commitdiff_plain;h=c24de07;p=thirdparty%2Fhaproxy.git 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 7f034dd5b..8889916a8 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 7f44202ab..83db4cc20 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 3f6635c71..fa71c3212 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 ea9476088..de16e680c 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 6ca73059d..9895b819e 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 bb4ffc6d8..16b3ef76e 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 2dcf331eb..8bddd1c29 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 bc9a3cea2..9862f7d0d 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 c3435e651..22eb0db28 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 112fbd891..c583d9bd2 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 ad2c7c190..bda8fe240 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 33490bae9..875be1199 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 a2eeff67a..0d1e9a35b 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 a3bb11207..6f1e95273 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 efb2ac0a6..dd6988c62 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 754c9fccf..b2d1f07b1 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 b862628de..21aff4ed8 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 22e5a3636..69bb63b76 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 7f3e58742..06d1cd86e 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 47c011c23..d5e69793b 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 70f5269cf..5b3544040 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;