MINOR: quic: Wrong traces after rework

TRACE_*() macros must take a quic_conn struct as first argument.

diff --git a/include/haproxy/quic_loss.h b/include/haproxy/quic_loss.h
index 441d478cb9d0efecd24e58dc9f3f6ce47f8f9d05..092046f12a28592142ac00caf4b05341419b1e77 100644 (file)
--- a/include/haproxy/quic_loss.h
+++ b/include/haproxy/quic_loss.h
@@ -47,9 +47,9 @@ static inline void quic_loss_init(struct quic_loss *ql)
  */
 static inline void quic_loss_srtt_update(struct quic_loss *ql,
                                          unsigned int rtt, unsigned int ack_delay,
-                                         struct quic_conn *conn)
+                                         struct quic_conn *qc)
 {
-       TRACE_PROTO("Loss info update", QUIC_EV_CONN_RTTUPDT, conn->conn, &rtt, &ack_delay, ql);
+       TRACE_PROTO("Loss info update", QUIC_EV_CONN_RTTUPDT, qc, &rtt, &ack_delay, ql);
        ql->latest_rtt = rtt;
        if (!ql->rtt_min) {
                /* No previous measurement. */
@@ -73,7 +73,7 @@ static inline void quic_loss_srtt_update(struct quic_loss *ql,
                /* 8*srtt = 7*srtt + rtt */
                ql->srtt += rtt - (ql->srtt >> 3);
        }
-       TRACE_PROTO("Loss info update", QUIC_EV_CONN_RTTUPDT, conn->conn,,, ql);
+       TRACE_PROTO("Loss info update", QUIC_EV_CONN_RTTUPDT, qc,,, ql);
 }
 
 /* Return 1 if a persitent congestion is observed for a list of
@@ -108,9 +108,9 @@ static inline struct quic_pktns *quic_loss_pktns(struct quic_conn *qc)
        struct quic_pktns *pktns;
 
        pktns = &qc->pktns[QUIC_TLS_PKTNS_INITIAL];
-       TRACE_PROTO("pktns", QUIC_EV_CONN_SPTO, qc->conn, pktns);
+       TRACE_PROTO("pktns", QUIC_EV_CONN_SPTO, qc, pktns);
        for (i = QUIC_TLS_PKTNS_HANDSHAKE; i < QUIC_TLS_PKTNS_MAX; i++) {
-               TRACE_PROTO("pktns", QUIC_EV_CONN_SPTO, qc->conn, &qc->pktns[i]);
+               TRACE_PROTO("pktns", QUIC_EV_CONN_SPTO, qc, &qc->pktns[i]);
                if (tick_isset(pktns->tx.loss_time) &&
                    qc->pktns[i].tx.loss_time < pktns->tx.loss_time)
                        pktns = &qc->pktns[i];
@@ -132,7 +132,7 @@ static inline struct quic_pktns *quic_pto_pktns(struct quic_conn *qc,
        struct quic_loss *ql = &qc->path->loss;
        struct quic_pktns *pktns;
 
-       TRACE_ENTER(QUIC_EV_CONN_SPTO, qc->conn);
+       TRACE_ENTER(QUIC_EV_CONN_SPTO, qc);
        duration =
                (ql->srtt >> 3) +
                (QUIC_MAX(ql->rtt_var, QUIC_TIMER_GRANULARITY) << ql->pto_count);
@@ -178,13 +178,13 @@ static inline struct quic_pktns *quic_pto_pktns(struct quic_conn *qc,
                        lpto = tmp_pto;
                        pktns = p;
                }
-               TRACE_PROTO("pktns", QUIC_EV_CONN_SPTO, qc->conn, p);
+               TRACE_PROTO("pktns", QUIC_EV_CONN_SPTO, qc, p);
        }
 
  out:
        if (pto)
                *pto = lpto;
-       TRACE_LEAVE(QUIC_EV_CONN_SPTO, qc->conn, pktns, &duration);
+       TRACE_LEAVE(QUIC_EV_CONN_SPTO, qc, pktns, &duration);
 
        return pktns;
 }

diff --git a/src/quic_cc_newreno.c b/src/quic_cc_newreno.c
index 7690c235c7756c3f70a04d0df177da4471d40faf..9a206601645cc0ab863ea50176ebd69816428066 100644 (file)
--- a/src/quic_cc_newreno.c
+++ b/src/quic_cc_newreno.c
@@ -44,7 +44,7 @@ static void quic_cc_nr_ss_cb(struct quic_cc *cc, struct quic_cc_event *ev)
 {
        struct quic_path *path;
 
-       TRACE_ENTER(QUIC_EV_CONN_CC, cc->qc->conn, ev);
+       TRACE_ENTER(QUIC_EV_CONN_CC, cc->qc, ev);
        path = container_of(cc, struct quic_path, cc);
        switch (ev->type) {
        case QUIC_CC_EVT_ACK:
@@ -72,7 +72,7 @@ static void quic_cc_nr_ss_cb(struct quic_cc *cc, struct quic_cc_event *ev)
                /* XXX TO DO XXX */
                break;
        }
-       TRACE_LEAVE(QUIC_EV_CONN_CC, cc->qc->conn,, cc);
+       TRACE_LEAVE(QUIC_EV_CONN_CC, cc->qc,, cc);
 }
 
 /* Congestion avoidance callback. */
@@ -80,7 +80,7 @@ static void quic_cc_nr_ca_cb(struct quic_cc *cc, struct quic_cc_event *ev)
 {
        struct quic_path *path;
 
-       TRACE_ENTER(QUIC_EV_CONN_CC, cc->qc->conn, ev);
+       TRACE_ENTER(QUIC_EV_CONN_CC, cc->qc, ev);
        path = container_of(cc, struct quic_path, cc);
        switch (ev->type) {
        case QUIC_CC_EVT_ACK:
@@ -121,7 +121,7 @@ static void quic_cc_nr_ca_cb(struct quic_cc *cc, struct quic_cc_event *ev)
        }
 
  out:
-       TRACE_LEAVE(QUIC_EV_CONN_CC, cc->qc->conn, NULL, cc);
+       TRACE_LEAVE(QUIC_EV_CONN_CC, cc->qc, NULL, cc);
 }
 
 static void quic_cc_nr_state_trace(struct buffer *buf, const struct quic_cc *cc)

diff --git a/src/quic_frame.c b/src/quic_frame.c
index ef9cefbf4bffa086ea0a9ba03e0bd0e3d01788ab..cd607ac3aefe1159a75b64caba218d91a6229055 100644 (file)
--- a/src/quic_frame.c
+++ b/src/quic_frame.c
@@ -271,7 +271,7 @@ static int quic_parse_ping_frame(struct quic_frame *frm, struct quic_conn *qc,
  * Returns 1 if succeeded (enough room in <buf> to encode the frame), 0 if not.
  */
 static int quic_build_ack_frame(unsigned char **buf, const unsigned char *end,
-                                struct quic_frame *frm, struct quic_conn *conn)
+                                struct quic_frame *frm, struct quic_conn *qc)
 {
        struct quic_tx_ack *tx_ack = &frm->tx_ack;
        struct eb64_node *ar, *prev_ar;
@@ -280,7 +280,7 @@ static int quic_build_ack_frame(unsigned char **buf, const unsigned char *end,
        ar = eb64_last(&tx_ack->arngs->root);
        ar_node = eb64_entry(&ar->node, struct quic_arng_node, first);
        TRACE_PROTO("ack range", QUIC_EV_CONN_PRSAFRM,
-                   conn->conn,, &ar_node->last, &ar_node->first.key);
+                   qc,, &ar_node->last, &ar_node->first.key);
        if (!quic_enc_int(buf, end, ar_node->last) ||
            !quic_enc_int(buf, end, tx_ack->ack_delay) ||
            !quic_enc_int(buf, end, tx_ack->arngs->sz - 1) ||
@@ -289,7 +289,7 @@ static int quic_build_ack_frame(unsigned char **buf, const unsigned char *end,
 
        while ((prev_ar = eb64_prev(ar))) {
                prev_ar_node = eb64_entry(&prev_ar->node, struct quic_arng_node, first);
-               TRACE_PROTO("ack range", QUIC_EV_CONN_PRSAFRM, conn->conn,,
+               TRACE_PROTO("ack range", QUIC_EV_CONN_PRSAFRM, qc,,
                            &prev_ar_node->last, &prev_ar_node->first.key);
                if (!quic_enc_int(buf, end, ar_node->first.key - prev_ar_node->last - 2) ||
                    !quic_enc_int(buf, end, prev_ar_node->last - prev_ar_node->first.key))
@@ -1084,30 +1084,30 @@ const struct quic_frame_parser quic_frame_parsers[] = {
  */
 int qc_parse_frm(struct quic_frame *frm, struct quic_rx_packet *pkt,
                  const unsigned char **buf, const unsigned char *end,
-                 struct quic_conn *conn)
+                 struct quic_conn *qc)
 {
        const struct quic_frame_parser *parser;
 
        if (end <= *buf) {
-               TRACE_DEVEL("wrong frame", QUIC_EV_CONN_PRSFRM, conn->conn);
+               TRACE_DEVEL("wrong frame", QUIC_EV_CONN_PRSFRM, qc);
                return 0;
        }
 
        frm->type = *(*buf)++;
        if (frm->type > QUIC_FT_MAX) {
-               TRACE_DEVEL("wrong frame type", QUIC_EV_CONN_PRSFRM, conn->conn, frm);
+               TRACE_DEVEL("wrong frame type", QUIC_EV_CONN_PRSFRM, qc, frm);
                return 0;
        }
 
        parser = &quic_frame_parsers[frm->type];
        if (!(parser->mask & (1 << pkt->type))) {
-               TRACE_DEVEL("unauthorized frame", QUIC_EV_CONN_PRSFRM, conn->conn, frm);
+               TRACE_DEVEL("unauthorized frame", QUIC_EV_CONN_PRSFRM, qc, frm);
                return 0;
        }
 
-       TRACE_PROTO("frame", QUIC_EV_CONN_PRSFRM, conn->conn, frm);
-       if (!parser->func(frm, conn, buf, end)) {
-               TRACE_DEVEL("parsing error", QUIC_EV_CONN_PRSFRM, conn->conn, frm);
+       TRACE_PROTO("frame", QUIC_EV_CONN_PRSFRM, qc, frm);
+       if (!parser->func(frm, qc, buf, end)) {
+               TRACE_DEVEL("parsing error", QUIC_EV_CONN_PRSFRM, qc, frm);
                return 0;
        }
 
@@ -1121,26 +1121,26 @@ int qc_parse_frm(struct quic_frame *frm, struct quic_rx_packet *pkt,
  */
 int qc_build_frm(unsigned char **buf, const unsigned char *end,
                  struct quic_frame *frm, struct quic_tx_packet *pkt,
-                 struct quic_conn *conn)
+                 struct quic_conn *qc)
 {
        const struct quic_frame_builder *builder;
 
        builder = &quic_frame_builders[frm->type];
        if (!(builder->mask & (1 << pkt->type))) {
                /* XXX This it a bug to send an unauthorized frame with such a packet type XXX */
-               TRACE_DEVEL("frame skipped", QUIC_EV_CONN_BFRM, conn->conn, frm);
+               TRACE_DEVEL("frame skipped", QUIC_EV_CONN_BFRM, qc, frm);
                BUG_ON(!(builder->mask & (1 << pkt->type)));
        }
 
        if (end <= *buf) {
-               TRACE_DEVEL("not enough room", QUIC_EV_CONN_BFRM, conn->conn, frm);
+               TRACE_DEVEL("not enough room", QUIC_EV_CONN_BFRM, qc, frm);
                return 0;
        }
 
-       TRACE_PROTO("frame", QUIC_EV_CONN_BFRM, conn->conn, frm);
+       TRACE_PROTO("frame", QUIC_EV_CONN_BFRM, qc, frm);
        *(*buf)++ = frm->type;
-       if (!quic_frame_builders[frm->type].func(buf, end, frm, conn)) {
-               TRACE_DEVEL("frame building error", QUIC_EV_CONN_BFRM, conn->conn, frm);
+       if (!quic_frame_builders[frm->type].func(buf, end, frm, qc)) {
+               TRACE_DEVEL("frame building error", QUIC_EV_CONN_BFRM, qc, frm);
                return 0;
        }
 

diff --git a/src/xprt_quic.c b/src/xprt_quic.c
index 9d15c740da438acfc3d5ee3932547a778a069eb8..b25b37759e946a75cccc01508f1063afa576da74 100644 (file)
--- a/src/xprt_quic.c
+++ b/src/xprt_quic.c
@@ -1827,7 +1827,7 @@ static inline int qc_provide_cdata(struct quic_enc_level *el,
 
        if (SSL_provide_quic_data(ctx->ssl, el->level, data, len) != 1) {
                TRACE_PROTO("SSL_provide_quic_data() error",
-                           QUIC_EV_CONN_SSLDATA, ctx->conn, pkt, cf, ctx->ssl);
+                           QUIC_EV_CONN_SSLDATA, qc, pkt, cf, ctx->ssl);
                goto err;
        }
 
@@ -2050,7 +2050,7 @@ static int qc_handle_bidi_strm_frm(struct quic_rx_packet *pkt,
 
        total += qc_treat_rx_strm_frms(strm);
        if (total && qc->qcc->app_ops->decode_qcs(strm, strm_frm->fin, qc->qcc->ctx) < 0) {
-               TRACE_PROTO("Decoding error", QUIC_EV_CONN_PSTRM);
+               TRACE_PROTO("Decoding error", QUIC_EV_CONN_PSTRM, qc);
                return 0;
        }
 
@@ -2323,7 +2323,7 @@ static int qc_parse_pkt_frms(struct quic_rx_packet *pkt, struct ssl_sock_ctx *ct
 
            if (state >= QUIC_HS_ST_SERVER_INITIAL) {
                    quic_tls_discard_keys(&qc->els[QUIC_TLS_ENC_LEVEL_INITIAL]);
-                   TRACE_PROTO("discarding Initial pktns", QUIC_EV_CONN_PRSHPKT, ctx->conn);
+                   TRACE_PROTO("discarding Initial pktns", QUIC_EV_CONN_PRSHPKT, qc);
                    quic_pktns_discard(qc->els[QUIC_TLS_ENC_LEVEL_INITIAL].pktns, qc);
                    qc_set_timer(ctx->qc);
                    if (state < QUIC_HS_ST_SERVER_HANDSHAKE)
@@ -5103,10 +5103,10 @@ static int qc_conn_init(struct connection *conn, void **xprt_ctx)
                        st = HA_ATOMIC_LOAD(&qc->state);
                        ssl_err = SSL_get_error(ctx->ssl, ssl_err);
                        if (ssl_err == SSL_ERROR_WANT_READ || ssl_err == SSL_ERROR_WANT_WRITE) {
-                               TRACE_PROTO("SSL handshake", QUIC_EV_CONN_HDSHK, ctx->conn, &st, &ssl_err);
+                               TRACE_PROTO("SSL handshake", QUIC_EV_CONN_HDSHK, qc, &st, &ssl_err);
                        }
                        else {
-                               TRACE_DEVEL("SSL handshake error", QUIC_EV_CONN_HDSHK, ctx->conn, &st, &ssl_err);
+                               TRACE_DEVEL("SSL handshake error", QUIC_EV_CONN_HDSHK, qc, &st, &ssl_err);
                                goto err;
                        }
                }
@@ -5137,7 +5137,7 @@ static int qc_conn_init(struct connection *conn, void **xprt_ctx)
 
  out:
        HA_ATOMIC_STORE(&qc->xprt_ctx, ctx);
-       TRACE_LEAVE(QUIC_EV_CONN_NEW, conn);
+       TRACE_LEAVE(QUIC_EV_CONN_NEW, qc);
 
        return 0;
 
@@ -5157,7 +5157,7 @@ static int qc_xprt_start(struct connection *conn, void *ctx)
 
        qc = conn->qc;
        if (!quic_conn_init_timer(qc)) {
-               TRACE_PROTO("Non initialized timer", QUIC_EV_CONN_LPKT, conn);
+               TRACE_PROTO("Non initialized timer", QUIC_EV_CONN_LPKT, qc);
                return 0;
        }