Adjust the relayd protocol on version check

If the relayd and sessiond are compatible (same major number), we store
in the session the protocol version to use for the rest of the
communication (the lowest minor number).

Signed-off-by: Julien Desfossez <jdesfossez@efficios.com>

diff --git a/src/bin/lttng-relayd/lttng-relayd.h b/src/bin/lttng-relayd/lttng-relayd.h
index edd32d6aba3770fb23cc4d720506eabde4062c5c..e6ca5ebbb2b7dcbfb9f9bdb9a4d302d70c2e3475 100644 (file)
--- a/src/bin/lttng-relayd/lttng-relayd.h
+++ b/src/bin/lttng-relayd/lttng-relayd.h
@@ -47,6 +47,9 @@ struct relay_session {
         */
        uint64_t id;
        struct lttcomm_sock *sock;
+       /* protocol version to use for this session */
+       uint32_t major;
+       uint32_t minor;
 };
 
 /*

diff --git a/src/bin/lttng-relayd/main.c b/src/bin/lttng-relayd/main.c
index 082eb7975efd0adb1c41bfbfee65c621dd34abeb..995714faf40b6f6d34b6ed31319834baf99e2b6d 100644 (file)
--- a/src/bin/lttng-relayd/main.c
+++ b/src/bin/lttng-relayd/main.c
@@ -1240,7 +1240,7 @@ end:
  */
 static
 int relay_send_version(struct lttcomm_relayd_hdr *recv_hdr,
-               struct relay_command *cmd)
+               struct relay_command *cmd, struct lttng_ht *streams_ht)
 {
        int ret;
        struct lttcomm_relayd_version reply, msg;
@@ -1262,13 +1262,6 @@ int relay_send_version(struct lttcomm_relayd_hdr *recv_hdr,
                goto end;
        }
 
-       /*
-        * For now, we just ignore the received version but after 2.1 stable
-        * release, a check must be done to see if we either adapt to the other
-        * side version (which MUST be lower than us) or keep the latest data
-        * structure considering that the other side will adapt.
-        */
-
        ret = sscanf(VERSION, "%10u.%10u", &reply.major, &reply.minor);
        if (ret < 2) {
                ERR("Error in scanning version");
@@ -1282,8 +1275,25 @@ int relay_send_version(struct lttcomm_relayd_hdr *recv_hdr,
        if (ret < 0) {
                ERR("Relay sending version");
        }
-       DBG("Version check done (%u.%u)", be32toh(reply.major),
-                       be32toh(reply.minor));
+
+       /* Major versions must be the same */
+       if (reply.major != be32toh(msg.major)) {
+               DBG("Incompatible major versions, deleting session");
+               relay_delete_session(cmd, streams_ht);
+               ret = 0;
+               goto end;
+       }
+
+       cmd->session->major = reply.major;
+       /* We adapt to the lowest compatible version */
+       if (reply.minor <= be32toh(msg.minor)) {
+               cmd->session->minor = reply.minor;
+       } else {
+               cmd->session->minor = be32toh(msg.minor);
+       }
+
+       DBG("Version check done using protocol %u.%u", cmd->session->major,
+                       cmd->session->minor);
 
 end:
        return ret;
@@ -1593,7 +1603,7 @@ int relay_process_control(struct lttcomm_relayd_hdr *recv_hdr,
                ret = relay_recv_metadata(recv_hdr, cmd, streams_ht);
                break;
        case RELAYD_VERSION:
-               ret = relay_send_version(recv_hdr, cmd);
+               ret = relay_send_version(recv_hdr, cmd, streams_ht);
                break;
        case RELAYD_CLOSE_STREAM:
                ret = relay_close_stream(recv_hdr, cmd, streams_ht);

diff --git a/src/bin/lttng-sessiond/cmd.c b/src/bin/lttng-sessiond/cmd.c
index 38ce83c7eefd308cc8b6e2f1b50abddbc5bedf9c..ca7e7dac17cb4e0e52e275e043b51c749d552096 100644 (file)
--- a/src/bin/lttng-sessiond/cmd.c
+++ b/src/bin/lttng-sessiond/cmd.c
@@ -480,10 +480,12 @@ error:
  */
 static int create_connect_relayd(struct consumer_output *output,
                const char *session_name, struct lttng_uri *uri,
-               struct lttcomm_sock **relayd_sock)
+               struct lttcomm_sock **relayd_sock,
+               struct ltt_session *session)
 {
        int ret;
        struct lttcomm_sock *sock;
+       uint32_t minor;
 
        /* Create socket object from URI */
        sock = lttcomm_alloc_sock_from_uri(uri);
@@ -518,11 +520,13 @@ static int create_connect_relayd(struct consumer_output *output,
 
                /* Check relayd version */
                ret = relayd_version_check(sock, RELAYD_VERSION_COMM_MAJOR,
-                               RELAYD_VERSION_COMM_MINOR);
+                               RELAYD_VERSION_COMM_MINOR, &minor);
                if (ret < 0) {
                        ret = LTTNG_ERR_RELAYD_VERSION_FAIL;
                        goto close_sock;
                }
+               session->major = RELAYD_VERSION_COMM_MAJOR;
+               session->minor = minor;
        } else if (uri->stype == LTTNG_STREAM_DATA) {
                DBG3("Creating relayd data socket from URI");
        } else {
@@ -559,7 +563,8 @@ static int send_consumer_relayd_socket(int domain, struct ltt_session *session,
        struct lttcomm_sock *sock = NULL;
 
        /* Connect to relayd and make version check if uri is the control. */
-       ret = create_connect_relayd(consumer, session->name, relayd_uri, &sock);
+       ret = create_connect_relayd(consumer, session->name, relayd_uri,
+                       &sock, session);
        if (ret != LTTNG_OK) {
                goto close_sock;
        }

diff --git a/src/bin/lttng-sessiond/session.h b/src/bin/lttng-sessiond/session.h
index fd23ab05ed90bb422779446d7dd3961bc862f1da..a56473783fb7d5f8f93ef11f50a40f628eaf35e5 100644 (file)
--- a/src/bin/lttng-sessiond/session.h
+++ b/src/bin/lttng-sessiond/session.h
@@ -86,6 +86,9 @@ struct ltt_session {
 
        /* Did a start command occured before the kern/ust session creation? */
        unsigned int started;
+       /* Procotol version to use with the relayd */
+       uint32_t major;
+       uint32_t minor;
 };
 
 /* Prototypes */

diff --git a/src/common/relayd/relayd.c b/src/common/relayd/relayd.c
index 9e10c83e02f7ec583bff72cd5b6d70b42870dca1..da54939f9a28153e4ae343d281ec1352e07b8ef9 100644 (file)
--- a/src/common/relayd/relayd.c
+++ b/src/common/relayd/relayd.c
@@ -212,11 +212,13 @@ error:
 
 /*
  * Check version numbers on the relayd.
+ * If major versions are compatible, we assign minor_to_use to the
+ * minor version of the procotol we are going to use for this session.
  *
  * Return 0 if compatible else negative value.
  */
 int relayd_version_check(struct lttcomm_sock *sock, uint32_t major,
-               uint32_t minor)
+               uint32_t minor, uint32_t *minor_to_use)
 {
        int ret;
        struct lttcomm_relayd_version msg;
@@ -251,15 +253,12 @@ int relayd_version_check(struct lttcomm_sock *sock, uint32_t major,
         * communication is not possible. Only major version equal can talk to each
         * other. If the minor version differs, the lowest version is used by both
         * sides.
-        *
-        * For now, before 2.1.0 stable release, we don't have to check the minor
-        * because this new mechanism with the relayd will only be available with
-        * 2.1 and NOT 2.0.x.
         */
-       if (msg.major == major) {
-               /* Compatible */
-               ret = 0;
-               DBG2("Relayd version is compatible");
+       if (msg.major != major) {
+               /* Not compatible */
+               ret = -1;
+               DBG2("Relayd version is NOT compatible. Relayd version %u != %u (us)",
+                               msg.major, major);
                goto error;
        }
 
@@ -270,11 +269,16 @@ int relayd_version_check(struct lttcomm_sock *sock, uint32_t major,
         * version is higher, it will adapt to our version so we can continue to
         * use the latest relayd communication data structure.
         */
+       if (minor <= msg.minor) {
+               *minor_to_use = minor;
+       } else {
+               *minor_to_use = msg.minor;
+       }
 
-       /* Version number not compatible */
-       DBG2("Relayd version is NOT compatible. Relayd version %u != %u (us)",
-                       msg.major, major);
-       ret = -1;
+       /* Version number compatible */
+       DBG2("Relayd version is compatible, using protocol version %u.%u",
+                       major, *minor_to_use);
+       ret = 0;
 
 error:
        return ret;

diff --git a/src/common/relayd/relayd.h b/src/common/relayd/relayd.h
index fd0acfb3583d1c4b10b80f0e45649ca00271a7b3..22bfce82901d3956fa53c55c8a228fbc09d8ff1c 100644 (file)
--- a/src/common/relayd/relayd.h
+++ b/src/common/relayd/relayd.h
@@ -31,7 +31,7 @@ int relayd_add_stream(struct lttcomm_sock *sock, const char *channel_name,
 int relayd_send_close_stream(struct lttcomm_sock *sock, uint64_t stream_id,
                uint64_t last_net_seq_num);
 int relayd_version_check(struct lttcomm_sock *sock, uint32_t major,
-               uint32_t minor);
+               uint32_t minor, uint32_t *minor_to_use);
 int relayd_start_data(struct lttcomm_sock *sock);
 int relayd_send_metadata(struct lttcomm_sock *sock, size_t len);
 int relayd_send_data_hdr(struct lttcomm_sock *sock,