X-Git-Url: https://git.lttng.org/?a=blobdiff_plain;ds=sidebyside;f=src%2Fcommon%2Frelayd%2Frelayd.c;h=87782e99477af6b3321ca40d597ed7b5c521f9b0;hb=db1da059574b86008035b12968446863ab6de866;hp=fb459699d32a68ddbf93d001df1829d93798181f;hpb=d295668767ac8234e83984e1812d342d03293d88;p=lttng-tools.git diff --git a/src/common/relayd/relayd.c b/src/common/relayd/relayd.c index fb459699d..87782e994 100644 --- a/src/common/relayd/relayd.c +++ b/src/common/relayd/relayd.c @@ -129,7 +129,9 @@ error: static int relayd_create_session_2_11(struct lttcomm_relayd_sock *rsock, const char *session_name, const char *hostname, int session_live_timer, unsigned int snapshot, - uint64_t sessiond_session_id, const lttng_uuid sessiond_uuid) + uint64_t sessiond_session_id, const lttng_uuid sessiond_uuid, + const uint64_t *current_chunk_id, + time_t creation_time) { int ret; struct lttcomm_relayd_create_session_2_11 *msg = NULL; @@ -170,6 +172,13 @@ static int relayd_create_session_2_11(struct lttcomm_relayd_sock *rsock, lttng_uuid_copy(msg->sessiond_uuid, sessiond_uuid); msg->session_id = htobe64(sessiond_session_id); + if (current_chunk_id) { + LTTNG_OPTIONAL_SET(&msg->current_chunk_id, + htobe64(*current_chunk_id)); + } + + msg->creation_time = htobe64((uint64_t) creation_time); + /* Send command */ ret = send_command(rsock, RELAYD_CREATE_SESSION, msg, msg_length, 0); if (ret < 0) { @@ -241,7 +250,9 @@ int relayd_create_session(struct lttcomm_relayd_sock *rsock, const char *session_name, const char *hostname, int session_live_timer, unsigned int snapshot, uint64_t sessiond_session_id, - const lttng_uuid sessiond_uuid) + const lttng_uuid sessiond_uuid, + const uint64_t *current_chunk_id, + time_t creation_time) { int ret; struct lttcomm_relayd_status_session reply; @@ -262,7 +273,8 @@ int relayd_create_session(struct lttcomm_relayd_sock *rsock, /* From 2.11 to ... */ ret = relayd_create_session_2_11(rsock, session_name, hostname, session_live_timer, snapshot, - sessiond_session_id, sessiond_uuid); + sessiond_session_id, sessiond_uuid, + current_chunk_id, creation_time); } if (ret < 0) { @@ -1188,175 +1200,162 @@ error: return ret; } -int relayd_rotate_rename(struct lttcomm_relayd_sock *rsock, - const char *old_path, const char *new_path) +int relayd_create_trace_chunk(struct lttcomm_relayd_sock *sock, + struct lttng_trace_chunk *chunk) { - int ret; - struct lttcomm_relayd_rotate_rename *msg = NULL; - struct lttcomm_relayd_generic_reply reply; - size_t old_path_length, new_path_length; - size_t msg_length; - - /* Code flow error. Safety net. */ - assert(rsock); - - DBG("Relayd rename chunk %s to %s", old_path, new_path); - - /* The two paths are sent with a '\0' delimiter between them. */ - old_path_length = strlen(old_path) + 1; - new_path_length = strlen(new_path) + 1; + int ret = 0; + enum lttng_trace_chunk_status status; + struct lttcomm_relayd_create_trace_chunk msg = {}; + struct lttcomm_relayd_generic_reply reply = {}; + struct lttng_dynamic_buffer payload; + uint64_t chunk_id; + time_t creation_timestamp; + const char *chunk_name; + size_t chunk_name_length; + bool overriden_name; + + lttng_dynamic_buffer_init(&payload); + + status = lttng_trace_chunk_get_id(chunk, &chunk_id); + if (status != LTTNG_TRACE_CHUNK_STATUS_OK) { + ret = -1; + goto end; + } - msg_length = sizeof(*msg) + old_path_length + new_path_length; - msg = zmalloc(msg_length); - if (!msg) { - PERROR("zmalloc rotate-rename command message"); + status = lttng_trace_chunk_get_creation_timestamp( + chunk, &creation_timestamp); + if (status != LTTNG_TRACE_CHUNK_STATUS_OK) { ret = -1; - goto error; + goto end; } - assert(old_path_length <= UINT32_MAX); - msg->old_path_length = htobe32(old_path_length); + status = lttng_trace_chunk_get_name( + chunk, &chunk_name, &overriden_name); + if (status != LTTNG_TRACE_CHUNK_STATUS_OK && + status != LTTNG_TRACE_CHUNK_STATUS_NONE) { + ret = -1; + goto end; + } - assert(new_path_length <= UINT32_MAX); - msg->new_path_length = htobe32(new_path_length); + chunk_name_length = overriden_name ? (strlen(chunk_name) + 1) : 0; + msg = (typeof(msg)){ + .chunk_id = htobe64(chunk_id), + .creation_timestamp = htobe64((uint64_t) creation_timestamp), + .override_name_length = htobe32((uint32_t) chunk_name_length), + }; - strcpy(msg->paths, old_path); - strcpy(msg->paths + old_path_length, new_path); + ret = lttng_dynamic_buffer_append(&payload, &msg, sizeof(msg)); + if (ret) { + goto end; + } + if (chunk_name_length) { + ret = lttng_dynamic_buffer_append( + &payload, chunk_name, chunk_name_length); + if (ret) { + goto end; + } + } - /* Send command */ - ret = send_command(rsock, RELAYD_ROTATE_RENAME, (const void *) msg, - msg_length, 0); + ret = send_command(sock, RELAYD_CREATE_TRACE_CHUNK, payload.data, + payload.size, 0); if (ret < 0) { - goto error; + ERR("Failed to send trace chunk creation command to relay daemon"); + goto end; } - /* Receive response */ - ret = recv_reply(rsock, (void *) &reply, sizeof(reply)); + ret = recv_reply(sock, &reply, sizeof(reply)); if (ret < 0) { - goto error; + ERR("Failed to receive relay daemon trace chunk creation command reply"); + goto end; } reply.ret_code = be32toh(reply.ret_code); - - /* Return session id or negative ret code. */ if (reply.ret_code != LTTNG_OK) { ret = -1; - ERR("Relayd rotate rename replied error %d", reply.ret_code); + ERR("Relayd trace chunk create replied error %d", + reply.ret_code); } else { - /* Success */ ret = 0; + DBG("Relayd successfully created trace chunk: chunk_id = %" PRIu64, + chunk_id); } - DBG("Relayd rotate rename completed successfully"); - -error: - free(msg); +end: + lttng_dynamic_buffer_reset(&payload); return ret; } -int relayd_rotate_pending(struct lttcomm_relayd_sock *rsock, uint64_t chunk_id) +int relayd_close_trace_chunk(struct lttcomm_relayd_sock *sock, + struct lttng_trace_chunk *chunk) { - int ret; - struct lttcomm_relayd_rotate_pending msg; - struct lttcomm_relayd_rotate_pending_reply reply; - - /* Code flow error. Safety net. */ - assert(rsock); - - DBG("Querying relayd for rotate pending with chunk_id %" PRIu64, - chunk_id); - - memset(&msg, 0, sizeof(msg)); - msg.chunk_id = htobe64(chunk_id); - - /* Send command */ - ret = send_command(rsock, RELAYD_ROTATE_PENDING, (void *) &msg, - sizeof(msg), 0); - if (ret < 0) { - goto error; - } - - /* Receive response */ - ret = recv_reply(rsock, (void *) &reply, sizeof(reply)); - if (ret < 0) { - goto error; - } - - reply.generic.ret_code = be32toh(reply.generic.ret_code); - - /* Return session id or negative ret code. */ - if (reply.generic.ret_code != LTTNG_OK) { - ret = -reply.generic.ret_code; - ERR("Relayd rotate pending replied with error %d", ret); - goto error; - } else { - /* No error, just rotate pending state */ - if (reply.is_pending == 0 || reply.is_pending == 1) { - ret = reply.is_pending; - DBG("Relayd rotate pending command completed successfully with result \"%s\"", - ret ? "rotation pending" : "rotation NOT pending"); - } else { - ret = -LTTNG_ERR_UNK; - } + int ret = 0; + enum lttng_trace_chunk_status status; + struct lttcomm_relayd_close_trace_chunk msg = {}; + struct lttcomm_relayd_generic_reply reply = {}; + uint64_t chunk_id; + time_t close_timestamp; + LTTNG_OPTIONAL(enum lttng_trace_chunk_command_type) close_command = {}; + + status = lttng_trace_chunk_get_id(chunk, &chunk_id); + if (status != LTTNG_TRACE_CHUNK_STATUS_OK) { + ERR("Failed to get trace chunk id"); + ret = -1; + goto end; } -error: - return ret; -} - -int relayd_mkdir(struct lttcomm_relayd_sock *rsock, const char *path) -{ - int ret; - struct lttcomm_relayd_mkdir *msg; - struct lttcomm_relayd_generic_reply reply; - size_t len; - - /* Code flow error. Safety net. */ - assert(rsock); - - DBG("Relayd mkdir path %s", path); - - len = strlen(path) + 1; - msg = zmalloc(sizeof(msg->length) + len); - if (!msg) { - PERROR("Alloc mkdir msg"); + status = lttng_trace_chunk_get_close_timestamp(chunk, &close_timestamp); + if (status != LTTNG_TRACE_CHUNK_STATUS_OK) { + ERR("Failed to get trace chunk close timestamp"); ret = -1; - goto error; + goto end; } - msg->length = htobe32((uint32_t) len); - if (lttng_strncpy(msg->path, path, len)) { + status = lttng_trace_chunk_get_close_command(chunk, + &close_command.value); + switch (status) { + case LTTNG_TRACE_CHUNK_STATUS_OK: + close_command.is_set = 1; + break; + case LTTNG_TRACE_CHUNK_STATUS_NONE: + break; + default: + ERR("Failed to get trace chunk close command"); ret = -1; - goto error; + goto end; } - /* Send command */ - ret = send_command(rsock, RELAYD_MKDIR, (void *) msg, - sizeof(msg->length) + len, 0); + msg = (typeof(msg)){ + .chunk_id = htobe64(chunk_id), + .close_timestamp = htobe64((uint64_t) close_timestamp), + .close_command = { + .value = htobe32((uint32_t) close_command.value), + .is_set = close_command.is_set, + }, + }; + + ret = send_command(sock, RELAYD_CLOSE_TRACE_CHUNK, &msg, sizeof(msg), + 0); if (ret < 0) { - goto error; + ERR("Failed to send trace chunk close command to relay daemon"); + goto end; } - /* Receive response */ - ret = recv_reply(rsock, (void *) &reply, sizeof(reply)); + ret = recv_reply(sock, &reply, sizeof(reply)); if (ret < 0) { - goto error; + ERR("Failed to receive relay daemon trace chunk close command reply"); + goto end; } reply.ret_code = be32toh(reply.ret_code); - - /* Return session id or negative ret code. */ if (reply.ret_code != LTTNG_OK) { ret = -1; - ERR("Relayd mkdir replied error %d", reply.ret_code); + ERR("Relayd trace chunk close replied error %d", + reply.ret_code); } else { - /* Success */ ret = 0; + DBG("Relayd successfully closed trace chunk: chunk_id = %" PRIu64, + chunk_id); } - - DBG("Relayd mkdir completed successfully"); - -error: - free(msg); +end: return ret; }