mirrors/haproxy
1
0
Fork 0
mirror of https://git.haproxy.org/git/haproxy.git/ synced 2025-08-06 07:07:04 +02:00
Code Issues Projects Releases Wiki Activity

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

Browse Source 
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)
This commit is contained in:
Aurelien DARRAGON 2025-07-24 19:46:36 +02:00
parent cf8ba60c88
commit c24de077bd
21 changed files with 285 additions and 264 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
include/haproxy/session-t.h
View File

@ -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 */
};
/*

2
include/haproxy/stream-t.h
View File

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

9
include/haproxy/stream.h
View File

@ -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);

49
src/backend.c
View File

@ -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;
}
}

2
src/cli.c
View File

@ -3364,6 +3364,8 @@ int pcli_wait_for_request(struct stream *s, struct channel *req, int an_bit)
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;

2
src/dns.c
View File

@ -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;

8
src/fcgi-app.c
View File

@ -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) {

16
src/flt_http_comp.c
View File

@ -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;
}

4
src/hlua.c
View File

@ -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:

58
src/http_act.c
View File

@ -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;

202
src/http_ana.c
View File

@ -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:

3
src/http_client.c
View File

@ -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;

8
src/log.c
View File

@ -5947,15 +5947,15 @@ static void syslog_io_handler(struct appctx *appctx)
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);

24
src/mux_h1.c
View File

@ -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);

2
src/peers.c
View File

@ -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;

1
src/proxy.c
View File

@ -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);

3
src/session.c
View File

@ -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);

2
src/sink.c
View File

@ -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;

106
src/stream.c
View File

@ -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);

6
src/tcp_act.c
View File

@ -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;
}

40
src/tcp_rules.c
View File

@ -264,25 +264,25 @@ int tcp_inspect_request(struct stream *s, struct channel *req, int an_bit)
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 @@ int tcp_inspect_response(struct stream *s, struct channel *rep, int an_bit)
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;