X-Git-Url: http://git.efficios.com/?p=babeltrace.git;a=blobdiff_plain;f=formats%2Flttng-live%2Flttng-live-comm.c;h=c19cc6460b5b06ee07ed46e6e5b5f54adf17d80a;hp=6b65512ca3219dd9096f36293ba2a797a8574ef5;hb=b727abf5b1da0904c4321b534bd6d002ce4597f1;hpb=772ff7857761fb0fd12c5c158ae69460f9baf3dc

diff --git a/formats/lttng-live/lttng-live-comm.c b/formats/lttng-live/lttng-live-comm.c
index 6b65512c..c19cc646 100644
--- a/formats/lttng-live/lttng-live-comm.c
+++ b/formats/lttng-live/lttng-live-comm.c
@@ -157,6 +157,8 @@ int lttng_live_establish_connection(struct lttng_live_ctx *ctx)
 {
 	struct lttng_viewer_cmd cmd;
 	struct lttng_viewer_connect connect;
+	const size_t cmd_buf_len = sizeof(cmd) + sizeof(connect);
+	char cmd_buf[cmd_buf_len];
 	int ret;
 	ssize_t ret_len;
 
@@ -174,19 +176,20 @@ int lttng_live_establish_connection(struct lttng_live_ctx *ctx)
 	connect.minor = htobe32(LTTNG_LIVE_MINOR);
 	connect.type = htobe32(LTTNG_VIEWER_CLIENT_COMMAND);
 
-	ret_len = lttng_live_send(ctx->control_sock, &cmd, sizeof(cmd));
-	if (ret_len < 0) {
-		perror("[error] Error sending cmd");
-		goto error;
-	}
-	assert(ret_len == sizeof(cmd));
+	/*
+	 * Merge the cmd and connection request to prevent a write-write
+	 * sequence on the TCP socket. Otherwise, a delayed ACK will prevent the
+	 * second write to be performed quickly in presence of Nagle's algorithm.
+	 */
+	memcpy(cmd_buf, &cmd, sizeof(cmd));
+	memcpy(cmd_buf + sizeof(cmd), &connect, sizeof(connect));
 
-	ret_len = lttng_live_send(ctx->control_sock, &connect, sizeof(connect));
+	ret_len = lttng_live_send(ctx->control_sock, cmd_buf, cmd_buf_len);
 	if (ret_len < 0) {
-		perror("[error] Error sending version");
+		perror("[error] Error sending cmd for establishing session");
 		goto error;
 	}
-	assert(ret_len == sizeof(connect));
+	assert(ret_len == cmd_buf_len);
 
 	ret_len = lttng_live_recv(ctx->control_sock, &connect, sizeof(connect));
 	if (ret_len == 0) {
@@ -423,6 +426,8 @@ int lttng_live_attach_session(struct lttng_live_ctx *ctx, uint64_t id)
 	struct lttng_viewer_attach_session_request rq;
 	struct lttng_viewer_attach_session_response rp;
 	struct lttng_viewer_stream stream;
+	const size_t cmd_buf_len = sizeof(cmd) + sizeof(rq);
+	char cmd_buf[cmd_buf_len];
 	int ret, i;
 	ssize_t ret_len;
 
@@ -441,19 +446,20 @@ int lttng_live_attach_session(struct lttng_live_ctx *ctx, uint64_t id)
 	// rq.seek = htobe32(LTTNG_VIEWER_SEEK_BEGINNING);
 	rq.seek = htobe32(LTTNG_VIEWER_SEEK_LAST);
 
-	ret_len = lttng_live_send(ctx->control_sock, &cmd, sizeof(cmd));
-	if (ret_len < 0) {
-		perror("[error] Error sending cmd");
-		goto error;
-	}
-	assert(ret_len == sizeof(cmd));
+	/*
+	 * Merge the cmd and connection request to prevent a write-write
+	 * sequence on the TCP socket. Otherwise, a delayed ACK will prevent the
+	 * second write to be performed quickly in presence of Nagle's algorithm.
+	 */
+	memcpy(cmd_buf, &cmd, sizeof(cmd));
+	memcpy(cmd_buf + sizeof(cmd), &rq, sizeof(rq));
 
-	ret_len = lttng_live_send(ctx->control_sock, &rq, sizeof(rq));
+	ret_len = lttng_live_send(ctx->control_sock, cmd_buf, cmd_buf_len);
 	if (ret_len < 0) {
-		perror("[error] Error sending attach request");
+		perror("[error] Error sending attach command and request");
 		goto error;
 	}
-	assert(ret_len == sizeof(rq));
+	assert(ret_len == cmd_buf_len);
 
 	ret_len = lttng_live_recv(ctx->control_sock, &rp, sizeof(rp));
 	if (ret_len == 0) {
@@ -641,6 +647,8 @@ int get_data_packet(struct lttng_live_ctx *ctx,
 	struct lttng_viewer_cmd cmd;
 	struct lttng_viewer_get_packet rq;
 	struct lttng_viewer_trace_packet rp;
+	const size_t cmd_buf_len = sizeof(cmd) + sizeof(rq);
+	char cmd_buf[cmd_buf_len];
 	ssize_t ret_len;
 	int ret;
 
@@ -659,19 +667,20 @@ retry:
 	rq.offset = htobe64(offset);
 	rq.len = htobe32(len);
 
-	ret_len = lttng_live_send(ctx->control_sock, &cmd, sizeof(cmd));
-	if (ret_len < 0) {
-		perror("[error] Error sending cmd");
-		goto error;
-	}
-	assert(ret_len == sizeof(cmd));
+	/*
+	 * Merge the cmd and connection request to prevent a write-write
+	 * sequence on the TCP socket. Otherwise, a delayed ACK will prevent the
+	 * second write to be performed quickly in presence of Nagle's algorithm.
+	 */
+	memcpy(cmd_buf, &cmd, sizeof(cmd));
+	memcpy(cmd_buf + sizeof(cmd), &rq, sizeof(rq));
 
-	ret_len = lttng_live_send(ctx->control_sock, &rq, sizeof(rq));
+	ret_len = lttng_live_send(ctx->control_sock, cmd_buf, cmd_buf_len);
 	if (ret_len < 0) {
-		perror("[error] Error sending get_data_packet request");
+		perror("[error] Error sending get_data_packet cmd and request");
 		goto error;
 	}
-	assert(ret_len == sizeof(rq));
+	assert(ret_len == cmd_buf_len);
 
 	ret_len = lttng_live_recv(ctx->control_sock, &rp, sizeof(rp));
 	if (ret_len == 0) {
@@ -795,6 +804,8 @@ int get_one_metadata_packet(struct lttng_live_ctx *ctx,
 	struct lttng_viewer_metadata_packet rp;
 	char *data = NULL;
 	ssize_t ret_len;
+	const size_t cmd_buf_len = sizeof(cmd) + sizeof(rq);
+	char cmd_buf[cmd_buf_len];
 
 	if (lttng_live_should_quit()) {
 		ret = -1;
@@ -806,19 +817,20 @@ int get_one_metadata_packet(struct lttng_live_ctx *ctx,
 	cmd.data_size = htobe64((uint64_t) sizeof(rq));
 	cmd.cmd_version = htobe32(0);
 
-	ret_len = lttng_live_send(ctx->control_sock, &cmd, sizeof(cmd));
-	if (ret_len < 0) {
-		perror("[error] Error sending cmd");
-		goto error;
-	}
-	assert(ret_len == sizeof(cmd));
+	/*
+	 * Merge the cmd and connection request to prevent a write-write
+	 * sequence on the TCP socket. Otherwise, a delayed ACK will prevent the
+	 * second write to be performed quickly in presence of Nagle's algorithm.
+	 */
+	memcpy(cmd_buf, &cmd, sizeof(cmd));
+	memcpy(cmd_buf + sizeof(cmd), &rq, sizeof(rq));
 
-	ret_len = lttng_live_send(ctx->control_sock, &rq, sizeof(rq));
+	ret_len = lttng_live_send(ctx->control_sock, cmd_buf, cmd_buf_len);
 	if (ret_len < 0) {
-		perror("[error] Error sending get_metadata request");
+		perror("[error] Error sending get_metadata cmd and request");
 		goto error;
 	}
-	assert(ret_len == sizeof(rq));
+	assert(ret_len == cmd_buf_len);
 
 	ret_len = lttng_live_recv(ctx->control_sock, &rp, sizeof(rp));
 	if (ret_len == 0) {
@@ -976,6 +988,8 @@ int get_next_index(struct lttng_live_ctx *ctx,
 	int ret;
 	ssize_t ret_len;
 	struct lttng_viewer_index *rp = &viewer_stream->current_index;
+	const size_t cmd_buf_len = sizeof(cmd) + sizeof(rq);
+	char cmd_buf[cmd_buf_len];
 
 	cmd.cmd = htobe32(LTTNG_VIEWER_GET_NEXT_INDEX);
 	cmd.data_size = htobe64((uint64_t) sizeof(rq));
@@ -984,24 +998,24 @@ int get_next_index(struct lttng_live_ctx *ctx,
 	memset(&rq, 0, sizeof(rq));
 	rq.stream_id = htobe64(viewer_stream->id);
 
+	/*
+	 * Merge the cmd and connection request to prevent a write-write
+	 * sequence on the TCP socket. Otherwise, a delayed ACK will prevent the
+	 * second write to be performed quickly in presence of Nagle's algorithm.
+	 */
+	memcpy(cmd_buf, &cmd, sizeof(cmd));
+	memcpy(cmd_buf + sizeof(cmd), &rq, sizeof(rq));
 retry:
 	if (lttng_live_should_quit()) {
 		ret = -1;
 		goto end;
 	}
-	ret_len = lttng_live_send(ctx->control_sock, &cmd, sizeof(cmd));
+	ret_len = lttng_live_send(ctx->control_sock, &cmd_buf, cmd_buf_len);
 	if (ret_len < 0) {
-		perror("[error] Error sending cmd");
+		perror("[error] Error sending get_next_index cmd and request");
 		goto error;
 	}
-	assert(ret_len == sizeof(cmd));
-
-	ret_len = lttng_live_send(ctx->control_sock, &rq, sizeof(rq));
-	if (ret_len < 0) {
-		perror("[error] Error sending get_next_index request");
-		goto error;
-	}
-	assert(ret_len == sizeof(rq));
+	assert(ret_len == cmd_buf_len);
 
 	ret_len = lttng_live_recv(ctx->control_sock, rp, sizeof(*rp));
 	if (ret_len == 0) {
@@ -1515,6 +1529,8 @@ int lttng_live_get_new_streams(struct lttng_live_ctx *ctx, uint64_t id)
 	int ret, i, nb_streams = 0;
 	ssize_t ret_len;
 	uint32_t stream_count;
+	const size_t cmd_buf_len = sizeof(cmd) + sizeof(rq);
+	char cmd_buf[cmd_buf_len];
 
 	if (lttng_live_should_quit()) {
 		ret = -1;
@@ -1528,19 +1544,20 @@ int lttng_live_get_new_streams(struct lttng_live_ctx *ctx, uint64_t id)
 	memset(&rq, 0, sizeof(rq));
 	rq.session_id = htobe64(id);
 
-	ret_len = lttng_live_send(ctx->control_sock, &cmd, sizeof(cmd));
-	if (ret_len < 0) {
-		perror("[error] Error sending cmd");
-		goto error;
-	}
-	assert(ret_len == sizeof(cmd));
+	/*
+	 * Merge the cmd and connection request to prevent a write-write
+	 * sequence on the TCP socket. Otherwise, a delayed ACK will prevent the
+	 * second write to be performed quickly in presence of Nagle's algorithm.
+	 */
+	memcpy(cmd_buf, &cmd, sizeof(cmd));
+	memcpy(cmd_buf + sizeof(cmd), &rq, sizeof(rq));
 
-	ret_len = lttng_live_send(ctx->control_sock, &rq, sizeof(rq));
+	ret_len = lttng_live_send(ctx->control_sock, cmd_buf, cmd_buf_len);
 	if (ret_len < 0) {
-		perror("[error] Error sending get_new_streams request");
+		perror("[error] Error sending get_new_streams cmd and request");
 		goto error;
 	}
-	assert(ret_len == sizeof(rq));
+	assert(ret_len == cmd_buf_len);
 
 	ret_len = lttng_live_recv(ctx->control_sock, &rp, sizeof(rp));
 	if (ret_len == 0) {