X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=src%2Fcommon%2Frelayd%2Frelayd.c;h=458553bfe997069706aa9b43987a99d1cfcf0ece;hb=00fb02ace5151a6546f4e97e5439512913a50e68;hp=acf6c38e7c54b959ad35233314801ec9c8aebf60;hpb=93ec662e687dc15a3601704a1e0c96c51ad228c9;p=lttng-tools.git diff --git a/src/common/relayd/relayd.c b/src/common/relayd/relayd.c index acf6c38e7..458553bfe 100644 --- a/src/common/relayd/relayd.c +++ b/src/common/relayd/relayd.c @@ -35,7 +35,7 @@ * Send command. Fill up the header and append the data. */ static int send_command(struct lttcomm_relayd_sock *rsock, - enum lttcomm_relayd_command cmd, void *data, size_t size, + enum lttcomm_relayd_command cmd, const void *data, size_t size, int flags) { int ret; @@ -72,14 +72,14 @@ static int send_command(struct lttcomm_relayd_sock *rsock, memcpy(buf + sizeof(header), data, size); } + DBG3("Relayd sending command %d of size %" PRIu64, (int) cmd, buf_size); ret = rsock->sock.ops->sendmsg(&rsock->sock, buf, buf_size, flags); if (ret < 0) { + PERROR("Failed to send command %d of size %" PRIu64, + (int) cmd, buf_size); ret = -errno; goto error; } - - DBG3("Relayd sending command %d of size %" PRIu64, cmd, buf_size); - error: free(buf); alloc_error: @@ -129,16 +129,15 @@ static int relayd_create_session_2_4(struct lttcomm_relayd_sock *rsock, int ret; struct lttcomm_relayd_create_session_2_4 msg; - if (strlen(session_name) >= sizeof(msg.session_name)) { + if (lttng_strncpy(msg.session_name, session_name, + sizeof(msg.session_name))) { ret = -1; goto error; } - strncpy(msg.session_name, session_name, sizeof(msg.session_name)); - if (strlen(hostname) >= sizeof(msg.hostname)) { + if (lttng_strncpy(msg.hostname, hostname, sizeof(msg.hostname))) { ret = -1; goto error; } - strncpy(msg.hostname, hostname, sizeof(msg.hostname)); msg.live_timer = htobe32(session_live_timer); msg.snapshot = htobe32(snapshot); @@ -255,16 +254,16 @@ int relayd_add_stream(struct lttcomm_relayd_sock *rsock, const char *channel_nam /* Compat with relayd 2.1 */ if (rsock->minor == 1) { memset(&msg, 0, sizeof(msg)); - if (strlen(channel_name) >= sizeof(msg.channel_name)) { + if (lttng_strncpy(msg.channel_name, channel_name, + sizeof(msg.channel_name))) { ret = -1; goto error; } - strncpy(msg.channel_name, channel_name, sizeof(msg.channel_name)); - if (strlen(pathname) >= sizeof(msg.pathname)) { + if (lttng_strncpy(msg.pathname, pathname, + sizeof(msg.pathname))) { ret = -1; goto error; } - strncpy(msg.pathname, pathname, sizeof(msg.pathname)); /* Send command */ ret = send_command(rsock, RELAYD_ADD_STREAM, (void *) &msg, sizeof(msg), 0); @@ -274,16 +273,16 @@ int relayd_add_stream(struct lttcomm_relayd_sock *rsock, const char *channel_nam } else { memset(&msg_2_2, 0, sizeof(msg_2_2)); /* Compat with relayd 2.2+ */ - if (strlen(channel_name) >= sizeof(msg_2_2.channel_name)) { + if (lttng_strncpy(msg_2_2.channel_name, channel_name, + sizeof(msg_2_2.channel_name))) { ret = -1; goto error; } - strncpy(msg_2_2.channel_name, channel_name, sizeof(msg_2_2.channel_name)); - if (strlen(pathname) >= sizeof(msg_2_2.pathname)) { + if (lttng_strncpy(msg_2_2.pathname, pathname, + sizeof(msg_2_2.pathname))) { ret = -1; goto error; } - strncpy(msg_2_2.pathname, pathname, sizeof(msg_2_2.pathname)); msg_2_2.tracefile_size = htobe64(tracefile_size); msg_2_2.tracefile_count = htobe64(tracefile_count); @@ -379,7 +378,8 @@ end: * 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. + * Return 0 if the two daemons are compatible, LTTNG_ERR_RELAYD_VERSION_FAIL + * otherwise, or a negative value on network errors. */ int relayd_version_check(struct lttcomm_relayd_sock *rsock) { @@ -421,7 +421,7 @@ int relayd_version_check(struct lttcomm_relayd_sock *rsock) */ if (msg.major != rsock->major) { /* Not compatible */ - ret = -1; + ret = LTTNG_ERR_RELAYD_VERSION_FAIL; DBG2("Relayd version is NOT compatible. Relayd version %u != %u (us)", msg.major, rsock->major); goto error; @@ -857,7 +857,11 @@ int relayd_send_index(struct lttcomm_relayd_sock *rsock, } /* Send command */ - ret = send_command(rsock, RELAYD_SEND_INDEX, &msg, sizeof(msg), 0); + ret = send_command(rsock, RELAYD_SEND_INDEX, &msg, + lttcomm_relayd_index_len(lttng_to_index_major(rsock->major, + rsock->minor), + lttng_to_index_minor(rsock->major, rsock->minor)), + 0); if (ret < 0) { goto error; } @@ -937,3 +941,126 @@ int relayd_reset_metadata(struct lttcomm_relayd_sock *rsock, error: return ret; } + +int relayd_rotate_rename(struct lttcomm_relayd_sock *rsock, + const char *old_path, const char *new_path) +{ + 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; + + msg_length = sizeof(*msg) + old_path_length + new_path_length; + msg = zmalloc(msg_length); + if (!msg) { + PERROR("zmalloc rotate-rename command message"); + ret = -1; + goto error; + } + + assert(old_path_length <= UINT32_MAX); + msg->old_path_length = htobe32(old_path_length); + + assert(new_path_length <= UINT32_MAX); + msg->new_path_length = htobe32(new_path_length); + + strcpy(msg->paths, old_path); + strcpy(msg->paths + old_path_length, new_path); + + /* Send command */ + ret = send_command(rsock, RELAYD_ROTATE_RENAME, (const void *) msg, + msg_length, 0); + if (ret < 0) { + goto error; + } + + /* Receive response */ + ret = recv_reply(rsock, (void *) &reply, sizeof(reply)); + if (ret < 0) { + goto error; + } + + 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); + } else { + /* Success */ + ret = 0; + } + + DBG("Relayd rotate rename completed successfully"); + +error: + free(msg); + 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"); + ret = -1; + goto error; + } + msg->length = htobe32((uint32_t) len); + + if (lttng_strncpy(msg->path, path, len)) { + ret = -1; + goto error; + } + + /* Send command */ + ret = send_command(rsock, RELAYD_MKDIR, (void *) msg, + sizeof(msg->length) + len, 0); + if (ret < 0) { + goto error; + } + + /* Receive response */ + ret = recv_reply(rsock, (void *) &reply, sizeof(reply)); + if (ret < 0) { + goto error; + } + + 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); + } else { + /* Success */ + ret = 0; + } + + DBG("Relayd mkdir completed successfully"); + +error: + free(msg); + return ret; +}