BUILD: traces: don't pass an empty argument for missing ones

It initially looked appealing to be able to call traces with ",,," for
unused arguments, but tcc doesn't like empty macro arguments, and quite
frankly, adding a zero between the few remaining ones is no big deal.
Let's do so now.

diff --git a/src/mux_fcgi.c b/src/mux_fcgi.c
index ab9ddf095ddaca2aceef02411af27b552353beeb..7be05b6e863e6db5c9149417ad872573bae88d6f 100644 (file)
--- a/src/mux_fcgi.c
+++ b/src/mux_fcgi.c
@@ -1540,7 +1540,7 @@ static int fcgi_conn_send_get_values(struct fcgi_conn *fconn)
                goto full;
 
        /* update the record's size now */
-       TRACE_PROTO("FCGI GET_VALUES record xferred", FCGI_EV_TX_RECORD|FCGI_EV_TX_GETVAL, fconn->conn,,, (size_t[]){outbuf.data-8});
+       TRACE_PROTO("FCGI GET_VALUES record xferred", FCGI_EV_TX_RECORD|FCGI_EV_TX_GETVAL, fconn->conn, 0, 0, (size_t[]){outbuf.data-8});
        fcgi_set_record_size(outbuf.area, outbuf.data - 8);
        b_add(mbuf, outbuf.data);
        ret = 1;
@@ -1615,17 +1615,17 @@ static int fcgi_conn_handle_values_result(struct fcgi_conn *fconn)
 
                if (isteqi(p.n, ist("FCGI_MPXS_CONNS"))) {
                        if (isteq(p.v, ist("1"))) {
-                               TRACE_STATE("set mpxs param", FCGI_EV_RX_RECORD|FCGI_EV_RX_GETVAL, fconn->conn,,, (size_t[]){1});
+                               TRACE_STATE("set mpxs param", FCGI_EV_RX_RECORD|FCGI_EV_RX_GETVAL, fconn->conn, 0, 0, (size_t[]){1});
                                fconn->flags |= FCGI_CF_MPXS_CONNS;
                        }
                        else {
-                               TRACE_STATE("set mpxs param", FCGI_EV_RX_RECORD|FCGI_EV_RX_GETVAL, fconn->conn,,, (size_t[]){0});
+                               TRACE_STATE("set mpxs param", FCGI_EV_RX_RECORD|FCGI_EV_RX_GETVAL, fconn->conn, 0, 0, (size_t[]){0});
                                fconn->flags &= ~FCGI_CF_MPXS_CONNS;
                        }
                }
                else if (isteqi(p.n, ist("FCGI_MAX_REQS"))) {
                        fconn->streams_limit = strl2ui(p.v.ptr, p.v.len);
-                       TRACE_STATE("set streams_limit", FCGI_EV_RX_RECORD|FCGI_EV_RX_GETVAL, fconn->conn,,, (size_t[]){fconn->streams_limit});
+                       TRACE_STATE("set streams_limit", FCGI_EV_RX_RECORD|FCGI_EV_RX_GETVAL, fconn->conn, 0, 0, (size_t[]){fconn->streams_limit});
                }
                /*
                 * Ignore all other params
@@ -1646,7 +1646,7 @@ static int fcgi_conn_handle_values_result(struct fcgi_conn *fconn)
        if (offset != fconn->drl)
                goto fail;
 
-       TRACE_PROTO("FCGI GET_VALUES_RESULT record rcvd", FCGI_EV_RX_RECORD|FCGI_EV_RX_GETVAL, fconn->conn,,, (size_t[]){fconn->drl});
+       TRACE_PROTO("FCGI GET_VALUES_RESULT record rcvd", FCGI_EV_RX_RECORD|FCGI_EV_RX_GETVAL, fconn->conn, 0, 0, (size_t[]){fconn->drl});
        b_del(&fconn->dbuf, fconn->drl + fconn->drp);
        fconn->drl = 0;
        fconn->drp = 0;
@@ -1736,7 +1736,7 @@ static int fcgi_strm_send_begin_request(struct fcgi_conn *fconn, struct fcgi_str
                goto full;
 
        /* commit the record */
-       TRACE_PROTO("FCGI BEGIN_REQUEST record xferred", FCGI_EV_TX_RECORD|FCGI_EV_TX_BEGREQ, fconn->conn, fstrm,, (size_t[]){0});
+       TRACE_PROTO("FCGI BEGIN_REQUEST record xferred", FCGI_EV_TX_RECORD|FCGI_EV_TX_BEGREQ, fconn->conn, fstrm, 0, (size_t[]){0});
        b_add(mbuf, outbuf.data);
        fstrm->flags |= FCGI_SF_BEGIN_SENT;
        fstrm->state = FCGI_SS_OPEN;
@@ -1824,7 +1824,7 @@ static int fcgi_strm_send_empty_params(struct fcgi_conn *fconn, struct fcgi_strm
        TRACE_POINT(FCGI_EV_TX_RECORD|FCGI_EV_TX_PARAMS, fconn->conn, fstrm);
        ret = fcgi_strm_send_empty_record(fconn, fstrm, FCGI_PARAMS);
        if (ret)
-               TRACE_PROTO("FCGI PARAMS record xferred", FCGI_EV_TX_RECORD|FCGI_EV_TX_STDIN, fconn->conn, fstrm,, (size_t[]){0});
+               TRACE_PROTO("FCGI PARAMS record xferred", FCGI_EV_TX_RECORD|FCGI_EV_TX_STDIN, fconn->conn, fstrm, 0, (size_t[]){0});
        return ret;
 }
 
@@ -1839,7 +1839,7 @@ static int fcgi_strm_send_empty_stdin(struct fcgi_conn *fconn, struct fcgi_strm
        ret = fcgi_strm_send_empty_record(fconn, fstrm, FCGI_STDIN);
        if (ret) {
                fstrm->flags |= FCGI_SF_ES_SENT;
-               TRACE_PROTO("FCGI STDIN record xferred", FCGI_EV_TX_RECORD|FCGI_EV_TX_STDIN, fconn->conn, fstrm,, (size_t[]){0});
+               TRACE_PROTO("FCGI STDIN record xferred", FCGI_EV_TX_RECORD|FCGI_EV_TX_STDIN, fconn->conn, fstrm, 0, (size_t[]){0});
                TRACE_USER("FCGI request fully xferred", FCGI_EV_TX_RECORD|FCGI_EV_TX_STDIN|FCGI_EV_TX_EOI, fconn->conn, fstrm);
                TRACE_STATE("stdin data fully sent", FCGI_EV_TX_RECORD|FCGI_EV_TX_STDIN|FCGI_EV_TX_EOI, fconn->conn, fstrm);
        }
@@ -1857,7 +1857,7 @@ static int fcgi_strm_send_abort(struct fcgi_conn *fconn, struct fcgi_strm *fstrm
        ret = fcgi_strm_send_empty_record(fconn, fstrm, FCGI_ABORT_REQUEST);
        if (ret) {
                fstrm->flags |= FCGI_SF_ABRT_SENT;
-               TRACE_PROTO("FCGI ABORT record xferred", FCGI_EV_TX_RECORD|FCGI_EV_TX_ABORT, fconn->conn, fstrm,, (size_t[]){0});
+               TRACE_PROTO("FCGI ABORT record xferred", FCGI_EV_TX_RECORD|FCGI_EV_TX_ABORT, fconn->conn, fstrm, 0, (size_t[]){0});
                TRACE_USER("FCGI request aborted", FCGI_EV_TX_RECORD|FCGI_EV_TX_ABORT, fconn->conn, fstrm);
                TRACE_STATE("abort sent", FCGI_EV_TX_RECORD|FCGI_EV_TX_ABORT, fconn->conn, fstrm);
        }
@@ -2053,7 +2053,7 @@ static size_t fcgi_strm_send_params(struct fcgi_conn *fconn, struct fcgi_strm *f
                goto error;
 
        /* update the record's size */
-       TRACE_PROTO("FCGI PARAMS record xferred", FCGI_EV_TX_RECORD|FCGI_EV_TX_PARAMS, fconn->conn, fstrm,, (size_t[]){outbuf.data - 8});
+       TRACE_PROTO("FCGI PARAMS record xferred", FCGI_EV_TX_RECORD|FCGI_EV_TX_PARAMS, fconn->conn, fstrm, 0, (size_t[]){outbuf.data - 8});
        fcgi_set_record_size(outbuf.area, outbuf.data - 8);
        b_add(mbuf, outbuf.data);
 
@@ -2231,7 +2231,7 @@ static size_t fcgi_strm_send_stdin(struct fcgi_conn *fconn, struct fcgi_strm *fs
 
   done:
        /* update the record's size */
-       TRACE_PROTO("FCGI STDIN record xferred", FCGI_EV_TX_RECORD|FCGI_EV_TX_STDIN, fconn->conn, fstrm,, (size_t[]){outbuf.data - 8});
+       TRACE_PROTO("FCGI STDIN record xferred", FCGI_EV_TX_RECORD|FCGI_EV_TX_STDIN, fconn->conn, fstrm, 0, (size_t[]){outbuf.data - 8});
        fcgi_set_record_size(outbuf.area, outbuf.data - 8);
        b_add(mbuf, outbuf.data);
 
@@ -2287,8 +2287,8 @@ static int fcgi_strm_handle_stdout(struct fcgi_conn *fconn, struct fcgi_strm *fs
        if (!ret)
                goto fail;
        fconn->drl -= ret;
-       TRACE_DATA("move some data to fstrm rxbuf", FCGI_EV_RX_RECORD|FCGI_EV_RX_STDOUT, fconn->conn, fstrm,, (size_t[]){ret});
-       TRACE_PROTO("FCGI STDOUT record rcvd", FCGI_EV_RX_RECORD|FCGI_EV_RX_STDOUT, fconn->conn, fstrm,, (size_t[]){ret});
+       TRACE_DATA("move some data to fstrm rxbuf", FCGI_EV_RX_RECORD|FCGI_EV_RX_STDOUT, fconn->conn, fstrm, 0, (size_t[]){ret});
+       TRACE_PROTO("FCGI STDOUT record rcvd", FCGI_EV_RX_RECORD|FCGI_EV_RX_STDOUT, fconn->conn, fstrm, 0, (size_t[]){ret});
 
        if (!buf_room_for_htx_data(&fstrm->rxbuf)) {
                fconn->flags |= FCGI_CF_DEM_SFULL;
@@ -2341,7 +2341,7 @@ static int fcgi_strm_handle_empty_stdout(struct fcgi_conn *fconn, struct fcgi_st
        }
        fconn->state = FCGI_CS_RECORD_H;
        fstrm->flags |= FCGI_SF_ES_RCVD;
-       TRACE_PROTO("FCGI STDOUT record rcvd", FCGI_EV_RX_RECORD|FCGI_EV_RX_STDOUT, fconn->conn, fstrm,, (size_t[]){0});
+       TRACE_PROTO("FCGI STDOUT record rcvd", FCGI_EV_RX_RECORD|FCGI_EV_RX_STDOUT, fconn->conn, fstrm, 0, (size_t[]){0});
        TRACE_STATE("stdout data fully send, switching to RECORD_H", FCGI_EV_RX_RECORD|FCGI_EV_RX_FHDR|FCGI_EV_RX_EOI, fconn->conn, fstrm);
        TRACE_LEAVE(FCGI_EV_RX_RECORD|FCGI_EV_RX_STDOUT, fconn->conn, fstrm);
        return 1;
@@ -2373,7 +2373,7 @@ static int fcgi_strm_handle_stderr(struct fcgi_conn *fconn, struct fcgi_strm *fs
        if (!ret)
                goto fail;
        fconn->drl -= ret;
-       TRACE_PROTO("FCGI STDERR record rcvd", FCGI_EV_RX_RECORD|FCGI_EV_RX_STDERR, fconn->conn, fstrm,, (size_t[]){ret});
+       TRACE_PROTO("FCGI STDERR record rcvd", FCGI_EV_RX_RECORD|FCGI_EV_RX_STDERR, fconn->conn, fstrm, 0, (size_t[]){ret});
 
        trash.area[ret]   = '\n';
        trash.area[ret+1] = '\0';
@@ -2441,7 +2441,7 @@ static int fcgi_strm_handle_end_request(struct fcgi_conn *fconn, struct fcgi_str
 
        fstrm->flags |= FCGI_SF_ES_RCVD;
        TRACE_STATE("end of script reported", FCGI_EV_RX_RECORD|FCGI_EV_RX_ENDREQ|FCGI_EV_RX_EOI, fconn->conn, fstrm);
-       TRACE_PROTO("FCGI END_REQUEST record rcvd", FCGI_EV_RX_RECORD|FCGI_EV_RX_ENDREQ, fconn->conn, fstrm,, (size_t[]){fconn->drl});
+       TRACE_PROTO("FCGI END_REQUEST record rcvd", FCGI_EV_RX_RECORD|FCGI_EV_RX_ENDREQ, fconn->conn, fstrm, 0, (size_t[]){fconn->drl});
        fstrm->proto_status = endreq.errcode;
        fcgi_strm_close(fstrm);
 
@@ -2585,7 +2585,7 @@ static void fcgi_process_demux(struct fcgi_conn *fconn)
                                fconn->drl += fconn->drp;
                                fconn->drp = 0;
                                ret = MIN(b_data(&fconn->dbuf), fconn->drl);
-                               TRACE_PROTO("receiving FCGI ignored record", FCGI_EV_RX_RECORD, fconn->conn, fstrm,, (size_t[]){ret});
+                               TRACE_PROTO("receiving FCGI ignored record", FCGI_EV_RX_RECORD, fconn->conn, fstrm, 0, (size_t[]){ret});
                                TRACE_STATE("switching to RECORD_P", FCGI_EV_RX_RECORD, fconn->conn, fstrm);
                                b_del(&fconn->dbuf, ret);
                                fconn->drl -= ret;
@@ -2750,7 +2750,7 @@ static int fcgi_recv(struct fcgi_conn *fconn)
                conn->xprt->subscribe(conn, conn->xprt_ctx, SUB_RETRY_RECV, &fconn->wait_event);
        }
        else
-               TRACE_DATA("recv data", FCGI_EV_FCONN_RECV, conn,,, (size_t[]){ret});
+               TRACE_DATA("recv data", FCGI_EV_FCONN_RECV, conn, 0, 0, (size_t[]){ret});
 
        if (!b_data(buf)) {
                fcgi_release_buf(fconn, &fconn->dbuf);
@@ -2838,7 +2838,7 @@ static int fcgi_send(struct fcgi_conn *fconn)
                                        break;
                                }
                                sent = 1;
-                               TRACE_DATA("send data", FCGI_EV_FCONN_SEND, conn,,, (size_t[]){ret});
+                               TRACE_DATA("send data", FCGI_EV_FCONN_SEND, conn, 0, 0, (size_t[]){ret});
                                b_del(buf, ret);
                                if (b_data(buf)) {
                                        done = 1;
@@ -3236,7 +3236,7 @@ static size_t fcgi_strm_parse_headers(struct fcgi_strm *fstrm, struct h1m *h1m,
 {
        int ret;
 
-       TRACE_ENTER(FCGI_EV_RSP_DATA|FCGI_EV_RSP_HDRS, fstrm->fconn->conn, fstrm,, (size_t[]){max});
+       TRACE_ENTER(FCGI_EV_RSP_DATA|FCGI_EV_RSP_HDRS, fstrm->fconn->conn, fstrm, 0, (size_t[]){max});
        ret = h1_parse_msg_hdrs(h1m, NULL, htx, buf, *ofs, max);
        if (!ret) {
                TRACE_DEVEL("leaving on missing data or error", FCGI_EV_RSP_DATA|FCGI_EV_RSP_HDRS, fstrm->fconn->conn, fstrm);
@@ -3250,7 +3250,7 @@ static size_t fcgi_strm_parse_headers(struct fcgi_strm *fstrm, struct h1m *h1m,
 
        *ofs += ret;
   end:
-       TRACE_LEAVE(FCGI_EV_RSP_DATA|FCGI_EV_RSP_HDRS, fstrm->fconn->conn, fstrm,, (size_t[]){ret});
+       TRACE_LEAVE(FCGI_EV_RSP_DATA|FCGI_EV_RSP_HDRS, fstrm->fconn->conn, fstrm, 0, (size_t[]){ret});
        return ret;
 
 }
@@ -3260,7 +3260,7 @@ static size_t fcgi_strm_parse_data(struct fcgi_strm *fstrm, struct h1m *h1m, str
 {
        int ret;
 
-       TRACE_ENTER(FCGI_EV_RSP_DATA|FCGI_EV_RSP_BODY, fstrm->fconn->conn, fstrm,, (size_t[]){max});
+       TRACE_ENTER(FCGI_EV_RSP_DATA|FCGI_EV_RSP_BODY, fstrm->fconn->conn, fstrm, 0, (size_t[]){max});
        ret = h1_parse_msg_data(h1m, htx, buf, *ofs, max, htxbuf);
        if (!ret) {
                TRACE_DEVEL("leaving on missing data or error", FCGI_EV_RSP_DATA|FCGI_EV_RSP_BODY, fstrm->fconn->conn, fstrm);
@@ -3273,7 +3273,7 @@ static size_t fcgi_strm_parse_data(struct fcgi_strm *fstrm, struct h1m *h1m, str
        }
        *ofs += ret;
   end:
-       TRACE_LEAVE(FCGI_EV_RSP_DATA|FCGI_EV_RSP_BODY, fstrm->fconn->conn, fstrm,, (size_t[]){ret});
+       TRACE_LEAVE(FCGI_EV_RSP_DATA|FCGI_EV_RSP_BODY, fstrm->fconn->conn, fstrm, 0, (size_t[]){ret});
        return ret;
 }
 
@@ -3282,7 +3282,7 @@ static size_t fcgi_strm_parse_trailers(struct fcgi_strm *fstrm, struct h1m *h1m,
 {
        int ret;
 
-       TRACE_ENTER(FCGI_EV_RSP_DATA|FCGI_EV_RSP_TLRS, fstrm->fconn->conn, fstrm,, (size_t[]){max});
+       TRACE_ENTER(FCGI_EV_RSP_DATA|FCGI_EV_RSP_TLRS, fstrm->fconn->conn, fstrm, 0, (size_t[]){max});
        ret = h1_parse_msg_tlrs(h1m, htx, buf, *ofs, max);
        if (!ret) {
                TRACE_DEVEL("leaving on missing data or error", FCGI_EV_RSP_DATA|FCGI_EV_RSP_TLRS, fstrm->fconn->conn, fstrm);
@@ -3295,7 +3295,7 @@ static size_t fcgi_strm_parse_trailers(struct fcgi_strm *fstrm, struct h1m *h1m,
        }
        *ofs += ret;
   end:
-       TRACE_LEAVE(FCGI_EV_RSP_DATA|FCGI_EV_RSP_TLRS, fstrm->fconn->conn, fstrm,, (size_t[]){ret});
+       TRACE_LEAVE(FCGI_EV_RSP_DATA|FCGI_EV_RSP_TLRS, fstrm->fconn->conn, fstrm, 0, (size_t[]){ret});
        return ret;
 }
 
@@ -3304,7 +3304,7 @@ static size_t fcgi_strm_add_eom(struct fcgi_strm *fstrm, struct h1m *h1m, struct
 {
        int ret;
 
-       TRACE_ENTER(FCGI_EV_RSP_DATA|FCGI_EV_RSP_EOM, fstrm->fconn->conn, fstrm,, (size_t[]){max});
+       TRACE_ENTER(FCGI_EV_RSP_DATA|FCGI_EV_RSP_EOM, fstrm->fconn->conn, fstrm, 0, (size_t[]){max});
        ret = h1_parse_msg_eom(h1m, htx, max);
        if (!ret) {
                TRACE_DEVEL("leaving on missing data or error", FCGI_EV_RSP_DATA|FCGI_EV_RSP_EOM, fstrm->fconn->conn, fstrm);
@@ -3317,7 +3317,7 @@ static size_t fcgi_strm_add_eom(struct fcgi_strm *fstrm, struct h1m *h1m, struct
        }
        fstrm->flags |= FCGI_SF_H1_PARSING_DONE;
   end:
-       TRACE_LEAVE(FCGI_EV_RSP_DATA|FCGI_EV_RSP_EOM, fstrm->fconn->conn, fstrm,, (size_t[]){ret});
+       TRACE_LEAVE(FCGI_EV_RSP_DATA|FCGI_EV_RSP_EOM, fstrm->fconn->conn, fstrm, 0, (size_t[]){ret});
        return ret;
 }
 
@@ -3887,7 +3887,7 @@ static size_t fcgi_snd_buf(struct conn_stream *cs, struct buffer *buf, size_t co
        struct htx_blk *blk;
        uint32_t bsize;
 
-       TRACE_ENTER(FCGI_EV_STRM_SEND, fconn->conn, fstrm,, (size_t[]){count});
+       TRACE_ENTER(FCGI_EV_STRM_SEND, fconn->conn, fstrm, 0, (size_t[]){count});
 
        /* If we were not just woken because we wanted to send but couldn't,
         * and there's somebody else that is waiting to send, do nothing,

diff --git a/src/mux_h1.c b/src/mux_h1.c
index 9e984904356b95f544b46fe92b36adfe6c23744f..5d2b7702346f1c7b1ddb2e0dfd04a57e6fe7005f 100644 (file)
--- a/src/mux_h1.c
+++ b/src/mux_h1.c
@@ -1210,7 +1210,7 @@ static size_t h1_process_headers(struct h1s *h1s, struct h1m *h1m, struct htx *h
        union h1_sl h1sl;
        int ret = 0;
 
-       TRACE_ENTER(H1_EV_RX_DATA|H1_EV_RX_HDRS, h1s->h1c->conn, h1s,, (size_t[]){max});
+       TRACE_ENTER(H1_EV_RX_DATA|H1_EV_RX_HDRS, h1s->h1c->conn, h1s, 0, (size_t[]){max});
 
        if (!(h1s->h1c->px->options2 & PR_O2_NO_H2_UPGRADE) && /* H2 upgrade supported by the proxy */
            !(h1s->flags & H1S_F_NOT_FIRST) &&                 /* It is the first transaction */
@@ -1270,7 +1270,7 @@ static size_t h1_process_headers(struct h1s *h1s, struct h1m *h1m, struct htx *h
        *ofs += ret;
 
   end:
-       TRACE_LEAVE(H1_EV_RX_DATA|H1_EV_RX_HDRS, h1s->h1c->conn, h1s,, (size_t[]){ret});
+       TRACE_LEAVE(H1_EV_RX_DATA|H1_EV_RX_HDRS, h1s->h1c->conn, h1s, 0, (size_t[]){ret});
        return ret;
 
   h2c_upgrade:
@@ -1292,7 +1292,7 @@ static size_t h1_process_data(struct h1s *h1s, struct h1m *h1m, struct htx **htx
 {
        int ret;
 
-       TRACE_ENTER(H1_EV_RX_DATA|H1_EV_RX_BODY, h1s->h1c->conn, h1s,, (size_t[]){max});
+       TRACE_ENTER(H1_EV_RX_DATA|H1_EV_RX_BODY, h1s->h1c->conn, h1s, 0, (size_t[]){max});
        ret = h1_parse_msg_data(h1m, htx, buf, *ofs, max, htxbuf);
        if (!ret) {
                TRACE_DEVEL("leaving on missing data or error", H1_EV_RX_DATA|H1_EV_RX_BODY, h1s->h1c->conn, h1s);
@@ -1325,7 +1325,7 @@ static size_t h1_process_data(struct h1s *h1s, struct h1m *h1m, struct htx **htx
        *ofs += ret;
 
   end:
-       TRACE_LEAVE(H1_EV_RX_DATA|H1_EV_RX_BODY, h1s->h1c->conn, h1s,, (size_t[]){ret});
+       TRACE_LEAVE(H1_EV_RX_DATA|H1_EV_RX_BODY, h1s->h1c->conn, h1s, 0, (size_t[]){ret});
        return ret;
 }
 
@@ -1340,7 +1340,7 @@ static size_t h1_process_trailers(struct h1s *h1s, struct h1m *h1m, struct htx *
 {
        int ret;
 
-       TRACE_ENTER(H1_EV_RX_DATA|H1_EV_RX_TLRS, h1s->h1c->conn, h1s,, (size_t[]){max});
+       TRACE_ENTER(H1_EV_RX_DATA|H1_EV_RX_TLRS, h1s->h1c->conn, h1s, 0, (size_t[]){max});
        ret = h1_parse_msg_tlrs(h1m, htx, buf, *ofs, max);
        if (!ret) {
                TRACE_DEVEL("leaving on missing data or error", H1_EV_RX_DATA|H1_EV_RX_BODY, h1s->h1c->conn, h1s);
@@ -1363,7 +1363,7 @@ static size_t h1_process_trailers(struct h1s *h1s, struct h1m *h1m, struct htx *
        *ofs += ret;
 
   end:
-       TRACE_LEAVE(H1_EV_RX_DATA|H1_EV_RX_TLRS, h1s->h1c->conn, h1s,, (size_t[]){ret});
+       TRACE_LEAVE(H1_EV_RX_DATA|H1_EV_RX_TLRS, h1s->h1c->conn, h1s, 0, (size_t[]){ret});
        return ret;
 }
 
@@ -1377,7 +1377,7 @@ static size_t h1_process_eom(struct h1s *h1s, struct h1m *h1m, struct htx *htx,
 {
        int ret;
 
-       TRACE_ENTER(H1_EV_RX_DATA|H1_EV_RX_EOI, h1s->h1c->conn, h1s,, (size_t[]){max});
+       TRACE_ENTER(H1_EV_RX_DATA|H1_EV_RX_EOI, h1s->h1c->conn, h1s, 0, (size_t[]){max});
        ret = h1_parse_msg_eom(h1m, htx, max);
        if (!ret) {
                TRACE_DEVEL("leaving on missing data or error", H1_EV_RX_DATA|H1_EV_RX_EOI, h1s->h1c->conn, h1s);
@@ -1400,7 +1400,7 @@ static size_t h1_process_eom(struct h1s *h1s, struct h1m *h1m, struct htx *htx,
        h1s->flags |= H1S_F_PARSING_DONE;
        h1s->cs->flags |= CS_FL_EOI;
   end:
-       TRACE_LEAVE(H1_EV_RX_DATA|H1_EV_RX_EOI, h1s->h1c->conn, h1s,, (size_t[]){ret});
+       TRACE_LEAVE(H1_EV_RX_DATA|H1_EV_RX_EOI, h1s->h1c->conn, h1s, 0, (size_t[]){ret});
        return ret;
 }
 
@@ -1637,10 +1637,10 @@ static size_t h1_process_output(struct h1c *h1c, struct buffer *buf, size_t coun
                        total += count;
                        if (h1m->state == H1_MSG_DATA)
                                TRACE_PROTO((!(h1m->flags & H1_MF_RESP) ? "H1 request payload data xferred" : "H1 response payload data xferred"),
-                                           H1_EV_TX_DATA|H1_EV_TX_BODY, h1c->conn, h1s,, (size_t[]){count});
+                                           H1_EV_TX_DATA|H1_EV_TX_BODY, h1c->conn, h1s, 0, (size_t[]){count});
                        else
                                TRACE_PROTO((!(h1m->flags & H1_MF_RESP) ? "H1 request tunneled data xferred" : "H1 response tunneled data xferred"),
-                                           H1_EV_TX_DATA|H1_EV_TX_BODY, h1c->conn, h1s,, (size_t[]){count});
+                                           H1_EV_TX_DATA|H1_EV_TX_BODY, h1c->conn, h1s, 0, (size_t[]){count});
                        goto out;
                }
                tmp.area = h1c->obuf.area + h1c->obuf.head;
@@ -1888,10 +1888,10 @@ static size_t h1_process_output(struct h1c *h1c, struct buffer *buf, size_t coun
 
                                if (h1m->state == H1_MSG_DATA)
                                        TRACE_PROTO((!(h1m->flags & H1_MF_RESP) ? "H1 request payload data xferred" : "H1 response payload data xferred"),
-                                                   H1_EV_TX_DATA|H1_EV_TX_BODY, h1c->conn, h1s,, (size_t[]){v.len});
+                                                   H1_EV_TX_DATA|H1_EV_TX_BODY, h1c->conn, h1s, 0, (size_t[]){v.len});
                                else
                                        TRACE_PROTO((!(h1m->flags & H1_MF_RESP) ? "H1 request tunneled data xferred" : "H1 response tunneled data xferred"),
-                                                   H1_EV_TX_DATA|H1_EV_TX_BODY, h1c->conn, h1s,, (size_t[]){v.len});
+                                                   H1_EV_TX_DATA|H1_EV_TX_BODY, h1c->conn, h1s, 0, (size_t[]){v.len});
                                break;
 
                        case H1_MSG_TRAILERS:
@@ -2081,7 +2081,7 @@ static int h1_recv(struct h1c *h1c)
                ret = conn->xprt->rcv_buf(conn, conn->xprt_ctx, &h1c->ibuf, max, flags);
        }
        if (ret > 0) {
-               TRACE_DATA("data received", H1_EV_H1C_RECV, h1c->conn,,, (size_t[]){ret});
+               TRACE_DATA("data received", H1_EV_H1C_RECV, h1c->conn, 0, 0, (size_t[]){ret});
                rcvd = 1;
                if (h1s && h1s->cs) {
                        h1s->cs->flags |= (CS_FL_READ_PARTIAL|CS_FL_RCV_MORE);
@@ -2147,7 +2147,7 @@ static int h1_send(struct h1c *h1c)
 
        ret = conn->xprt->snd_buf(conn, conn->xprt_ctx, &h1c->obuf, b_data(&h1c->obuf), flags);
        if (ret > 0) {
-               TRACE_DATA("data sent", H1_EV_H1C_SEND, h1c->conn,,, (size_t[]){ret});
+               TRACE_DATA("data sent", H1_EV_H1C_SEND, h1c->conn, 0, 0, (size_t[]){ret});
                if (h1c->flags & H1C_F_OUT_FULL) {
                        h1c->flags &= ~H1C_F_OUT_FULL;
                        TRACE_STATE("h1c obuf not full anymore", H1_EV_STRM_SEND|H1_EV_H1S_BLK, h1c->conn);
@@ -2689,7 +2689,7 @@ static size_t h1_rcv_buf(struct conn_stream *cs, struct buffer *buf, size_t coun
        struct h1m *h1m = (!conn_is_back(cs->conn) ? &h1s->req : &h1s->res);
        size_t ret = 0;
 
-       TRACE_ENTER(H1_EV_STRM_RECV, h1c->conn, h1s,, (size_t[]){count});
+       TRACE_ENTER(H1_EV_STRM_RECV, h1c->conn, h1s, 0, (size_t[]){count});
        if (!(h1c->flags & H1C_F_IN_ALLOC))
                ret = h1_process_input(h1c, buf, count);
        else
@@ -2709,7 +2709,7 @@ static size_t h1_rcv_buf(struct conn_stream *cs, struct buffer *buf, size_t coun
                if (h1m->state != H1_MSG_DONE && !(h1c->wait_event.events & SUB_RETRY_RECV))
                        h1c->conn->xprt->subscribe(h1c->conn, h1c->conn->xprt_ctx, SUB_RETRY_RECV, &h1c->wait_event);
        }
-       TRACE_LEAVE(H1_EV_STRM_RECV, h1c->conn, h1s,, (size_t[]){ret});
+       TRACE_LEAVE(H1_EV_STRM_RECV, h1c->conn, h1s, 0, (size_t[]){ret});
        return ret;
 }
 
@@ -2725,7 +2725,7 @@ static size_t h1_snd_buf(struct conn_stream *cs, struct buffer *buf, size_t coun
                return 0;
        h1c = h1s->h1c;
 
-       TRACE_ENTER(H1_EV_STRM_SEND, h1c->conn, h1s,, (size_t[]){count});
+       TRACE_ENTER(H1_EV_STRM_SEND, h1c->conn, h1s, 0, (size_t[]){count});
 
        /* If we're not connected yet, or we're waiting for a handshake, stop
         * now, as we don't want to remove everything from the channel buffer
@@ -2762,7 +2762,7 @@ static size_t h1_snd_buf(struct conn_stream *cs, struct buffer *buf, size_t coun
                        break;
        }
        h1_refresh_timeout(h1c);
-       TRACE_LEAVE(H1_EV_STRM_SEND, h1c->conn, h1s,, (size_t[]){total});
+       TRACE_LEAVE(H1_EV_STRM_SEND, h1c->conn, h1s, 0, (size_t[]){total});
        return total;
 }
 
@@ -2774,7 +2774,7 @@ static int h1_rcv_pipe(struct conn_stream *cs, struct pipe *pipe, unsigned int c
        struct h1m *h1m = (!conn_is_back(cs->conn) ? &h1s->req : &h1s->res);
        int ret = 0;
 
-       TRACE_ENTER(H1_EV_STRM_RECV, cs->conn, h1s,, (size_t[]){count});
+       TRACE_ENTER(H1_EV_STRM_RECV, cs->conn, h1s, 0, (size_t[]){count});
 
        if ((h1m->flags & H1_MF_CHNK) || (h1m->state != H1_MSG_DATA && h1m->state != H1_MSG_TUNNEL)) {
                h1s->flags &= ~(H1S_F_BUF_FLUSH|H1S_F_SPLICED_DATA);
@@ -2828,7 +2828,7 @@ static int h1_rcv_pipe(struct conn_stream *cs, struct pipe *pipe, unsigned int c
                cs->flags &= ~CS_FL_MAY_SPLICE;
        }
 
-       TRACE_LEAVE(H1_EV_STRM_RECV, cs->conn, h1s,, (size_t[]){ret});
+       TRACE_LEAVE(H1_EV_STRM_RECV, cs->conn, h1s, 0, (size_t[]){ret});
        return ret;
 }
 
@@ -2837,7 +2837,7 @@ static int h1_snd_pipe(struct conn_stream *cs, struct pipe *pipe)
        struct h1s *h1s = cs->ctx;
        int ret = 0;
 
-       TRACE_ENTER(H1_EV_STRM_SEND, cs->conn, h1s,, (size_t[]){pipe->data});
+       TRACE_ENTER(H1_EV_STRM_SEND, cs->conn, h1s, 0, (size_t[]){pipe->data});
 
        if (b_data(&h1s->h1c->obuf))
                goto end;
@@ -2851,7 +2851,7 @@ static int h1_snd_pipe(struct conn_stream *cs, struct pipe *pipe)
                }
        }
 
-       TRACE_LEAVE(H1_EV_STRM_SEND, cs->conn, h1s,, (size_t[]){ret});
+       TRACE_LEAVE(H1_EV_STRM_SEND, cs->conn, h1s, 0, (size_t[]){ret});
        return ret;
 }
 #endif

diff --git a/src/mux_h2.c b/src/mux_h2.c
index bfa65bd24b502a669e6d77f6f1460074f356acb6..15cafea5c19c59e5772e99090231fcc4a8d0cc83 100644 (file)
--- a/src/mux_h2.c
+++ b/src/mux_h2.c
@@ -1007,7 +1007,7 @@ static inline __maybe_unused int h2c_mux_busy(const struct h2c *h2c, const struc
 /* marks an error on the connection */
 static inline __maybe_unused void h2c_error(struct h2c *h2c, enum h2_err err)
 {
-       TRACE_POINT(H2_EV_H2C_ERR, h2c->conn,,, (void *)(long)(err));
+       TRACE_POINT(H2_EV_H2C_ERR, h2c->conn, 0, 0, (void *)(long)(err));
        h2c->errcode = err;
        h2c->st0 = H2_CS_ERROR;
 }
@@ -1018,7 +1018,7 @@ static inline __maybe_unused void h2c_error(struct h2c *h2c, enum h2_err err)
 static inline __maybe_unused void h2s_error(struct h2s *h2s, enum h2_err err)
 {
        if (h2s->id && h2s->st != H2_SS_ERROR) {
-               TRACE_POINT(H2_EV_H2S_ERR, h2s->h2c->conn, h2s,, (void *)(long)(err));
+               TRACE_POINT(H2_EV_H2S_ERR, h2s->h2c->conn, h2s, 0, (void *)(long)(err));
                h2s->errcode = err;
                if (h2s->st < H2_SS_ERROR)
                        h2s->st = H2_SS_ERROR;
@@ -2538,7 +2538,7 @@ static struct h2s *h2c_frt_handle_headers(struct h2c *h2c, struct h2s *h2s)
        if (h2s->id > h2c->max_id)
                h2c->max_id = h2s->id;
 
-       TRACE_USER("rcvd H2 request ", H2_EV_RX_FRAME|H2_EV_RX_HDR|H2_EV_STRM_NEW, h2c->conn,, &rxbuf);
+       TRACE_USER("rcvd H2 request ", H2_EV_RX_FRAME|H2_EV_RX_HDR|H2_EV_STRM_NEW, h2c->conn, 0, &rxbuf);
        return h2s;
 
  conn_err:
@@ -2558,7 +2558,7 @@ static struct h2s *h2c_frt_handle_headers(struct h2c *h2c, struct h2s *h2s)
        h2_release_buf(h2c, &rxbuf);
        h2c->st0 = H2_CS_FRAME_E;
 
-       TRACE_USER("rejected H2 request", H2_EV_RX_FRAME|H2_EV_RX_HDR|H2_EV_STRM_NEW|H2_EV_STRM_END, h2c->conn,, &rxbuf);
+       TRACE_USER("rejected H2 request", H2_EV_RX_FRAME|H2_EV_RX_HDR|H2_EV_STRM_NEW|H2_EV_STRM_END, h2c->conn, 0, &rxbuf);
        TRACE_DEVEL("leaving on error", H2_EV_RX_FRAME|H2_EV_RX_HDR, h2c->conn, h2s);
        return h2s;
 }
@@ -2629,7 +2629,7 @@ static struct h2s *h2c_bck_handle_headers(struct h2c *h2c, struct h2s *h2s)
                        h2s_close(h2s);
        }
 
-       TRACE_USER("rcvd H2 response", H2_EV_RX_FRAME|H2_EV_RX_HDR, h2c->conn,, &h2s->rxbuf);
+       TRACE_USER("rcvd H2 response", H2_EV_RX_FRAME|H2_EV_RX_HDR, h2c->conn, 0, &h2s->rxbuf);
        TRACE_LEAVE(H2_EV_RX_FRAME|H2_EV_RX_HDR, h2c->conn, h2s);
        return h2s;
  fail:
@@ -2644,7 +2644,7 @@ static struct h2s *h2c_bck_handle_headers(struct h2c *h2c, struct h2s *h2s)
        h2_release_buf(h2c, &rxbuf);
        h2c->st0 = H2_CS_FRAME_E;
 
-       TRACE_USER("rejected H2 response", H2_EV_RX_FRAME|H2_EV_RX_HDR|H2_EV_STRM_NEW|H2_EV_STRM_END, h2c->conn,, &rxbuf);
+       TRACE_USER("rejected H2 response", H2_EV_RX_FRAME|H2_EV_RX_HDR|H2_EV_STRM_NEW|H2_EV_STRM_END, h2c->conn, 0, &rxbuf);
        TRACE_DEVEL("leaving on error", H2_EV_RX_FRAME|H2_EV_RX_HDR, h2c->conn, h2s);
        return h2s;
 }
@@ -3386,7 +3386,7 @@ static int h2_recv(struct h2c *h2c)
                TRACE_DATA("failed to receive data, subscribing", H2_EV_H2C_RECV, h2c->conn);
                conn->xprt->subscribe(conn, conn->xprt_ctx, SUB_RETRY_RECV, &h2c->wait_event);
        } else if (ret)
-               TRACE_DATA("received data", H2_EV_H2C_RECV, h2c->conn,,, (void*)(long)ret);
+               TRACE_DATA("received data", H2_EV_H2C_RECV, h2c->conn, 0, 0, (void*)(long)ret);
 
        if (!b_data(buf)) {
                h2_release_buf(h2c, &h2c->dbuf);
@@ -3470,7 +3470,7 @@ static int h2_send(struct h2c *h2c)
                                        break;
                                }
                                sent = 1;
-                               TRACE_DATA("sent data", H2_EV_H2C_SEND, h2c->conn,, buf, (void*)(long)ret);
+                               TRACE_DATA("sent data", H2_EV_H2C_SEND, h2c->conn, 0, buf, (void*)(long)ret);
                                b_del(buf, ret);
                                if (b_data(buf)) {
                                        done = 1;
@@ -4562,7 +4562,7 @@ try_again:
                flen = block;
 
        sent = htx_add_data(htx, ist2(b_head(&h2c->dbuf), flen));
-       TRACE_DATA("move some data to h2s rxbuf", H2_EV_RX_FRAME|H2_EV_RX_DATA, h2c->conn, h2s,, (void *)(long)sent);
+       TRACE_DATA("move some data to h2s rxbuf", H2_EV_RX_FRAME|H2_EV_RX_DATA, h2c->conn, h2s, 0, (void *)(long)sent);
 
        b_del(&h2c->dbuf, sent);
        h2c->dfl    -= sent;