MINOR: connection: Set the conncetion target during its initialisation

When a new connection is created, its target is always set just after. So the
connection target may set when it is created instead, during its initialisation
to be precise. It is the purpose of this patch. Now, conn_new() function is
called with the connection target as parameter. The target is then passed to
conn_init(). It means the target must be passed when cs_new() is called. In this
case, the target is only used when the conn-stream is created with no
connection. This only happens for tcpchecks for now.

diff --git a/include/haproxy/connection.h b/include/haproxy/connection.h
index b0974886029ce233ecf02f7afdde635dd7510696..8ccb31d38e7cfb1ad80502c696c1234a2a47a043 100644 (file)
--- a/include/haproxy/connection.h
+++ b/include/haproxy/connection.h
@@ -312,7 +312,7 @@ static inline void cs_init(struct conn_stream *cs, struct connection *conn)
  * is about to be reused. It also leaves the addresses untouched, which makes
  * it usable across connection retries to reset a connection to a known state.
  */
-static inline void conn_init(struct connection *conn)
+static inline void conn_init(struct connection *conn, void *target)
 {
        conn->obj_type = OBJ_TYPE_CONN;
        conn->flags = CO_FL_NONE;
@@ -322,7 +322,7 @@ static inline void conn_init(struct connection *conn)
        conn->send_proxy_ofs = 0;
        conn->handle.fd = DEAD_FD_MAGIC;
        conn->err_code = CO_ER_NONE;
-       conn->target = NULL;
+       conn->target = target;
        conn->destroy_cb = NULL;
        conn->proxy_netns = NULL;
        MT_LIST_INIT(&conn->list);
@@ -388,13 +388,13 @@ static inline void sockaddr_free(struct sockaddr_storage **sap)
  * connection is returned on success, NULL on failure. The connection must
  * be released using pool_free() or conn_free().
  */
-static inline struct connection *conn_new()
+static inline struct connection *conn_new(void *target)
 {
        struct connection *conn;
 
        conn = pool_alloc(pool_head_connection);
        if (likely(conn != NULL))
-               conn_init(conn);
+               conn_init(conn, target);
        return conn;
 }
 
@@ -414,7 +414,7 @@ static inline void cs_free(struct conn_stream *cs)
  * to the mux's stream list on success, then returned. On failure, nothing is
  * allocated and NULL is returned.
  */
-static inline struct conn_stream *cs_new(struct connection *conn)
+static inline struct conn_stream *cs_new(struct connection *conn, void *target)
 {
        struct conn_stream *cs;
 
@@ -423,12 +423,11 @@ static inline struct conn_stream *cs_new(struct connection *conn)
                return NULL;
 
        if (!conn) {
-               conn = conn_new();
+               conn = conn_new(target);
                if (unlikely(!conn)) {
                        cs_free(cs);
                        return NULL;
                }
-               conn_init(conn);
        }
 
        cs_init(cs, conn);

diff --git a/include/haproxy/stream_interface.h b/include/haproxy/stream_interface.h
index 66159d581a762c01b05d75f727835befd407654c..a81a84f54c8473581c6e3ebb915b2cd38ad526f9 100644 (file)
--- a/include/haproxy/stream_interface.h
+++ b/include/haproxy/stream_interface.h
@@ -372,7 +372,7 @@ static inline struct conn_stream *si_alloc_cs(struct stream_interface *si, struc
 
        si_release_endpoint(si);
 
-       cs = cs_new(conn);
+       cs = cs_new(conn, conn->target);
        if (cs)
                si_attach_cs(si, cs);
 

diff --git a/src/backend.c b/src/backend.c
index 8556d4c0a43f51d147a9482f32cc06b327321e77..47f4bffb5d9276935a9e152fce25acff4a905d73 100644 (file)
--- a/src/backend.c
+++ b/src/backend.c
@@ -1368,10 +1368,8 @@ int connect_server(struct stream *s)
 
        /* no reuse or failed to reuse the connection above, pick a new one */
        if (!srv_conn) {
-               srv_conn = conn_new();
+               srv_conn = conn_new(s->target);
                was_unused = 1;
-               if (srv_conn)
-                       srv_conn->target = s->target;
                srv_cs = NULL;
 
                srv_conn->owner = s->sess;

diff --git a/src/mux_fcgi.c b/src/mux_fcgi.c
index 88cc6b1e434980355c4b4daac74c0b197629b1f7..58d4923083017ff416920b698b51e00021a29950 100644 (file)
--- a/src/mux_fcgi.c
+++ b/src/mux_fcgi.c
@@ -3436,7 +3436,7 @@ static struct conn_stream *fcgi_attach(struct connection *conn, struct session *
        struct fcgi_conn *fconn = conn->ctx;
 
        TRACE_ENTER(FCGI_EV_FSTRM_NEW, conn);
-       cs = cs_new(conn);
+       cs = cs_new(conn, conn->target);
        if (!cs) {
                TRACE_DEVEL("leaving on CS allocation failure", FCGI_EV_FSTRM_NEW|FCGI_EV_FSTRM_ERR, conn);
                return NULL;

diff --git a/src/mux_h1.c b/src/mux_h1.c
index a27c2d0a3339dac07a9d4a9e5c77dbf30a9b254c..3268aff6e38761bbf0d6acf6045be260703d3c21 100644 (file)
--- a/src/mux_h1.c
+++ b/src/mux_h1.c
@@ -473,7 +473,7 @@ static struct conn_stream *h1s_new_cs(struct h1s *h1s)
        struct conn_stream *cs;
 
        TRACE_ENTER(H1_EV_STRM_NEW, h1s->h1c->conn, h1s);
-       cs = cs_new(h1s->h1c->conn);
+       cs = cs_new(h1s->h1c->conn, h1s->h1c->conn->target);
        if (!cs) {
                TRACE_DEVEL("leaving on CS allocation failure", H1_EV_STRM_NEW|H1_EV_STRM_END|H1_EV_STRM_ERR, h1s->h1c->conn, h1s);
                goto err;
@@ -2372,7 +2372,7 @@ static struct conn_stream *h1_attach(struct connection *conn, struct session *se
                goto end;
        }
 
-       cs = cs_new(h1c->conn);
+       cs = cs_new(h1c->conn, h1c->conn->target);
        if (!cs) {
                TRACE_DEVEL("leaving on CS allocation failure", H1_EV_STRM_NEW|H1_EV_STRM_END|H1_EV_STRM_ERR, conn);
                goto end;

diff --git a/src/mux_h2.c b/src/mux_h2.c
index ea79371bbb00a24ade0ddc798dbb4211abcc4314..4b790e61411eb806d66d60803c9b94fcabaf9e82 100644 (file)
--- a/src/mux_h2.c
+++ b/src/mux_h2.c
@@ -1352,7 +1352,7 @@ static struct h2s *h2c_frt_stream_new(struct h2c *h2c, int id)
        if (!h2s)
                goto out;
 
-       cs = cs_new(h2c->conn);
+       cs = cs_new(h2c->conn, h2c->conn->target);
        if (!cs)
                goto out_close;
 
@@ -3818,7 +3818,7 @@ static struct conn_stream *h2_attach(struct connection *conn, struct session *se
        struct h2c *h2c = conn->ctx;
 
        TRACE_ENTER(H2_EV_H2S_NEW, conn);
-       cs = cs_new(conn);
+       cs = cs_new(conn, conn->target);
        if (!cs) {
                TRACE_DEVEL("leaving on CS allocation failure", H2_EV_H2S_NEW|H2_EV_H2S_ERR, conn);
                return NULL;

diff --git a/src/mux_pt.c b/src/mux_pt.c
index 9a96fb862c338814b411346b15df0535e9cdcd14..a9fe0091fc80cd0f4f7c69edebf22dc96f2efe61 100644 (file)
--- a/src/mux_pt.c
+++ b/src/mux_pt.c
@@ -100,7 +100,7 @@ static int mux_pt_init(struct connection *conn, struct proxy *prx, struct sessio
        ctx->conn = conn;
 
        if (!cs) {
-               cs = cs_new(conn);
+               cs = cs_new(conn, conn->target);
                if (!cs)
                        goto fail_free_ctx;
 
@@ -167,7 +167,7 @@ static struct conn_stream *mux_pt_attach(struct connection *conn, struct session
 
        if (ctx->wait_event.events)
                conn->xprt->unsubscribe(ctx->conn, conn->xprt_ctx, SUB_RETRY_RECV, &ctx->wait_event);
-       cs = cs_new(conn);
+       cs = cs_new(conn, conn->target);
        if (!cs)
                goto fail;
 

diff --git a/src/session.c b/src/session.c
index 4fad934ceca44e0d12226f137a28260c7565623b..52d3a1fa17f2501deab1862e382d6c83b484cda8 100644 (file)
--- a/src/session.c
+++ b/src/session.c
@@ -144,7 +144,7 @@ int session_accept_fd(struct listener *l, int cfd, struct sockaddr_storage *addr
 
        ret = -1; /* assume unrecoverable error by default */
 
-       if (unlikely((cli_conn = conn_new()) == NULL))
+       if (unlikely((cli_conn = conn_new(&l->obj_type)) == NULL))
                goto out_close;
 
        if (!sockaddr_alloc(&cli_conn->src))
@@ -153,7 +153,6 @@ int session_accept_fd(struct listener *l, int cfd, struct sockaddr_storage *addr
        cli_conn->handle.fd = cfd;
        *cli_conn->src = *addr;
        cli_conn->flags |= CO_FL_ADDR_FROM_SET;
-       cli_conn->target = &l->obj_type;
        cli_conn->proxy_netns = l->netns;
 
        conn_prepare(cli_conn, l->proto, l->bind_conf->xprt);

diff --git a/src/tcpcheck.c b/src/tcpcheck.c
index 4e714fa352116ff17ff60a4ba1c25abec39a77f6..6f962cc6b61a564877386fc6fcc7cae85db76055 100644 (file)
--- a/src/tcpcheck.c
+++ b/src/tcpcheck.c
@@ -994,7 +994,7 @@ enum tcpcheck_eval_ret tcpcheck_eval_connect(struct check *check, struct tcpchec
         */
 
        /* 2- prepare new connection */
-       cs = cs_new(NULL);
+       cs = cs_new(NULL, (s ? &s->obj_type : &proxy->obj_type));
        if (!cs) {
                chunk_printf(&trash, "TCPCHK error allocating connection at step %d",
                             tcpcheck_get_step_id(check, rule));
@@ -1028,9 +1028,7 @@ enum tcpcheck_eval_ret tcpcheck_eval_connect(struct check *check, struct tcpchec
        check->wait_list.events = 0;
        if (s) {
                _HA_ATOMIC_ADD(&s->curr_used_conns, 1);
-               conn->target = &s->obj_type;
-       } else
-               conn->target = &proxy->obj_type;
+       }
 
        /* no client address */
        if (!sockaddr_alloc(&conn->dst)) {