MINOR: trace: move the known trace context into a dedicated struct

We now have a trace_ctx to hold the sess, conn, qc, stream and so on.
This will allow us to pass it across layers so that other helpers can
help fill them.

Ideally it should be passed as an argument to __trace_enabled() by
__trace() so that it can be passed back to the trace callback. But
it seems that trace callbacks are smart enough to figure all their
info when they need them.

diff --git a/include/haproxy/trace-t.h b/include/haproxy/trace-t.h
index 8cd912ef26f140091b0372b28356a5ab3ac22586..0c9452cc212f7ed6f1e8de9c8d94bbed66922bfd 100644 (file)
--- a/include/haproxy/trace-t.h
+++ b/include/haproxy/trace-t.h
@@ -136,6 +136,20 @@ struct trace_event {
        const char *desc;
 };
 
+/* context of a trace in progress. Unknown fields are NULL */
+struct trace_ctx {
+       const struct listener *li;
+       const struct proxy *fe;
+       const struct proxy *be;
+       const struct server *srv;
+       const struct session *sess;
+       const struct stream *strm;
+       const struct connection *conn;
+       const struct check *check;
+       const struct quic_conn *qc;
+       const struct appctx *appctx;
+};
+
 /* Regarding the verbosity, if <decoding> is not NULL, it must point to a NULL-
  * terminated array of name:description, which will define verbosity levels
  * implemented by the decoding callback. The verbosity value will default to

diff --git a/src/trace.c b/src/trace.c
index e328e5fe64e97806ed92237631f9a82cb9aa63fd..f4f9fa0b58d2cd33e0561201ede44896c0b7d4e8 100644 (file)
--- a/src/trace.c
+++ b/src/trace.c
@@ -90,18 +90,9 @@ int __trace_enabled(enum trace_level level, uint64_t mask, struct trace_source *
                    const void *a1, const void *a2, const void *a3, const void *a4,
                    const void **plockptr)
 {
-       const struct listener *li = NULL;
-       const struct proxy *fe = NULL;
-       const struct proxy *be = NULL;
-       const struct server *srv = NULL;
-       const struct session *sess = NULL;
-       const struct stream *strm = NULL;
-       const struct connection *conn = NULL;
-       const struct check *check = NULL;
-       const struct quic_conn *qc = NULL;
-       const struct appctx *appctx = NULL;
        const void *lockon_ptr = NULL;
        const struct trace_source *origin = NULL;
+       struct trace_ctx ctx = { };
 
        /* in case we also follow another one (e.g. session) */
        origin = HA_ATOMIC_LOAD(&src->follow);
@@ -115,64 +106,64 @@ int __trace_enabled(enum trace_level level, uint64_t mask, struct trace_source *
 
        /* retrieve available information from the caller's arguments */
        if (src->arg_def & TRC_ARGS_CONN)
-               conn = trace_pick_arg(src->arg_def & TRC_ARGS_CONN, a1, a2, a3, a4);
+               ctx.conn = trace_pick_arg(src->arg_def & TRC_ARGS_CONN, a1, a2, a3, a4);
 
        if (src->arg_def & TRC_ARGS_SESS)
-               sess = trace_pick_arg(src->arg_def & TRC_ARGS_SESS, a1, a2, a3, a4);
+               ctx.sess = trace_pick_arg(src->arg_def & TRC_ARGS_SESS, a1, a2, a3, a4);
 
        if (src->arg_def & TRC_ARGS_STRM)
-               strm = trace_pick_arg(src->arg_def & TRC_ARGS_STRM, a1, a2, a3, a4);
+               ctx.strm = trace_pick_arg(src->arg_def & TRC_ARGS_STRM, a1, a2, a3, a4);
 
        if (src->arg_def & TRC_ARGS_CHK)
-               check = trace_pick_arg(src->arg_def & TRC_ARGS_CHK, a1, a2, a3, a4);
+               ctx.check = trace_pick_arg(src->arg_def & TRC_ARGS_CHK, a1, a2, a3, a4);
 
        if (src->arg_def & TRC_ARGS_QCON)
-               qc = trace_pick_arg(src->arg_def & TRC_ARGS_QCON, a1, a2, a3, a4);
+               ctx.qc = trace_pick_arg(src->arg_def & TRC_ARGS_QCON, a1, a2, a3, a4);
 
        if (src->arg_def & TRC_ARGS_APPCTX)
-               appctx = trace_pick_arg(src->arg_def & TRC_ARGS_APPCTX, a1, a2, a3, a4);
+               ctx.appctx = trace_pick_arg(src->arg_def & TRC_ARGS_APPCTX, a1, a2, a3, a4);
 
 #ifdef USE_QUIC
-       if (qc && !conn)
-               conn = qc->conn;
+       if (ctx.qc && !ctx.conn)
+               ctx.conn = ctx.qc->conn;
 #endif
-       if (!sess && strm)
-               sess = strm->sess;
-       else if (!sess && conn && LIST_INLIST(&conn->sess_el))
-               sess = conn->owner;
-       else if (!sess && check)
-               sess = check->sess;
-       else if (!sess && appctx)
-               sess = appctx->sess;
-
-       if (sess) {
-               fe = sess->fe;
-               li = sess->listener;
+       if (!ctx.sess && ctx.strm)
+               ctx.sess = ctx.strm->sess;
+       else if (!ctx.sess && ctx.conn && LIST_INLIST(&ctx.conn->sess_el))
+               ctx.sess = ctx.conn->owner;
+       else if (!ctx.sess && ctx.check)
+               ctx.sess = ctx.check->sess;
+       else if (!ctx.sess && ctx.appctx)
+               ctx.sess = ctx.appctx->sess;
+
+       if (ctx.sess) {
+               ctx.fe = ctx.sess->fe;
+               ctx.li = ctx.sess->listener;
        }
 
-       if (!li && conn)
-               li = objt_listener(conn->target);
+       if (!ctx.li && ctx.conn)
+               ctx.li = objt_listener(ctx.conn->target);
 
-       if (li && !fe)
-               fe = li->bind_conf->frontend;
+       if (ctx.li && !ctx.fe)
+               ctx.fe = ctx.li->bind_conf->frontend;
 
-       if (strm) {
-               be = strm->be;
-               srv = strm->srv_conn;
+       if (ctx.strm) {
+               ctx.be = ctx.strm->be;
+               ctx.srv = ctx.strm->srv_conn;
        }
-       if (check) {
-               srv = check->server;
-               be = (srv ? srv->proxy : NULL);
+       if (ctx.check) {
+               ctx.srv = ctx.check->server;
+               ctx.be = (ctx.srv ? ctx.srv->proxy : NULL);
        }
 
-       if (!srv && conn)
-               srv = objt_server(conn->target);
+       if (!ctx.srv && ctx.conn)
+               ctx.srv = objt_server(ctx.conn->target);
 
-       if (srv && !be)
-               be = srv->proxy;
+       if (ctx.srv && !ctx.be)
+               ctx.be = ctx.srv->proxy;
 
-       if (!be && conn)
-               be = objt_proxy(conn->target);
+       if (!ctx.be && ctx.conn)
+               ctx.be = objt_proxy(ctx.conn->target);
 
        /* TODO: add handling of filters here, return if no match (not even update states) */
 
@@ -188,21 +179,21 @@ int __trace_enabled(enum trace_level level, uint64_t mask, struct trace_source *
        /* we may want to lock on a particular object */
        if (src->lockon != TRACE_LOCKON_NOTHING) {
                switch (src->lockon) {
-               case TRACE_LOCKON_BACKEND:    lockon_ptr = be;     break;
-               case TRACE_LOCKON_CONNECTION: lockon_ptr = conn;   break;
-               case TRACE_LOCKON_FRONTEND:   lockon_ptr = fe;     break;
-               case TRACE_LOCKON_LISTENER:   lockon_ptr = li;     break;
-               case TRACE_LOCKON_SERVER:     lockon_ptr = srv;    break;
-               case TRACE_LOCKON_SESSION:    lockon_ptr = sess;   break;
-               case TRACE_LOCKON_STREAM:     lockon_ptr = strm;   break;
-               case TRACE_LOCKON_CHECK:      lockon_ptr = check;  break;
-               case TRACE_LOCKON_THREAD:     lockon_ptr = ti;     break;
-               case TRACE_LOCKON_QCON:       lockon_ptr = qc;     break;
-               case TRACE_LOCKON_APPCTX:     lockon_ptr = appctx; break;
-               case TRACE_LOCKON_ARG1:       lockon_ptr = a1;     break;
-               case TRACE_LOCKON_ARG2:       lockon_ptr = a2;     break;
-               case TRACE_LOCKON_ARG3:       lockon_ptr = a3;     break;
-               case TRACE_LOCKON_ARG4:       lockon_ptr = a4;     break;
+               case TRACE_LOCKON_BACKEND:    lockon_ptr = ctx.be;     break;
+               case TRACE_LOCKON_CONNECTION: lockon_ptr = ctx.conn;   break;
+               case TRACE_LOCKON_FRONTEND:   lockon_ptr = ctx.fe;     break;
+               case TRACE_LOCKON_LISTENER:   lockon_ptr = ctx.li;     break;
+               case TRACE_LOCKON_SERVER:     lockon_ptr = ctx.srv;    break;
+               case TRACE_LOCKON_SESSION:    lockon_ptr = ctx.sess;   break;
+               case TRACE_LOCKON_STREAM:     lockon_ptr = ctx.strm;   break;
+               case TRACE_LOCKON_CHECK:      lockon_ptr = ctx.check;  break;
+               case TRACE_LOCKON_THREAD:     lockon_ptr = ti;         break;
+               case TRACE_LOCKON_QCON:       lockon_ptr = ctx.qc;     break;
+               case TRACE_LOCKON_APPCTX:     lockon_ptr = ctx.appctx; break;
+               case TRACE_LOCKON_ARG1:       lockon_ptr = a1;         break;
+               case TRACE_LOCKON_ARG2:       lockon_ptr = a2;         break;
+               case TRACE_LOCKON_ARG3:       lockon_ptr = a3;         break;
+               case TRACE_LOCKON_ARG4:       lockon_ptr = a4;         break;
                default: break; // silence stupid gcc -Wswitch
                }
 
@@ -219,21 +210,21 @@ int __trace_enabled(enum trace_level level, uint64_t mask, struct trace_source *
                        return 0;
 
                switch (origin->lockon) {
-               case TRACE_LOCKON_BACKEND:    lockon_ptr = be;     break;
-               case TRACE_LOCKON_CONNECTION: lockon_ptr = conn;   break;
-               case TRACE_LOCKON_FRONTEND:   lockon_ptr = fe;     break;
-               case TRACE_LOCKON_LISTENER:   lockon_ptr = li;     break;
-               case TRACE_LOCKON_SERVER:     lockon_ptr = srv;    break;
-               case TRACE_LOCKON_SESSION:    lockon_ptr = sess;   break;
-               case TRACE_LOCKON_STREAM:     lockon_ptr = strm;   break;
-               case TRACE_LOCKON_CHECK:      lockon_ptr = check;  break;
-               case TRACE_LOCKON_THREAD:     lockon_ptr = ti;     break;
-               case TRACE_LOCKON_QCON:       lockon_ptr = qc;     break;
-               case TRACE_LOCKON_APPCTX:     lockon_ptr = appctx; break;
-               case TRACE_LOCKON_ARG1:       lockon_ptr = a1;     break;
-               case TRACE_LOCKON_ARG2:       lockon_ptr = a2;     break;
-               case TRACE_LOCKON_ARG3:       lockon_ptr = a3;     break;
-               case TRACE_LOCKON_ARG4:       lockon_ptr = a4;     break;
+               case TRACE_LOCKON_BACKEND:    lockon_ptr = ctx.be;     break;
+               case TRACE_LOCKON_CONNECTION: lockon_ptr = ctx.conn;   break;
+               case TRACE_LOCKON_FRONTEND:   lockon_ptr = ctx.fe;     break;
+               case TRACE_LOCKON_LISTENER:   lockon_ptr = ctx.li;     break;
+               case TRACE_LOCKON_SERVER:     lockon_ptr = ctx.srv;    break;
+               case TRACE_LOCKON_SESSION:    lockon_ptr = ctx.sess;   break;
+               case TRACE_LOCKON_STREAM:     lockon_ptr = ctx.strm;   break;
+               case TRACE_LOCKON_CHECK:      lockon_ptr = ctx.check;  break;
+               case TRACE_LOCKON_THREAD:     lockon_ptr = ti;         break;
+               case TRACE_LOCKON_QCON:       lockon_ptr = ctx.qc;     break;
+               case TRACE_LOCKON_APPCTX:     lockon_ptr = ctx.appctx; break;
+               case TRACE_LOCKON_ARG1:       lockon_ptr = a1;         break;
+               case TRACE_LOCKON_ARG2:       lockon_ptr = a2;         break;
+               case TRACE_LOCKON_ARG3:       lockon_ptr = a3;         break;
+               case TRACE_LOCKON_ARG4:       lockon_ptr = a4;         break;
                default: break; // silence stupid gcc -Wswitch
                }