Fix: Off by one in seq num for data pending command

[lttng-tools.git] / src / common / consumer.c

diff --git a/src/common/consumer.c b/src/common/consumer.c
index c74d1f7ae3cbded46415430ca20054c8686de416..61d6f2e79b702337e3e8095da5132136714616b5 100644 (file)
--- a/src/common/consumer.c
+++ b/src/common/consumer.c
@@ -782,6 +782,13 @@ static int write_relayd_stream_header(struct lttng_consumer_stream *stream,
                data_hdr.stream_id = htobe64(stream->relayd_stream_id);
                data_hdr.data_size = htobe32(data_size);
                data_hdr.padding_size = htobe32(padding);
+               /*
+                * Note that net_seq_num below is assigned with the *current* value of
+                * next_net_seq_num and only after that the next_net_seq_num will be
+                * increment. This is why when issuing a command on the relayd using
+                * this next value, 1 should always be substracted in order to compare
+                * the last seen sequence number on the relayd side to the last sent.
+                */
                data_hdr.net_seq_num = htobe64(stream->next_net_seq_num++);
                /* Other fields are zeroed previously */
 
@@ -1435,7 +1442,13 @@ ssize_t lttng_consumer_on_read_subbuffer_mmap(
                } while (ret < 0 && errno == EINTR);
                DBG("Consumer mmap write() ret %zd (len %lu)", ret, len);
                if (ret < 0) {
-                       PERROR("Error in file write");
+                       /*
+                        * This is possible if the fd is closed on the other side (outfd)
+                        * or any write problem. It can be verbose a bit for a normal
+                        * execution if for instance the relayd is stopped abruptly. This
+                        * can happen so set this to a DBG statement.
+                        */
+                       DBG("Error in file write mmap");
                        if (written == 0) {
                                written = ret;
                        }
@@ -2364,6 +2377,11 @@ void *consumer_thread_data_poll(void *data)
                                pipe_readlen = read(ctx->consumer_data_pipe[0], &new_stream,
                                                sizeof(new_stream));
                        } while (pipe_readlen == -1 && errno == EINTR);
+                       if (pipe_readlen < 0) {
+                               PERROR("read consumer data pipe");
+                               /* Continue so we can at least handle the current stream(s). */
+                               continue;
+                       }
 
                        /*
                         * If the stream is NULL, just ignore it. It's also possible that
@@ -3010,7 +3028,8 @@ int consumer_data_pending(uint64_t id)
                                                stream->relayd_stream_id);
                        } else {
                                ret = relayd_data_pending(&relayd->control_sock,
-                                               stream->relayd_stream_id, stream->next_net_seq_num);
+                                               stream->relayd_stream_id,
+                                               stream->next_net_seq_num - 1);
                        }
                        pthread_mutex_unlock(&relayd->ctrl_sock_mutex);
                        if (ret == 1) {