MINOR: channel/stconn: Replace channel_shutw_now() by sc_schedule_shutdown()

After the flag renaming, it is now the turn for the channel function to be
renamed and moved in the SC scope. channel_shutw_now() is replaced by
sc_schedule_shutdown(). The request channel is replaced by the front SC and
the response is replace by the back SC.

diff --git a/include/haproxy/channel.h b/include/haproxy/channel.h
index f71b592fcc60965fa34c89f1a2881c765093271e..994daf8e3e134804d9ba338de3f84de5ad8d1ab9 100644 (file)
--- a/include/haproxy/channel.h
+++ b/include/haproxy/channel.h
@@ -548,11 +548,6 @@ static inline void channel_htx_erase(struct channel *chn, struct htx *htx)
        channel_erase(chn);
 }
 
-/* marks the channel as "shutdown" ASAP for writes */
-static inline void channel_shutw_now(struct channel *chn)
-{
-       chn_cons(chn)->flags |= SC_FL_SHUT_WANTED;
-}
 
 /* marks the channel as "shutdown" ASAP in both directions */
 static inline void channel_abort(struct channel *chn)

diff --git a/include/haproxy/sc_strm.h b/include/haproxy/sc_strm.h
index ae5861dc19042fe5ea2bff64ea2f21251bf994b0..1c8c47f4f4a33ac5d25957a0e0d22ec66dfb725d 100644 (file)
--- a/include/haproxy/sc_strm.h
+++ b/include/haproxy/sc_strm.h
@@ -420,4 +420,10 @@ static inline void sc_schedule_abort(struct stconn *sc)
        sc->flags |= SC_FL_ABRT_WANTED;
 }
 
+/* Schedule a shutdown for the SC */
+static inline void sc_schedule_shutdown(struct stconn *sc)
+{
+       sc->flags |= SC_FL_SHUT_WANTED;
+}
+
 #endif /* _HAPROXY_SC_STRM_H */

diff --git a/src/cli.c b/src/cli.c
index abb65f37b748c111f847f65dde456a9c84952e8c..7fefc3ebb21ef3c52f1c9faddabae639f398e1a8 100644 (file)
--- a/src/cli.c
+++ b/src/cli.c
@@ -2361,7 +2361,7 @@ int pcli_find_and_exec_kw(struct stream *s, char **args, int argl, char **errmsg
 
        } else if (strcmp("quit", args[0]) == 0) {
                sc_schedule_abort(s->scf);
-               channel_shutw_now(&s->res);
+               sc_schedule_shutdown(s->scf);
                return argl; /* return the number of elements in the array */
        } else if (strcmp(args[0], "operator") == 0) {
                if (!pcli_has_level(s, ACCESS_LVL_OPER)) {
@@ -2640,7 +2640,7 @@ read_again:
 
                if (!(s->pcli_flags & PCLI_F_PAYLOAD)) {
                        /* we send only 1 command per request, and we write close after it */
-                       channel_shutw_now(req);
+                       sc_schedule_shutdown(s->scb);
                } else {
                        pcli_write_prompt(s);
                }
@@ -2695,7 +2695,7 @@ missing_data:
         if (chn_prod(req)->flags & SC_FL_SHUTR) {
                 /* There is no more request or a only a partial one and we
                  * receive a close from the client, we can leave */
-                channel_shutw_now(&s->res);
+               sc_schedule_shutdown(s->scf);
                 s->req.analysers &= ~AN_REQ_WAIT_CLI;
                 return 1;
         }

diff --git a/src/http_ana.c b/src/http_ana.c
index 26bd098aa0a4259f75c4d087bf01a80b299c8431..282cf8ec5adb0fbddb7d1c7311b161a267005c71 100644 (file)
--- a/src/http_ana.c
+++ b/src/http_ana.c
@@ -4274,7 +4274,7 @@ static void http_end_request(struct stream *s)
 
                        if (!(chn_cons(chn)->flags & (SC_FL_SHUTW|SC_FL_SHUT_WANTED))) {
                                sc_schedule_abort(s->scf);
-                               channel_shutw_now(chn);
+                               sc_schedule_shutdown(s->scb);
                        }
                }
                goto check_channel_flags;
@@ -4283,7 +4283,7 @@ static void http_end_request(struct stream *s)
        if (txn->req.msg_state == HTTP_MSG_CLOSING) {
          http_msg_closing:
                /* nothing else to forward, just waiting for the output buffer
-                * to be empty and for the shutw_now to take effect.
+                * to be empty and for the shut_wanted to take effect.
                 */
                if (channel_is_empty(chn)) {
                        txn->req.msg_state = HTTP_MSG_CLOSED;
@@ -4373,7 +4373,7 @@ static void http_end_response(struct stream *s)
                         */
                        if (!(chn_cons(chn)->flags & (SC_FL_SHUTW|SC_FL_SHUT_WANTED))) {
                                sc_schedule_abort(s->scb);
-                               channel_shutw_now(chn);
+                               sc_schedule_shutdown(s->scf);
                        }
                }
                goto check_channel_flags;
@@ -4382,7 +4382,7 @@ static void http_end_response(struct stream *s)
        if (txn->rsp.msg_state == HTTP_MSG_CLOSING) {
          http_msg_closing:
                /* nothing else to forward, just waiting for the output buffer
-                * to be empty and for the shutw_now to take effect.
+                * to be empty and for the shut_wanted to take effect.
                 */
                if (channel_is_empty(chn)) {
                        txn->rsp.msg_state = HTTP_MSG_CLOSED;

diff --git a/src/stconn.c b/src/stconn.c
index 87529aa7365c276f544e726164ae2eb59c6c0acc..8e1759e8d26d6b7b4398a931375f381a58c8d373 100644 (file)
--- a/src/stconn.c
+++ b/src/stconn.c
@@ -511,11 +511,11 @@ static inline int sc_cond_forward_shutw(struct stconn *sc)
                return 0;
 
        if (!channel_is_empty(sc_ic(sc))) {
-               /* the close to the write side cannot be forwarded now because
+               /* the shutdown cannot be forwarded now because
                 * we should flush outgoing data first. But instruct the output
                 * channel it should be done ASAP.
                 */
-               channel_shutw_now(sc_oc(sc));
+               sc_schedule_shutdown(sc);
                return 0;
        }
 
@@ -1484,7 +1484,7 @@ static int sc_conn_recv(struct stconn *sc)
        if (sc_ep_test(sc, SE_FL_EOS)) {
                /* we received a shutdown */
                if (ic->flags & CF_AUTO_CLOSE)
-                       channel_shutw_now(ic);
+                       sc_schedule_shutdown(sc_opposite(sc));
                sc_conn_read0(sc);
                ret = 1;
        }
@@ -1777,7 +1777,7 @@ static int sc_conn_process(struct stconn *sc)
        if (sc_ep_test(sc, SE_FL_EOS) && !(sc->flags & SC_FL_SHUTR)) {
                /* we received a shutdown */
                if (ic->flags & CF_AUTO_CLOSE)
-                       channel_shutw_now(ic);
+                       sc_schedule_shutdown(sc_opposite(sc));
                sc_conn_read0(sc);
        }
 

diff --git a/src/stream.c b/src/stream.c
index 9ceffe3ee0d3bb8fa3d0f33499b459470fca6067..44f8f804407ecb31cf5ec739af766d78d8ff5c2c 100644 (file)
--- a/src/stream.c
+++ b/src/stream.c
@@ -2308,7 +2308,7 @@ struct task *process_stream(struct task *t, void *context, unsigned int state)
                }
                else {
                        s->scb->state = SC_ST_CLO; /* shutw+ini = abort */
-                       channel_shutw_now(req);        /* fix buffer flags upon abort */
+                       sc_schedule_shutdown(scb);
                        sc_schedule_abort(scb);
                }
        }
@@ -2367,7 +2367,7 @@ struct task *process_stream(struct task *t, void *context, unsigned int state)
        if (unlikely((req->flags & CF_AUTO_CLOSE) && (scf->flags & SC_FL_SHUTR) &&
                     !(scb->flags & (SC_FL_SHUTW|SC_FL_SHUT_WANTED)) &&
                     (scb->state != SC_ST_CON || (s->be->options & PR_O_ABRT_CLOSE)))) {
-               channel_shutw_now(req);
+               sc_schedule_shutdown(scb);
        }
 
        /* shutdown(write) pending */
@@ -2489,7 +2489,7 @@ struct task *process_stream(struct task *t, void *context, unsigned int state)
        /* first, let's check if the response buffer needs to shutdown(write) */
        if (unlikely((res->flags & CF_AUTO_CLOSE) && (scb->flags & SC_FL_SHUTR) &&
                     !(scf->flags & (SC_FL_SHUTW|SC_FL_SHUT_WANTED)))) {
-               channel_shutw_now(res);
+               sc_schedule_shutdown(scf);
        }
 
        /* shutdown(write) pending */
@@ -2781,7 +2781,7 @@ void stream_shutdown(struct stream *stream, int why)
        if (stream->scb->flags & (SC_FL_SHUTW|SC_FL_SHUT_WANTED))
                return;
 
-       channel_shutw_now(&stream->req);
+       sc_schedule_shutdown(stream->scb);
        sc_schedule_abort(stream->scb);
        stream->task->nice = 1024;
        if (!(stream->flags & SF_ERR_MASK))