mirrors/haproxy
1
0
Fork 0
mirror of https://git.haproxy.org/git/haproxy.git/ synced 2025-09-21 13:51:26 +02:00
Code Issues Projects Releases Wiki Activity

MINOR: channel/stconn: Replace sc_shutr() by sc_abort()

Browse Source 
All reference to a shutr is replaced by an abort. So sc_shutr() is renamed
sc_abort(). SC app ops functions are renamed accordingly.
This commit is contained in:
Christopher Faulet 2023-04-13 16:10:23 +02:00
parent 0c370eee6d
commit cfc11c0eae
8 changed files with 36 additions and 36 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
include/haproxy/sc_strm.h
View File

@ -262,13 +262,6 @@ static inline void sc_must_kill_conn(struct stconn *sc)
} }
/* Sends a shutr to the endpoint using the data layer */
static inline void sc_shutr(struct stconn *sc)
{
if (likely(sc->app_ops->shutr))
sc->app_ops->shutr(sc);
}
/* Sends a shutw to the endpoint using the data layer */ /* Sends a shutw to the endpoint using the data layer */
static inline void sc_shutw(struct stconn *sc) static inline void sc_shutw(struct stconn *sc)
{ {
@ -420,6 +413,13 @@ static inline void sc_schedule_abort(struct stconn *sc)
sc->flags |= SC_FL_ABRT_WANTED; sc->flags |= SC_FL_ABRT_WANTED;
} }
/* Abort the SC and notify the endpoint using the data layer */
static inline void sc_abort(struct stconn *sc)
{
if (likely(sc->app_ops->abort))
sc->app_ops->abort(sc);
}
/* Schedule a shutdown for the SC */ /* Schedule a shutdown for the SC */
static inline void sc_schedule_shutdown(struct stconn *sc) static inline void sc_schedule_shutdown(struct stconn *sc)
{ {

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

@ -265,7 +265,7 @@ struct sedesc {
struct sc_app_ops { struct sc_app_ops {
void (*chk_rcv)(struct stconn *); /* chk_rcv function, may not be null */ void (*chk_rcv)(struct stconn *); /* chk_rcv function, may not be null */
void (*chk_snd)(struct stconn *); /* chk_snd function, may not be null */ void (*chk_snd)(struct stconn *); /* chk_snd function, may not be null */
void (*shutr)(struct stconn *); /* shut read function, may not be null */ void (*abort)(struct stconn *); /* abort function, may not be null */
void (*shutw)(struct stconn *); /* shut write function, may not be null */ void (*shutw)(struct stconn *); /* shut write function, may not be null */
int (*wake)(struct stconn *); /* data-layer callback to report activity */ int (*wake)(struct stconn *); /* data-layer callback to report activity */
char name[8]; /* data layer name, zero-terminated */ char name[8]; /* data layer name, zero-terminated */

10
src/backend.c
View File

@ -2022,7 +2022,7 @@ void back_try_conn_req(struct stream *s)
process_srv_queue(srv); process_srv_queue(srv);
/* Failed and not retryable. */ /* Failed and not retryable. */
sc_shutr(sc); sc_abort(sc);
sc_shutw(sc); sc_shutw(sc);
sc_ep_set(sc, SE_FL_ERROR|SE_FL_EOS); sc_ep_set(sc, SE_FL_ERROR|SE_FL_EOS);
@ -2082,7 +2082,7 @@ void back_try_conn_req(struct stream *s)
if (srv) if (srv)
_HA_ATOMIC_INC(&srv->counters.failed_conns); _HA_ATOMIC_INC(&srv->counters.failed_conns);
_HA_ATOMIC_INC(&s->be->be_counters.failed_conns); _HA_ATOMIC_INC(&s->be->be_counters.failed_conns);
sc_shutr(sc); sc_abort(sc);
sc_shutw(sc); sc_shutw(sc);
req->flags |= CF_WRITE_TIMEOUT; req->flags |= CF_WRITE_TIMEOUT;
if (!s->conn_err_type) if (!s->conn_err_type)
@ -2142,7 +2142,7 @@ abort_connection:
/* give up */ /* give up */
s->conn_exp = TICK_ETERNITY; s->conn_exp = TICK_ETERNITY;
s->flags &= ~SF_CONN_EXP; s->flags &= ~SF_CONN_EXP;
sc_shutr(sc); sc_abort(sc);
sc_shutw(sc); sc_shutw(sc);
sc->state = SC_ST_CLO; sc->state = SC_ST_CLO;
if (s->srv_error) if (s->srv_error)
@ -2182,7 +2182,7 @@ void back_handle_st_req(struct stream *s)
*/ */
s->flags &= ~(SF_ERR_MASK | SF_FINST_MASK); s->flags &= ~(SF_ERR_MASK | SF_FINST_MASK);
sc_shutr(sc); sc_abort(sc);
sc_shutw(sc); sc_shutw(sc);
sc_ep_set(sc, SE_FL_ERROR|SE_FL_EOS); sc_ep_set(sc, SE_FL_ERROR|SE_FL_EOS);
s->conn_err_type = STRM_ET_CONN_RES; s->conn_err_type = STRM_ET_CONN_RES;
@ -2208,7 +2208,7 @@ void back_handle_st_req(struct stream *s)
} }
/* we did not get any server, let's check the cause */ /* we did not get any server, let's check the cause */
sc_shutr(sc); sc_abort(sc);
sc_shutw(sc); sc_shutw(sc);
sc_ep_set(sc, SE_FL_ERROR|SE_FL_EOS); sc_ep_set(sc, SE_FL_ERROR|SE_FL_EOS);
if (!s->conn_err_type) if (!s->conn_err_type)

2
src/cli.c
View File

@ -2747,7 +2747,7 @@ int pcli_wait_for_response(struct stream *s, struct channel *rep, int an_bit)
pcli_write_prompt(s); pcli_write_prompt(s);
s->scb->flags |= SC_FL_NOLINGER | SC_FL_NOHALF; s->scb->flags |= SC_FL_NOLINGER | SC_FL_NOHALF;
sc_shutr(s->scb); sc_abort(s->scb);
sc_shutw(s->scb); sc_shutw(s->scb);
/* /*

2
src/http_ana.c
View File

@ -4177,7 +4177,7 @@ void http_perform_server_redirect(struct stream *s, struct stconn *sc)
goto fail; goto fail;
/* return without error. */ /* return without error. */
sc_shutr(sc); sc_abort(sc);
sc_shutw(sc); sc_shutw(sc);
s->conn_err_type = STRM_ET_NONE; s->conn_err_type = STRM_ET_NONE;
sc->state = SC_ST_CLO; sc->state = SC_ST_CLO;

28
src/stconn.c
View File

@ -24,19 +24,19 @@ DECLARE_POOL(pool_head_connstream, "stconn", sizeof(struct stconn));
DECLARE_POOL(pool_head_sedesc, "sedesc", sizeof(struct sedesc)); DECLARE_POOL(pool_head_sedesc, "sedesc", sizeof(struct sedesc));
/* functions used by default on a detached stream connector */ /* functions used by default on a detached stream connector */
static void sc_app_shutr(struct stconn *sc); static void sc_app_abort(struct stconn *sc);
static void sc_app_shutw(struct stconn *sc); static void sc_app_shutw(struct stconn *sc);
static void sc_app_chk_rcv(struct stconn *sc); static void sc_app_chk_rcv(struct stconn *sc);
static void sc_app_chk_snd(struct stconn *sc); static void sc_app_chk_snd(struct stconn *sc);
/* functions used on a mux-based stream connector */ /* functions used on a mux-based stream connector */
static void sc_app_shutr_conn(struct stconn *sc); static void sc_app_abort_conn(struct stconn *sc);
static void sc_app_shutw_conn(struct stconn *sc); static void sc_app_shutw_conn(struct stconn *sc);
static void sc_app_chk_rcv_conn(struct stconn *sc); static void sc_app_chk_rcv_conn(struct stconn *sc);
static void sc_app_chk_snd_conn(struct stconn *sc); static void sc_app_chk_snd_conn(struct stconn *sc);
/* functions used on an applet-based stream connector */ /* functions used on an applet-based stream connector */
static void sc_app_shutr_applet(struct stconn *sc); static void sc_app_abort_applet(struct stconn *sc);
static void sc_app_shutw_applet(struct stconn *sc); static void sc_app_shutw_applet(struct stconn *sc);
static void sc_app_chk_rcv_applet(struct stconn *sc); static void sc_app_chk_rcv_applet(struct stconn *sc);
static void sc_app_chk_snd_applet(struct stconn *sc); static void sc_app_chk_snd_applet(struct stconn *sc);
@ -50,7 +50,7 @@ static int sc_applet_process(struct stconn *sc);
struct sc_app_ops sc_app_conn_ops = { struct sc_app_ops sc_app_conn_ops = {
.chk_rcv = sc_app_chk_rcv_conn, .chk_rcv = sc_app_chk_rcv_conn,
.chk_snd = sc_app_chk_snd_conn, .chk_snd = sc_app_chk_snd_conn,
.shutr = sc_app_shutr_conn, .abort = sc_app_abort_conn,
.shutw = sc_app_shutw_conn, .shutw = sc_app_shutw_conn,
.wake = sc_conn_process, .wake = sc_conn_process,
.name = "STRM", .name = "STRM",
@ -60,7 +60,7 @@ struct sc_app_ops sc_app_conn_ops = {
struct sc_app_ops sc_app_embedded_ops = { struct sc_app_ops sc_app_embedded_ops = {
.chk_rcv = sc_app_chk_rcv, .chk_rcv = sc_app_chk_rcv,
.chk_snd = sc_app_chk_snd, .chk_snd = sc_app_chk_snd,
.shutr = sc_app_shutr, .abort = sc_app_abort,
.shutw = sc_app_shutw, .shutw = sc_app_shutw,
.wake = NULL, /* may never be used */ .wake = NULL, /* may never be used */
.name = "NONE", /* may never be used */ .name = "NONE", /* may never be used */
@ -70,7 +70,7 @@ struct sc_app_ops sc_app_embedded_ops = {
struct sc_app_ops sc_app_applet_ops = { struct sc_app_ops sc_app_applet_ops = {
.chk_rcv = sc_app_chk_rcv_applet, .chk_rcv = sc_app_chk_rcv_applet,
.chk_snd = sc_app_chk_snd_applet, .chk_snd = sc_app_chk_snd_applet,
.shutr = sc_app_shutr_applet, .abort = sc_app_abort_applet,
.shutw = sc_app_shutw_applet, .shutw = sc_app_shutw_applet,
.wake = sc_applet_process, .wake = sc_applet_process,
.name = "STRM", .name = "STRM",
@ -80,7 +80,7 @@ struct sc_app_ops sc_app_applet_ops = {
struct sc_app_ops sc_app_check_ops = { struct sc_app_ops sc_app_check_ops = {
.chk_rcv = NULL, .chk_rcv = NULL,
.chk_snd = NULL, .chk_snd = NULL,
.shutr = NULL, .abort = NULL,
.shutw = NULL, .shutw = NULL,
.wake = wake_srv_chk, .wake = wake_srv_chk,
.name = "CHCK", .name = "CHCK",
@ -530,7 +530,7 @@ static inline int sc_cond_forward_shutw(struct stconn *sc)
* reflect the new state. If the stream connector has SC_FL_NOHALF, we also * reflect the new state. If the stream connector has SC_FL_NOHALF, we also
* forward the close to the write side. The owner task is woken up if it exists. * forward the close to the write side. The owner task is woken up if it exists.
*/ */
static void sc_app_shutr(struct stconn *sc) static void sc_app_abort(struct stconn *sc)
{ {
struct channel *ic = sc_ic(sc); struct channel *ic = sc_ic(sc);
@ -655,7 +655,7 @@ static void sc_app_chk_snd(struct stconn *sc)
* descriptors are then shutdown or closed accordingly. The function * descriptors are then shutdown or closed accordingly. The function
* automatically disables polling if needed. * automatically disables polling if needed.
*/ */
static void sc_app_shutr_conn(struct stconn *sc) static void sc_app_abort_conn(struct stconn *sc)
{ {
struct channel *ic = sc_ic(sc); struct channel *ic = sc_ic(sc);
@ -738,7 +738,7 @@ static void sc_app_shutw_conn(struct stconn *sc)
__fallthrough; __fallthrough;
case SC_ST_CON: case SC_ST_CON:
/* we may have to close a pending connection, and mark the /* we may have to close a pending connection, and mark the
* response buffer as shutr * response buffer as abort
*/ */
sc_conn_shut(sc); sc_conn_shut(sc);
__fallthrough; __fallthrough;
@ -851,7 +851,7 @@ static void sc_app_chk_snd_conn(struct stconn *sc)
* we also forward the close to the write side. The owner task is woken up if * we also forward the close to the write side. The owner task is woken up if
* it exists. * it exists.
*/ */
static void sc_app_shutr_applet(struct stconn *sc) static void sc_app_abort_applet(struct stconn *sc)
{ {
struct channel *ic = sc_ic(sc); struct channel *ic = sc_ic(sc);
@ -862,7 +862,7 @@ static void sc_app_shutr_applet(struct stconn *sc)
sc->flags |= SC_FL_ABRT_DONE; sc->flags |= SC_FL_ABRT_DONE;
ic->flags |= CF_READ_EVENT; ic->flags |= CF_READ_EVENT;
/* Note: on shutr, we don't call the applet */ /* Note: on abort, we don't call the applet */
if (!sc_state_in(sc->state, SC_SB_CON|SC_SB_RDY|SC_SB_EST)) if (!sc_state_in(sc->state, SC_SB_CON|SC_SB_RDY|SC_SB_EST))
return; return;
@ -1197,7 +1197,7 @@ static int sc_conn_recv(struct stconn *sc)
if ((sc->wait_event.events & SUB_RETRY_RECV) || sc_waiting_room(sc)) if ((sc->wait_event.events & SUB_RETRY_RECV) || sc_waiting_room(sc))
return 0; return 0;
/* maybe we were called immediately after an asynchronous shutr */ /* maybe we were called immediately after an asynchronous abort */
if (sc->flags & SC_FL_ABRT_DONE) if (sc->flags & SC_FL_ABRT_DONE)
return 1; return 1;
@ -1847,7 +1847,7 @@ static int sc_applet_process(struct stconn *sc)
if (sc_ep_test(sc, SE_FL_EOS)) { if (sc_ep_test(sc, SE_FL_EOS)) {
/* we received a shutdown */ /* we received a shutdown */
sc_shutr(sc); sc_abort(sc);
} }
/* If the applet wants to write and the channel is closed, it's a /* If the applet wants to write and the channel is closed, it's a

12
src/stream.c
View File

@ -1593,7 +1593,7 @@ static void stream_handle_timeouts(struct stream *s)
if (unlikely(!(s->scf->flags & SC_FL_ABRT_DONE) && (s->req.flags & CF_READ_TIMEOUT))) { if (unlikely(!(s->scf->flags & SC_FL_ABRT_DONE) && (s->req.flags & CF_READ_TIMEOUT))) {
if (s->scf->flags & SC_FL_NOHALF) if (s->scf->flags & SC_FL_NOHALF)
s->scf->flags |= SC_FL_NOLINGER; s->scf->flags |= SC_FL_NOLINGER;
sc_shutr(s->scf); sc_abort(s->scf);
} }
if (unlikely(!(s->scf->flags & SC_FL_SHUTW) && (s->res.flags & CF_WRITE_TIMEOUT))) { if (unlikely(!(s->scf->flags & SC_FL_SHUTW) && (s->res.flags & CF_WRITE_TIMEOUT))) {
s->scf->flags |= SC_FL_NOLINGER; s->scf->flags |= SC_FL_NOLINGER;
@ -1603,7 +1603,7 @@ static void stream_handle_timeouts(struct stream *s)
if (unlikely(!(s->scb->flags & SC_FL_ABRT_DONE) && (s->res.flags & CF_READ_TIMEOUT))) { if (unlikely(!(s->scb->flags & SC_FL_ABRT_DONE) && (s->res.flags & CF_READ_TIMEOUT))) {
if (s->scb->flags & SC_FL_NOHALF) if (s->scb->flags & SC_FL_NOHALF)
s->scb->flags |= SC_FL_NOLINGER; s->scb->flags |= SC_FL_NOLINGER;
sc_shutr(s->scb); sc_abort(s->scb);
} }
if (HAS_FILTERS(s)) if (HAS_FILTERS(s))
@ -1826,7 +1826,7 @@ struct task *process_stream(struct task *t, void *context, unsigned int state)
srv = objt_server(s->target); srv = objt_server(s->target);
if (unlikely(sc_ep_test(scf, SE_FL_ERROR))) { if (unlikely(sc_ep_test(scf, SE_FL_ERROR))) {
if (sc_state_in(scf->state, SC_SB_EST|SC_SB_DIS)) { if (sc_state_in(scf->state, SC_SB_EST|SC_SB_DIS)) {
sc_shutr(scf); sc_abort(scf);
sc_shutw(scf); sc_shutw(scf);
//sc_report_error(scf); TODO: Be sure it is useless //sc_report_error(scf); TODO: Be sure it is useless
if (!(req->analysers) && !(res->analysers)) { if (!(req->analysers) && !(res->analysers)) {
@ -1846,7 +1846,7 @@ struct task *process_stream(struct task *t, void *context, unsigned int state)
if (unlikely(sc_ep_test(scb, SE_FL_ERROR))) { if (unlikely(sc_ep_test(scb, SE_FL_ERROR))) {
if (sc_state_in(scb->state, SC_SB_EST|SC_SB_DIS)) { if (sc_state_in(scb->state, SC_SB_EST|SC_SB_DIS)) {
sc_shutr(scb); sc_abort(scb);
sc_shutw(scb); sc_shutw(scb);
//sc_report_error(scb); TODO: Be sure it is useless //sc_report_error(scb); TODO: Be sure it is useless
_HA_ATOMIC_INC(&s->be->be_counters.failed_resp); _HA_ATOMIC_INC(&s->be->be_counters.failed_resp);
@ -2387,7 +2387,7 @@ struct task *process_stream(struct task *t, void *context, unsigned int state)
if (unlikely((scf->flags & (SC_FL_ABRT_DONE|SC_FL_ABRT_WANTED)) == SC_FL_ABRT_WANTED)) { if (unlikely((scf->flags & (SC_FL_ABRT_DONE|SC_FL_ABRT_WANTED)) == SC_FL_ABRT_WANTED)) {
if (scf->flags & SC_FL_NOHALF) if (scf->flags & SC_FL_NOHALF)
scf->flags |= SC_FL_NOLINGER; scf->flags |= SC_FL_NOLINGER;
sc_shutr(scf); sc_abort(scf);
} }
/* Benchmarks have shown that it's optimal to do a full resync now */ /* Benchmarks have shown that it's optimal to do a full resync now */
@ -2507,7 +2507,7 @@ struct task *process_stream(struct task *t, void *context, unsigned int state)
if (unlikely((scb->flags & (SC_FL_ABRT_DONE|SC_FL_ABRT_WANTED)) == SC_FL_ABRT_WANTED)) { if (unlikely((scb->flags & (SC_FL_ABRT_DONE|SC_FL_ABRT_WANTED)) == SC_FL_ABRT_WANTED)) {
if (scb->flags & SC_FL_NOHALF) if (scb->flags & SC_FL_NOHALF)
scb->flags |= SC_FL_NOLINGER; scb->flags |= SC_FL_NOLINGER;
sc_shutr(scb); sc_abort(scb);
} }
if (scf->state == SC_ST_DIS || if (scf->state == SC_ST_DIS ||

2
src/tcp_rules.c
View File

@ -393,7 +393,7 @@ resume_execution:
else if (rule->action == ACT_TCP_CLOSE) { else if (rule->action == ACT_TCP_CLOSE) {
chn_prod(rep)->flags |= SC_FL_NOLINGER | SC_FL_NOHALF; chn_prod(rep)->flags |= SC_FL_NOLINGER | SC_FL_NOHALF;
sc_must_kill_conn(chn_prod(rep)); sc_must_kill_conn(chn_prod(rep));
sc_shutr(chn_prod(rep)); sc_abort(chn_prod(rep));
sc_shutw(chn_prod(rep)); sc_shutw(chn_prod(rep));
s->last_rule_file = rule->conf.file; s->last_rule_file = rule->conf.file;
s->last_rule_line = rule->conf.line; s->last_rule_line = rule->conf.line;