X-Git-Url: https://git.liburcu.org/?a=blobdiff_plain;f=src%2Fbin%2Flttng-sessiond%2Fclient.cpp;h=90ab4cdc02a38aef1aff28f4bfc1b7953f8d1421;hb=dd7ef1243236f524e57b25baa038973e793d5d72;hp=abd26fcb96f755b9687cfa2cdb23342e387d2bff;hpb=26e1c61ff394774de86a3ebad6a7caa02db69367;p=lttng-tools.git diff --git a/src/bin/lttng-sessiond/client.cpp b/src/bin/lttng-sessiond/client.cpp index abd26fcb9..90ab4cdc0 100644 --- a/src/bin/lttng-sessiond/client.cpp +++ b/src/bin/lttng-sessiond/client.cpp @@ -7,25 +7,41 @@ * */ -#include "common/buffer-view.h" -#include "common/compat/socket.h" -#include "common/dynamic-array.h" -#include "common/dynamic-buffer.h" -#include "common/fd-handle.h" -#include "common/payload-view.h" -#include "common/payload.h" -#include "common/sessiond-comm/sessiond-comm.h" +#include "agent-thread.hpp" +#include "clear.hpp" +#include "client.hpp" +#include "cmd.hpp" +#include "common/buffer-view.hpp" +#include "common/compat/socket.hpp" +#include "common/dynamic-array.hpp" +#include "common/dynamic-buffer.hpp" +#include "common/fd-handle.hpp" +#include "common/payload-view.hpp" +#include "common/payload.hpp" +#include "common/sessiond-comm/sessiond-comm.hpp" +#include "health-sessiond.hpp" +#include "kernel.hpp" +#include "lttng-sessiond.hpp" #include "lttng/lttng-error.h" #include "lttng/tracker.h" -#include -#include -#include -#include -#include -#include -#include -#include -#include +#include "manage-consumer.hpp" +#include "save.hpp" +#include "testpoint.hpp" +#include "utils.hpp" + +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include + +#include #include #include #include @@ -33,25 +49,15 @@ #include #include -#include "agent-thread.h" -#include "clear.h" -#include "client.h" -#include "cmd.h" -#include "health-sessiond.h" -#include "kernel.h" -#include "lttng-sessiond.h" -#include "manage-consumer.h" -#include "save.h" -#include "testpoint.h" -#include "utils.h" - -static bool is_root; - -static struct thread_state { +namespace { +bool is_root; + +struct thread_state { sem_t ready; bool running; int client_sock; } thread_state; +} /* namespace */ static void set_thread_status(bool running) { @@ -60,7 +66,7 @@ static void set_thread_status(bool running) sem_post(&thread_state.ready); } -static bool wait_thread_status(void) +static bool wait_thread_status() { DBG("Waiting for client thread to be ready"); sem_wait(&thread_state.ready); @@ -81,13 +87,15 @@ static bool wait_thread_status(void) * Return 0 on success, negative value on error. */ static int setup_lttng_msg(struct command_ctx *cmd_ctx, - const void *payload_buf, size_t payload_len, - const void *cmd_header_buf, size_t cmd_header_len) + const void *payload_buf, + size_t payload_len, + const void *cmd_header_buf, + size_t cmd_header_len) { int ret = 0; const size_t header_len = sizeof(struct lttcomm_lttng_msg); const size_t total_msg_size = header_len + cmd_header_len + payload_len; - lttcomm_lttng_msg llm {}; + lttcomm_lttng_msg llm{}; llm.cmd_type = cmd_ctx->lsm.cmd_type; llm.pid = (uint32_t) cmd_ctx->lsm.domain.attr.pid; @@ -104,8 +112,7 @@ static int setup_lttng_msg(struct command_ctx *cmd_ctx, cmd_ctx->lttng_msg_size = total_msg_size; /* Append reply header. */ - ret = lttng_dynamic_buffer_append( - &cmd_ctx->reply_payload.buffer, &llm, sizeof(llm)); + ret = lttng_dynamic_buffer_append(&cmd_ctx->reply_payload.buffer, &llm, sizeof(llm)); if (ret) { goto end; } @@ -113,8 +120,7 @@ static int setup_lttng_msg(struct command_ctx *cmd_ctx, /* Append command header. */ if (cmd_header_len) { ret = lttng_dynamic_buffer_append( - &cmd_ctx->reply_payload.buffer, cmd_header_buf, - cmd_header_len); + &cmd_ctx->reply_payload.buffer, cmd_header_buf, cmd_header_len); if (ret) { goto end; } @@ -123,8 +129,7 @@ static int setup_lttng_msg(struct command_ctx *cmd_ctx, /* Append payload. */ if (payload_len) { ret = lttng_dynamic_buffer_append( - &cmd_ctx->reply_payload.buffer, payload_buf, - payload_len); + &cmd_ctx->reply_payload.buffer, payload_buf, payload_len); if (ret) { goto end; } @@ -145,8 +150,7 @@ static int setup_empty_lttng_msg(struct command_ctx *cmd_ctx) } /* Append place-holder reply header. */ - ret = lttng_dynamic_buffer_append( - &cmd_ctx->reply_payload.buffer, &llm, sizeof(llm)); + ret = lttng_dynamic_buffer_append(&cmd_ctx->reply_payload.buffer, &llm, sizeof(llm)); if (ret) { goto end; } @@ -156,13 +160,12 @@ end: return ret; } -static void update_lttng_msg(struct command_ctx *cmd_ctx, size_t cmd_header_len, - size_t payload_len) +static void update_lttng_msg(struct command_ctx *cmd_ctx, size_t cmd_header_len, size_t payload_len) { const size_t header_len = sizeof(struct lttcomm_lttng_msg); const size_t total_msg_size = header_len + cmd_header_len + payload_len; struct lttcomm_lttng_msg *p_llm; - lttcomm_lttng_msg llm {}; + lttcomm_lttng_msg llm{}; llm.cmd_type = cmd_ctx->lsm.cmd_type; llm.pid = (uint32_t) cmd_ctx->lsm.domain.attr.pid; @@ -224,9 +227,9 @@ static pid_t spawn_consumerd(struct consumer_data *consumer_data) * fallback on the 32-bit one, */ DBG3("Looking for a kernel consumer at these locations:"); - DBG3(" 1) %s", the_config.consumerd64_bin_path.value ? : "NULL"); + DBG3(" 1) %s", the_config.consumerd64_bin_path.value ?: "NULL"); DBG3(" 2) %s/%s", INSTALL_BIN_PATH, DEFAULT_CONSUMERD_FILE); - DBG3(" 3) %s", the_config.consumerd32_bin_path.value ? : "NULL"); + DBG3(" 3) %s", the_config.consumerd32_bin_path.value ?: "NULL"); if (stat(the_config.consumerd64_bin_path.value, &st) == 0) { DBG3("Found location #1"); consumer_to_use = the_config.consumerd64_bin_path.value; @@ -234,7 +237,7 @@ static pid_t spawn_consumerd(struct consumer_data *consumer_data) DBG3("Found location #2"); consumer_to_use = INSTALL_BIN_PATH "/" DEFAULT_CONSUMERD_FILE; } else if (the_config.consumerd32_bin_path.value && - stat(the_config.consumerd32_bin_path.value, &st) == 0) { + stat(the_config.consumerd32_bin_path.value, &st) == 0) { DBG3("Found location #3"); consumer_to_use = the_config.consumerd32_bin_path.value; } else { @@ -242,15 +245,18 @@ static pid_t spawn_consumerd(struct consumer_data *consumer_data) ret = -EINVAL; goto error; } - DBG("Using kernel consumer at: %s", consumer_to_use); - (void) execl(consumer_to_use, "lttng-consumerd", - verbosity, "-k", "--consumerd-cmd-sock", - consumer_data->cmd_unix_sock_path, - "--consumerd-err-sock", - consumer_data->err_unix_sock_path, - "--group", - the_config.tracing_group_name.value, - NULL); + DBG("Using kernel consumer at: %s", consumer_to_use); + (void) execl(consumer_to_use, + "lttng-consumerd", + verbosity, + "-k", + "--consumerd-cmd-sock", + consumer_data->cmd_unix_sock_path, + "--consumerd-err-sock", + consumer_data->err_unix_sock_path, + "--group", + the_config.tracing_group_name.value, + NULL); break; case LTTNG_CONSUMER64_UST: { @@ -263,8 +269,9 @@ static pid_t spawn_consumerd(struct consumer_data *consumer_data) if (!tmp) { tmp = ""; } - tmplen = strlen(the_config.consumerd64_lib_dir.value) + 1 /* : */ + strlen(tmp); - tmpnew = (char *) zmalloc(tmplen + 1 /* \0 */); + tmplen = strlen(the_config.consumerd64_lib_dir.value) + 1 /* : */ + + strlen(tmp); + tmpnew = zmalloc(tmplen + 1 /* \0 */); if (!tmpnew) { ret = -ENOMEM; goto error; @@ -282,16 +289,18 @@ static pid_t spawn_consumerd(struct consumer_data *consumer_data) } } DBG("Using 64-bit UST consumer at: %s", - the_config.consumerd64_bin_path.value); + the_config.consumerd64_bin_path.value); (void) execl(the_config.consumerd64_bin_path.value, - "lttng-consumerd", verbosity, "-u", - "--consumerd-cmd-sock", - consumer_data->cmd_unix_sock_path, - "--consumerd-err-sock", - consumer_data->err_unix_sock_path, - "--group", - the_config.tracing_group_name.value, - NULL); + "lttng-consumerd", + verbosity, + "-u", + "--consumerd-cmd-sock", + consumer_data->cmd_unix_sock_path, + "--consumerd-err-sock", + consumer_data->err_unix_sock_path, + "--group", + the_config.tracing_group_name.value, + NULL); break; } case LTTNG_CONSUMER32_UST: @@ -305,8 +314,9 @@ static pid_t spawn_consumerd(struct consumer_data *consumer_data) if (!tmp) { tmp = ""; } - tmplen = strlen(the_config.consumerd32_lib_dir.value) + 1 /* : */ + strlen(tmp); - tmpnew = (char *) zmalloc(tmplen + 1 /* \0 */); + tmplen = strlen(the_config.consumerd32_lib_dir.value) + 1 /* : */ + + strlen(tmp); + tmpnew = zmalloc(tmplen + 1 /* \0 */); if (!tmpnew) { ret = -ENOMEM; goto error; @@ -324,16 +334,18 @@ static pid_t spawn_consumerd(struct consumer_data *consumer_data) } } DBG("Using 32-bit UST consumer at: %s", - the_config.consumerd32_bin_path.value); + the_config.consumerd32_bin_path.value); (void) execl(the_config.consumerd32_bin_path.value, - "lttng-consumerd", verbosity, "-u", - "--consumerd-cmd-sock", - consumer_data->cmd_unix_sock_path, - "--consumerd-err-sock", - consumer_data->err_unix_sock_path, - "--group", - the_config.tracing_group_name.value, - NULL); + "lttng-consumerd", + verbosity, + "-u", + "--consumerd-cmd-sock", + consumer_data->cmd_unix_sock_path, + "--consumerd-err-sock", + consumer_data->err_unix_sock_path, + "--group", + the_config.tracing_group_name.value, + NULL); break; } default: @@ -439,8 +451,7 @@ static int copy_session_consumer(int domain, struct ltt_session *session) if (session->kernel_session->consumer) { consumer_output_put(session->kernel_session->consumer); } - session->kernel_session->consumer = - consumer_copy_output(session->consumer); + session->kernel_session->consumer = consumer_copy_output(session->consumer); /* Ease our life a bit for the next part */ consumer = session->kernel_session->consumer; dir_name = DEFAULT_KERNEL_TRACE_DIR; @@ -453,8 +464,7 @@ static int copy_session_consumer(int domain, struct ltt_session *session) if (session->ust_session->consumer) { consumer_output_put(session->ust_session->consumer); } - session->ust_session->consumer = - consumer_copy_output(session->consumer); + session->ust_session->consumer = consumer_copy_output(session->consumer); /* Ease our life a bit for the next part */ consumer = session->ust_session->consumer; dir_name = DEFAULT_UST_TRACE_DIR; @@ -465,8 +475,7 @@ static int copy_session_consumer(int domain, struct ltt_session *session) } /* Append correct directory to subdir */ - ret = lttng_strncpy(consumer->domain_subdir, dir_name, - sizeof(consumer->domain_subdir)); + ret = lttng_strncpy(consumer->domain_subdir, dir_name, sizeof(consumer->domain_subdir)); if (ret) { ret = LTTNG_ERR_UNK; goto error; @@ -481,11 +490,10 @@ error: /* * Create an UST session and add it to the session ust list. */ -static int create_ust_session(struct ltt_session *session, - const struct lttng_domain *domain) +static int create_ust_session(struct ltt_session *session, const struct lttng_domain *domain) { int ret; - struct ltt_ust_session *lus = NULL; + struct ltt_ust_session *lus = nullptr; LTTNG_ASSERT(session); LTTNG_ASSERT(domain); @@ -506,7 +514,7 @@ static int create_ust_session(struct ltt_session *session, DBG("Creating UST session"); lus = trace_ust_create_session(session->id); - if (lus == NULL) { + if (lus == nullptr) { ret = LTTNG_ERR_UST_SESS_FAIL; goto error; } @@ -518,14 +526,11 @@ static int create_ust_session(struct ltt_session *session, lus->live_timer_interval = session->live_timer; session->ust_session = lus; if (session->shm_path[0]) { - strncpy(lus->root_shm_path, session->shm_path, - sizeof(lus->root_shm_path)); + strncpy(lus->root_shm_path, session->shm_path, sizeof(lus->root_shm_path)); lus->root_shm_path[sizeof(lus->root_shm_path) - 1] = '\0'; - strncpy(lus->shm_path, session->shm_path, - sizeof(lus->shm_path)); + strncpy(lus->shm_path, session->shm_path, sizeof(lus->shm_path)); lus->shm_path[sizeof(lus->shm_path) - 1] = '\0'; - strncat(lus->shm_path, "/ust", - sizeof(lus->shm_path) - strlen(lus->shm_path) - 1); + strncat(lus->shm_path, "/ust", sizeof(lus->shm_path) - strlen(lus->shm_path) - 1); } /* Copy session output to the newly created UST session */ ret = copy_session_consumer(domain->type, session); @@ -537,7 +542,7 @@ static int create_ust_session(struct ltt_session *session, error: free(lus); - session->ust_session = NULL; + session->ust_session = nullptr; return ret; } @@ -575,7 +580,7 @@ static int create_kernel_session(struct ltt_session *session) error: trace_kernel_destroy_session(session->kernel_session); - session->kernel_session = NULL; + session->kernel_session = nullptr; error_create: return ret; } @@ -583,21 +588,20 @@ error_create: /* * Count number of session permitted by uid/gid. */ -static unsigned int lttng_sessions_count(uid_t uid, gid_t gid) +static unsigned int lttng_sessions_count(uid_t uid, gid_t gid __attribute__((unused))) { unsigned int i = 0; struct ltt_session *session; const struct ltt_session_list *session_list = session_get_list(); DBG("Counting number of available session for UID %d", uid); - cds_list_for_each_entry(session, &session_list->head, list) { + cds_list_for_each_entry (session, &session_list->head, list) { if (!session_get(session)) { continue; } session_lock(session); /* Only count the sessions the user can control. */ - if (session_access_ok(session, uid) && - !session->destroyed) { + if (session_access_ok(session, uid) && !session->destroyed) { i++; } session_unlock(session); @@ -607,28 +611,26 @@ static unsigned int lttng_sessions_count(uid_t uid, gid_t gid) } static enum lttng_error_code receive_lttng_trigger(struct command_ctx *cmd_ctx, - int sock, - int *sock_error, - struct lttng_trigger **_trigger) + int sock, + int *sock_error, + struct lttng_trigger **_trigger) { int ret; size_t trigger_len; ssize_t sock_recv_len; enum lttng_error_code ret_code; struct lttng_payload trigger_payload; - struct lttng_trigger *trigger = NULL; + struct lttng_trigger *trigger = nullptr; lttng_payload_init(&trigger_payload); trigger_len = (size_t) cmd_ctx->lsm.u.trigger.length; - ret = lttng_dynamic_buffer_set_size( - &trigger_payload.buffer, trigger_len); + ret = lttng_dynamic_buffer_set_size(&trigger_payload.buffer, trigger_len); if (ret) { ret_code = LTTNG_ERR_NOMEM; goto end; } - sock_recv_len = lttcomm_recv_unix_sock( - sock, trigger_payload.buffer.data, trigger_len); + sock_recv_len = lttcomm_recv_unix_sock(sock, trigger_payload.buffer.data, trigger_len); if (sock_recv_len < 0 || sock_recv_len != trigger_len) { ERR("Failed to receive trigger in command payload"); *sock_error = 1; @@ -639,17 +641,18 @@ static enum lttng_error_code receive_lttng_trigger(struct command_ctx *cmd_ctx, /* Receive fds, if any. */ if (cmd_ctx->lsm.fd_count > 0) { sock_recv_len = lttcomm_recv_payload_fds_unix_sock( - sock, cmd_ctx->lsm.fd_count, &trigger_payload); - if (sock_recv_len > 0 && - sock_recv_len != cmd_ctx->lsm.fd_count * sizeof(int)) { + sock, cmd_ctx->lsm.fd_count, &trigger_payload); + if (sock_recv_len > 0 && sock_recv_len != cmd_ctx->lsm.fd_count * sizeof(int)) { ERR("Failed to receive all file descriptors for trigger in command payload: expected fd count = %u, ret = %d", - cmd_ctx->lsm.fd_count, (int) ret); + cmd_ctx->lsm.fd_count, + (int) ret); ret_code = LTTNG_ERR_INVALID_PROTOCOL; *sock_error = 1; goto end; } else if (sock_recv_len <= 0) { ERR("Failed to receive file descriptors for trigger in command payload: expected fd count = %u, ret = %d", - cmd_ctx->lsm.fd_count, (int) ret); + cmd_ctx->lsm.fd_count, + (int) ret); ret_code = LTTNG_ERR_FATAL; *sock_error = 1; goto end; @@ -659,11 +662,9 @@ static enum lttng_error_code receive_lttng_trigger(struct command_ctx *cmd_ctx, /* Deserialize trigger. */ { struct lttng_payload_view view = - lttng_payload_view_from_payload( - &trigger_payload, 0, -1); + lttng_payload_view_from_payload(&trigger_payload, 0, -1); - if (lttng_trigger_create_from_payload(&view, &trigger) != - trigger_len) { + if (lttng_trigger_create_from_payload(&view, &trigger) != trigger_len) { ERR("Invalid trigger received as part of command payload"); ret_code = LTTNG_ERR_INVALID_TRIGGER; lttng_trigger_put(trigger); @@ -680,16 +681,16 @@ end: } static enum lttng_error_code receive_lttng_error_query(struct command_ctx *cmd_ctx, - int sock, - int *sock_error, - struct lttng_error_query **_query) + int sock, + int *sock_error, + struct lttng_error_query **_query) { int ret; size_t query_len; ssize_t sock_recv_len; enum lttng_error_code ret_code; struct lttng_payload query_payload; - struct lttng_error_query *query = NULL; + struct lttng_error_query *query = nullptr; lttng_payload_init(&query_payload); query_len = (size_t) cmd_ctx->lsm.u.error_query.length; @@ -699,8 +700,7 @@ static enum lttng_error_code receive_lttng_error_query(struct command_ctx *cmd_c goto end; } - sock_recv_len = lttcomm_recv_unix_sock( - sock, query_payload.buffer.data, query_len); + sock_recv_len = lttcomm_recv_unix_sock(sock, query_payload.buffer.data, query_len); if (sock_recv_len < 0 || sock_recv_len != query_len) { ERR("Failed to receive error query in command payload"); *sock_error = 1; @@ -711,17 +711,18 @@ static enum lttng_error_code receive_lttng_error_query(struct command_ctx *cmd_c /* Receive fds, if any. */ if (cmd_ctx->lsm.fd_count > 0) { sock_recv_len = lttcomm_recv_payload_fds_unix_sock( - sock, cmd_ctx->lsm.fd_count, &query_payload); - if (sock_recv_len > 0 && - sock_recv_len != cmd_ctx->lsm.fd_count * sizeof(int)) { + sock, cmd_ctx->lsm.fd_count, &query_payload); + if (sock_recv_len > 0 && sock_recv_len != cmd_ctx->lsm.fd_count * sizeof(int)) { ERR("Failed to receive all file descriptors for error query in command payload: expected fd count = %u, ret = %d", - cmd_ctx->lsm.fd_count, (int) ret); + cmd_ctx->lsm.fd_count, + (int) ret); ret_code = LTTNG_ERR_INVALID_PROTOCOL; *sock_error = 1; goto end; } else if (sock_recv_len <= 0) { ERR("Failed to receive file descriptors for error query in command payload: expected fd count = %u, ret = %d", - cmd_ctx->lsm.fd_count, (int) ret); + cmd_ctx->lsm.fd_count, + (int) ret); ret_code = LTTNG_ERR_FATAL; *sock_error = 1; goto end; @@ -731,11 +732,9 @@ static enum lttng_error_code receive_lttng_error_query(struct command_ctx *cmd_c /* Deserialize error query. */ { struct lttng_payload_view view = - lttng_payload_view_from_payload( - &query_payload, 0, -1); + lttng_payload_view_from_payload(&query_payload, 0, -1); - if (lttng_error_query_create_from_payload(&view, &query) != - query_len) { + if (lttng_error_query_create_from_payload(&view, &query) != query_len) { ERR("Invalid error query received as part of command payload"); ret_code = LTTNG_ERR_INVALID_PROTOCOL; goto end; @@ -751,23 +750,27 @@ end: } static enum lttng_error_code receive_lttng_event(struct command_ctx *cmd_ctx, - int sock, - int *sock_error, - struct lttng_event **out_event, - char **out_filter_expression, - struct lttng_bytecode **out_bytecode, - struct lttng_event_exclusion **out_exclusion) + int sock, + int *sock_error, + struct lttng_event **out_event, + char **out_filter_expression, + struct lttng_bytecode **out_bytecode, + struct lttng_event_exclusion **out_exclusion) { int ret; size_t event_len; ssize_t sock_recv_len; enum lttng_error_code ret_code; struct lttng_payload event_payload; + struct lttng_event *local_event = nullptr; + char *local_filter_expression = nullptr; + struct lttng_bytecode *local_bytecode = nullptr; + struct lttng_event_exclusion *local_exclusion = nullptr; lttng_payload_init(&event_payload); - if (cmd_ctx->lsm.cmd_type == LTTNG_ENABLE_EVENT) { + if (cmd_ctx->lsm.cmd_type == LTTCOMM_SESSIOND_COMMAND_ENABLE_EVENT) { event_len = (size_t) cmd_ctx->lsm.u.enable.length; - } else if (cmd_ctx->lsm.cmd_type == LTTNG_DISABLE_EVENT) { + } else if (cmd_ctx->lsm.cmd_type == LTTCOMM_SESSIOND_COMMAND_DISABLE_EVENT) { event_len = (size_t) cmd_ctx->lsm.u.disable.length; } else { abort(); @@ -779,8 +782,7 @@ static enum lttng_error_code receive_lttng_event(struct command_ctx *cmd_ctx, goto end; } - sock_recv_len = lttcomm_recv_unix_sock( - sock, event_payload.buffer.data, event_len); + sock_recv_len = lttcomm_recv_unix_sock(sock, event_payload.buffer.data, event_len); if (sock_recv_len < 0 || sock_recv_len != event_len) { ERR("Failed to receive event in command payload"); *sock_error = 1; @@ -791,17 +793,18 @@ static enum lttng_error_code receive_lttng_event(struct command_ctx *cmd_ctx, /* Receive fds, if any. */ if (cmd_ctx->lsm.fd_count > 0) { sock_recv_len = lttcomm_recv_payload_fds_unix_sock( - sock, cmd_ctx->lsm.fd_count, &event_payload); - if (sock_recv_len > 0 && - sock_recv_len != cmd_ctx->lsm.fd_count * sizeof(int)) { + sock, cmd_ctx->lsm.fd_count, &event_payload); + if (sock_recv_len > 0 && sock_recv_len != cmd_ctx->lsm.fd_count * sizeof(int)) { ERR("Failed to receive all file descriptors for event in command payload: expected fd count = %u, ret = %d", - cmd_ctx->lsm.fd_count, (int) ret); + cmd_ctx->lsm.fd_count, + (int) ret); ret_code = LTTNG_ERR_INVALID_PROTOCOL; *sock_error = 1; goto end; } else if (sock_recv_len <= 0) { ERR("Failed to receive file descriptors for event in command payload: expected fd count = %u, ret = %d", - cmd_ctx->lsm.fd_count, (int) ret); + cmd_ctx->lsm.fd_count, + (int) ret); ret_code = LTTNG_ERR_FATAL; *sock_error = 1; goto end; @@ -810,51 +813,75 @@ static enum lttng_error_code receive_lttng_event(struct command_ctx *cmd_ctx, /* Deserialize event. */ { + ssize_t len; struct lttng_payload_view event_view = - lttng_payload_view_from_payload( - &event_payload, 0, -1); + lttng_payload_view_from_payload(&event_payload, 0, -1); + + len = lttng_event_create_from_payload(&event_view, + &local_event, + &local_exclusion, + &local_filter_expression, + &local_bytecode); - if (lttng_event_create_from_payload(&event_view, out_event, - out_exclusion, out_filter_expression, - out_bytecode) != event_len) { - ERR("Invalid event received as part of command payload"); + if (len < 0) { + ERR("Failed to create an event from the received buffer"); + ret_code = LTTNG_ERR_INVALID_PROTOCOL; + goto end; + } + + if (len != event_len) { + ERR("Userspace probe location from the received buffer is not the advertised length: header length = %zu" PRIu32 + ", payload length = %zd", + event_len, + len); ret_code = LTTNG_ERR_INVALID_PROTOCOL; goto end; } } + *out_event = local_event; + *out_exclusion = local_exclusion; + *out_filter_expression = local_filter_expression; + *out_bytecode = local_bytecode; + local_event = nullptr; + local_exclusion = nullptr; + local_filter_expression = nullptr; + local_bytecode = nullptr; + ret_code = LTTNG_OK; end: lttng_payload_reset(&event_payload); + lttng_event_destroy(local_event); + free(local_filter_expression); + free(local_bytecode); + free(local_exclusion); return ret_code; } -static enum lttng_error_code receive_lttng_event_context( - const struct command_ctx *cmd_ctx, - int sock, - int *sock_error, - struct lttng_event_context **out_event_context) +static enum lttng_error_code +receive_lttng_event_context(const struct command_ctx *cmd_ctx, + int sock, + int *sock_error, + struct lttng_event_context **out_event_context) { int ret; - const size_t event_context_len = - (size_t) cmd_ctx->lsm.u.context.length; + const size_t event_context_len = (size_t) cmd_ctx->lsm.u.context.length; ssize_t sock_recv_len; enum lttng_error_code ret_code; struct lttng_payload event_context_payload; + struct lttng_event_context *context = nullptr; lttng_payload_init(&event_context_payload); - ret = lttng_dynamic_buffer_set_size(&event_context_payload.buffer, - event_context_len); + ret = lttng_dynamic_buffer_set_size(&event_context_payload.buffer, event_context_len); if (ret) { ret_code = LTTNG_ERR_NOMEM; goto end; } - sock_recv_len = lttcomm_recv_unix_sock( - sock, event_context_payload.buffer.data, - event_context_len); + sock_recv_len = + lttcomm_recv_unix_sock(sock, event_context_payload.buffer.data, event_context_len); if (sock_recv_len < 0 || sock_recv_len != event_context_len) { ERR("Failed to receive event context in command payload"); *sock_error = 1; @@ -864,22 +891,33 @@ static enum lttng_error_code receive_lttng_event_context( /* Deserialize event. */ { + ssize_t len; struct lttng_payload_view event_context_view = - lttng_payload_view_from_payload( - &event_context_payload, 0, -1); + lttng_payload_view_from_payload(&event_context_payload, 0, -1); + + len = lttng_event_context_create_from_payload(&event_context_view, &context); + + if (len < 0) { + ERR("Failed to create a event context from the received buffer"); + ret_code = LTTNG_ERR_INVALID_PROTOCOL; + goto end; + } - if (lttng_event_context_create_from_payload( - &event_context_view, out_event_context) != - event_context_len) { - ERR("Invalid event context received as part of command payload"); + if (len != event_context_len) { + ERR("Event context from the received buffer is not the advertised length: expected length = %zu, payload length = %zd", + event_context_len, + len); ret_code = LTTNG_ERR_INVALID_PROTOCOL; goto end; } } + *out_event_context = context; + context = nullptr; ret_code = LTTNG_OK; end: + lttng_event_context_destroy(context); lttng_payload_reset(&event_context_payload); return ret_code; } @@ -887,22 +925,21 @@ end: /* * Version of setup_lttng_msg() without command header. */ -static int setup_lttng_msg_no_cmd_header(struct command_ctx *cmd_ctx, - void *payload_buf, size_t payload_len) +static int +setup_lttng_msg_no_cmd_header(struct command_ctx *cmd_ctx, void *payload_buf, size_t payload_len) { - return setup_lttng_msg(cmd_ctx, payload_buf, payload_len, NULL, 0); + return setup_lttng_msg(cmd_ctx, payload_buf, payload_len, nullptr, 0); } /* * Check if the current kernel tracer supports the session rotation feature. * Return 1 if it does, 0 otherwise. */ -static int check_rotate_compatible(void) +static int check_rotate_compatible() { int ret = 1; - if (the_kernel_tracer_version.major != 2 || - the_kernel_tracer_version.minor < 11) { + if (the_kernel_tracer_version.major != 2 || the_kernel_tracer_version.minor < 11) { DBG("Kernel tracer version is not compatible with the rotation feature"); ret = 0; } @@ -926,8 +963,7 @@ static int send_unix_sock(int sock, struct lttng_payload_view *view) goto end; } - ret = lttcomm_send_unix_sock( - sock, view->buffer.data, view->buffer.size); + ret = lttcomm_send_unix_sock(sock, view->buffer.data, view->buffer.size); if (ret < 0) { goto end; } @@ -954,43 +990,49 @@ end: * A command may assume the ownership of the socket, in which case its value * should be set to -1. */ -static int process_client_msg(struct command_ctx *cmd_ctx, int *sock, - int *sock_error) +static int process_client_msg(struct command_ctx *cmd_ctx, int *sock, int *sock_error) { int ret = LTTNG_OK; bool need_tracing_session = true; bool need_domain; bool need_consumerd; + if (!lttcomm_sessiond_command_is_valid((lttcomm_sessiond_command) cmd_ctx->lsm.cmd_type)) { + ERR("Unknown client command received: command id = %" PRIu32, + cmd_ctx->lsm.cmd_type); + ret = LTTNG_ERR_UND; + goto error; + } + DBG("Processing client command '%s\' (%d)", - lttcomm_sessiond_command_str((lttcomm_sessiond_command) cmd_ctx->lsm.cmd_type), - cmd_ctx->lsm.cmd_type); + lttcomm_sessiond_command_str((lttcomm_sessiond_command) cmd_ctx->lsm.cmd_type), + cmd_ctx->lsm.cmd_type); *sock_error = 0; switch (cmd_ctx->lsm.cmd_type) { - case LTTNG_CREATE_SESSION_EXT: - case LTTNG_DESTROY_SESSION: - case LTTNG_LIST_SESSIONS: - case LTTNG_LIST_DOMAINS: - case LTTNG_START_TRACE: - case LTTNG_STOP_TRACE: - case LTTNG_DATA_PENDING: - case LTTNG_SNAPSHOT_ADD_OUTPUT: - case LTTNG_SNAPSHOT_DEL_OUTPUT: - case LTTNG_SNAPSHOT_LIST_OUTPUT: - case LTTNG_SNAPSHOT_RECORD: - case LTTNG_SAVE_SESSION: - case LTTNG_SET_SESSION_SHM_PATH: - case LTTNG_REGENERATE_METADATA: - case LTTNG_REGENERATE_STATEDUMP: - case LTTNG_ROTATE_SESSION: - case LTTNG_ROTATION_GET_INFO: - case LTTNG_ROTATION_SET_SCHEDULE: - case LTTNG_SESSION_LIST_ROTATION_SCHEDULES: - case LTTNG_CLEAR_SESSION: - case LTTNG_LIST_TRIGGERS: - case LTTNG_EXECUTE_ERROR_QUERY: + case LTTCOMM_SESSIOND_COMMAND_CREATE_SESSION_EXT: + case LTTCOMM_SESSIOND_COMMAND_DESTROY_SESSION: + case LTTCOMM_SESSIOND_COMMAND_LIST_SESSIONS: + case LTTCOMM_SESSIOND_COMMAND_LIST_DOMAINS: + case LTTCOMM_SESSIOND_COMMAND_START_TRACE: + case LTTCOMM_SESSIOND_COMMAND_STOP_TRACE: + case LTTCOMM_SESSIOND_COMMAND_DATA_PENDING: + case LTTCOMM_SESSIOND_COMMAND_SNAPSHOT_ADD_OUTPUT: + case LTTCOMM_SESSIOND_COMMAND_SNAPSHOT_DEL_OUTPUT: + case LTTCOMM_SESSIOND_COMMAND_SNAPSHOT_LIST_OUTPUT: + case LTTCOMM_SESSIOND_COMMAND_SNAPSHOT_RECORD: + case LTTCOMM_SESSIOND_COMMAND_SAVE_SESSION: + case LTTCOMM_SESSIOND_COMMAND_SET_SESSION_SHM_PATH: + case LTTCOMM_SESSIOND_COMMAND_REGENERATE_METADATA: + case LTTCOMM_SESSIOND_COMMAND_REGENERATE_STATEDUMP: + case LTTCOMM_SESSIOND_COMMAND_ROTATE_SESSION: + case LTTCOMM_SESSIOND_COMMAND_ROTATION_GET_INFO: + case LTTCOMM_SESSIOND_COMMAND_ROTATION_SET_SCHEDULE: + case LTTCOMM_SESSIOND_COMMAND_SESSION_LIST_ROTATION_SCHEDULES: + case LTTCOMM_SESSIOND_COMMAND_CLEAR_SESSION: + case LTTCOMM_SESSIOND_COMMAND_LIST_TRIGGERS: + case LTTCOMM_SESSIOND_COMMAND_EXECUTE_ERROR_QUERY: need_domain = false; break; default: @@ -999,9 +1041,9 @@ static int process_client_msg(struct command_ctx *cmd_ctx, int *sock, /* Needs a functioning consumerd? */ switch (cmd_ctx->lsm.cmd_type) { - case LTTNG_REGISTER_TRIGGER: - case LTTNG_UNREGISTER_TRIGGER: - case LTTNG_EXECUTE_ERROR_QUERY: + case LTTCOMM_SESSIOND_COMMAND_REGISTER_TRIGGER: + case LTTCOMM_SESSIOND_COMMAND_UNREGISTER_TRIGGER: + case LTTCOMM_SESSIOND_COMMAND_EXECUTE_ERROR_QUERY: need_consumerd = false; break; default: @@ -1010,7 +1052,7 @@ static int process_client_msg(struct command_ctx *cmd_ctx, int *sock, } if (the_config.no_kernel && need_domain && - cmd_ctx->lsm.domain.type == LTTNG_DOMAIN_KERNEL) { + cmd_ctx->lsm.domain.type == LTTNG_DOMAIN_KERNEL) { if (!is_root) { ret = LTTNG_ERR_NEED_ROOT_SESSIOND; } else { @@ -1020,7 +1062,7 @@ static int process_client_msg(struct command_ctx *cmd_ctx, int *sock, } /* Deny register consumer if we already have a spawned consumer. */ - if (cmd_ctx->lsm.cmd_type == LTTNG_REGISTER_CONSUMER) { + if (cmd_ctx->lsm.cmd_type == LTTCOMM_SESSIOND_COMMAND_REGISTER_CONSUMER) { pthread_mutex_lock(&the_kconsumer_data.pid_mutex); if (the_kconsumer_data.pid > 0) { ret = LTTNG_ERR_KERN_CONSUMER_FAIL; @@ -1035,27 +1077,27 @@ static int process_client_msg(struct command_ctx *cmd_ctx, int *sock, * this here so we don't have to make the call for no payload at each * command. */ - switch(cmd_ctx->lsm.cmd_type) { - case LTTNG_LIST_SESSIONS: - case LTTNG_LIST_TRACEPOINTS: - case LTTNG_LIST_TRACEPOINT_FIELDS: - case LTTNG_LIST_DOMAINS: - case LTTNG_LIST_CHANNELS: - case LTTNG_LIST_EVENTS: - case LTTNG_LIST_SYSCALLS: - case LTTNG_SESSION_LIST_ROTATION_SCHEDULES: - case LTTNG_PROCESS_ATTR_TRACKER_GET_POLICY: - case LTTNG_PROCESS_ATTR_TRACKER_GET_INCLUSION_SET: - case LTTNG_DATA_PENDING: - case LTTNG_ROTATE_SESSION: - case LTTNG_ROTATION_GET_INFO: - case LTTNG_REGISTER_TRIGGER: - case LTTNG_LIST_TRIGGERS: - case LTTNG_EXECUTE_ERROR_QUERY: + switch (cmd_ctx->lsm.cmd_type) { + case LTTCOMM_SESSIOND_COMMAND_LIST_SESSIONS: + case LTTCOMM_SESSIOND_COMMAND_LIST_TRACEPOINTS: + case LTTCOMM_SESSIOND_COMMAND_LIST_TRACEPOINT_FIELDS: + case LTTCOMM_SESSIOND_COMMAND_LIST_DOMAINS: + case LTTCOMM_SESSIOND_COMMAND_LIST_CHANNELS: + case LTTCOMM_SESSIOND_COMMAND_LIST_EVENTS: + case LTTCOMM_SESSIOND_COMMAND_LIST_SYSCALLS: + case LTTCOMM_SESSIOND_COMMAND_SESSION_LIST_ROTATION_SCHEDULES: + case LTTCOMM_SESSIOND_COMMAND_PROCESS_ATTR_TRACKER_GET_POLICY: + case LTTCOMM_SESSIOND_COMMAND_PROCESS_ATTR_TRACKER_GET_INCLUSION_SET: + case LTTCOMM_SESSIOND_COMMAND_DATA_PENDING: + case LTTCOMM_SESSIOND_COMMAND_ROTATE_SESSION: + case LTTCOMM_SESSIOND_COMMAND_ROTATION_GET_INFO: + case LTTCOMM_SESSIOND_COMMAND_REGISTER_TRIGGER: + case LTTCOMM_SESSIOND_COMMAND_LIST_TRIGGERS: + case LTTCOMM_SESSIOND_COMMAND_EXECUTE_ERROR_QUERY: break; default: /* Setup lttng message with no payload */ - ret = setup_lttng_msg_no_cmd_header(cmd_ctx, NULL, 0); + ret = setup_lttng_msg_no_cmd_header(cmd_ctx, nullptr, 0); if (ret < 0) { /* This label does not try to unlock the session */ goto init_setup_error; @@ -1064,16 +1106,16 @@ static int process_client_msg(struct command_ctx *cmd_ctx, int *sock, /* Commands that DO NOT need a session. */ switch (cmd_ctx->lsm.cmd_type) { - case LTTNG_CREATE_SESSION_EXT: - case LTTNG_LIST_SESSIONS: - case LTTNG_LIST_TRACEPOINTS: - case LTTNG_LIST_SYSCALLS: - case LTTNG_LIST_TRACEPOINT_FIELDS: - case LTTNG_SAVE_SESSION: - case LTTNG_REGISTER_TRIGGER: - case LTTNG_UNREGISTER_TRIGGER: - case LTTNG_LIST_TRIGGERS: - case LTTNG_EXECUTE_ERROR_QUERY: + case LTTCOMM_SESSIOND_COMMAND_CREATE_SESSION_EXT: + case LTTCOMM_SESSIOND_COMMAND_LIST_SESSIONS: + case LTTCOMM_SESSIOND_COMMAND_LIST_TRACEPOINTS: + case LTTCOMM_SESSIOND_COMMAND_LIST_SYSCALLS: + case LTTCOMM_SESSIOND_COMMAND_LIST_TRACEPOINT_FIELDS: + case LTTCOMM_SESSIOND_COMMAND_SAVE_SESSION: + case LTTCOMM_SESSIOND_COMMAND_REGISTER_TRIGGER: + case LTTCOMM_SESSIOND_COMMAND_UNREGISTER_TRIGGER: + case LTTCOMM_SESSIOND_COMMAND_LIST_TRIGGERS: + case LTTCOMM_SESSIOND_COMMAND_EXECUTE_ERROR_QUERY: need_tracing_session = false; break; default: @@ -1085,7 +1127,7 @@ static int process_client_msg(struct command_ctx *cmd_ctx, int *sock, */ session_lock_list(); cmd_ctx->session = session_find_by_name(cmd_ctx->lsm.session.name); - if (cmd_ctx->session == NULL) { + if (cmd_ctx->session == nullptr) { ret = LTTNG_ERR_SESS_NOT_FOUND; goto error; } else { @@ -1102,8 +1144,8 @@ static int process_client_msg(struct command_ctx *cmd_ctx, int *sock, * code path. */ switch (cmd_ctx->lsm.cmd_type) { - case LTTNG_DISABLE_CHANNEL: - case LTTNG_DISABLE_EVENT: + case LTTCOMM_SESSIOND_COMMAND_DISABLE_CHANNEL: + case LTTCOMM_SESSIOND_COMMAND_DISABLE_EVENT: switch (cmd_ctx->lsm.domain.type) { case LTTNG_DOMAIN_KERNEL: if (!cmd_ctx->session->kernel_session) { @@ -1152,15 +1194,14 @@ static int process_client_msg(struct command_ctx *cmd_ctx, int *sock, } /* Consumer is in an ERROR state. Report back to client */ - if (need_consumerd && uatomic_read(&the_kernel_consumerd_state) == - CONSUMER_ERROR) { + if (need_consumerd && uatomic_read(&the_kernel_consumerd_state) == CONSUMER_ERROR) { ret = LTTNG_ERR_NO_KERNCONSUMERD; goto error; } /* Need a session for kernel command */ if (need_tracing_session) { - if (cmd_ctx->session->kernel_session == NULL) { + if (cmd_ctx->session->kernel_session == nullptr) { ret = create_kernel_session(cmd_ctx->session); if (ret != LTTNG_OK) { ret = LTTNG_ERR_KERN_SESS_FAIL; @@ -1171,7 +1212,7 @@ static int process_client_msg(struct command_ctx *cmd_ctx, int *sock, /* Start the kernel consumer daemon */ pthread_mutex_lock(&the_kconsumer_data.pid_mutex); if (the_kconsumer_data.pid == 0 && - cmd_ctx->lsm.cmd_type != LTTNG_REGISTER_CONSUMER) { + cmd_ctx->lsm.cmd_type != LTTCOMM_SESSIOND_COMMAND_REGISTER_CONSUMER) { pthread_mutex_unlock(&the_kconsumer_data.pid_mutex); ret = start_consumerd(&the_kconsumer_data); if (ret < 0) { @@ -1188,7 +1229,7 @@ static int process_client_msg(struct command_ctx *cmd_ctx, int *sock, * the consumer output of the session if exist. */ ret = consumer_create_socket(&the_kconsumer_data, - cmd_ctx->session->kernel_session->consumer); + cmd_ctx->session->kernel_session->consumer); if (ret < 0) { goto error; } @@ -1211,16 +1252,14 @@ static int process_client_msg(struct command_ctx *cmd_ctx, int *sock, } /* Consumer is in an ERROR state. Report back to client */ - if (need_consumerd && - uatomic_read(&the_ust_consumerd_state) == - CONSUMER_ERROR) { + if (need_consumerd && uatomic_read(&the_ust_consumerd_state) == CONSUMER_ERROR) { ret = LTTNG_ERR_NO_USTCONSUMERD; goto error; } if (need_tracing_session) { /* Create UST session if none exist. */ - if (cmd_ctx->session->ust_session == NULL) { + if (cmd_ctx->session->ust_session == nullptr) { lttng_domain domain = cmd_ctx->lsm.domain; ret = create_ust_session(cmd_ctx->session, &domain); if (ret != LTTNG_OK) { @@ -1232,8 +1271,8 @@ static int process_client_msg(struct command_ctx *cmd_ctx, int *sock, /* 64-bit */ pthread_mutex_lock(&the_ustconsumer64_data.pid_mutex); if (the_config.consumerd64_bin_path.value && - the_ustconsumer64_data.pid == 0 && - cmd_ctx->lsm.cmd_type != LTTNG_REGISTER_CONSUMER) { + the_ustconsumer64_data.pid == 0 && + cmd_ctx->lsm.cmd_type != LTTCOMM_SESSIOND_COMMAND_REGISTER_CONSUMER) { pthread_mutex_unlock(&the_ustconsumer64_data.pid_mutex); ret = start_consumerd(&the_ustconsumer64_data); if (ret < 0) { @@ -1242,7 +1281,8 @@ static int process_client_msg(struct command_ctx *cmd_ctx, int *sock, goto error; } - uatomic_set(&the_ust_consumerd64_fd, the_ustconsumer64_data.cmd_sock); + uatomic_set(&the_ust_consumerd64_fd, + the_ustconsumer64_data.cmd_sock); uatomic_set(&the_ust_consumerd_state, CONSUMER_STARTED); } else { pthread_mutex_unlock(&the_ustconsumer64_data.pid_mutex); @@ -1253,7 +1293,7 @@ static int process_client_msg(struct command_ctx *cmd_ctx, int *sock, * since it was set above and can ONLY be set in this thread. */ ret = consumer_create_socket(&the_ustconsumer64_data, - cmd_ctx->session->ust_session->consumer); + cmd_ctx->session->ust_session->consumer); if (ret < 0) { goto error; } @@ -1261,8 +1301,8 @@ static int process_client_msg(struct command_ctx *cmd_ctx, int *sock, /* 32-bit */ pthread_mutex_lock(&the_ustconsumer32_data.pid_mutex); if (the_config.consumerd32_bin_path.value && - the_ustconsumer32_data.pid == 0 && - cmd_ctx->lsm.cmd_type != LTTNG_REGISTER_CONSUMER) { + the_ustconsumer32_data.pid == 0 && + cmd_ctx->lsm.cmd_type != LTTCOMM_SESSIOND_COMMAND_REGISTER_CONSUMER) { pthread_mutex_unlock(&the_ustconsumer32_data.pid_mutex); ret = start_consumerd(&the_ustconsumer32_data); if (ret < 0) { @@ -1271,7 +1311,8 @@ static int process_client_msg(struct command_ctx *cmd_ctx, int *sock, goto error; } - uatomic_set(&the_ust_consumerd32_fd, the_ustconsumer32_data.cmd_sock); + uatomic_set(&the_ust_consumerd32_fd, + the_ustconsumer32_data.cmd_sock); uatomic_set(&the_ust_consumerd_state, CONSUMER_STARTED); } else { pthread_mutex_unlock(&the_ustconsumer32_data.pid_mutex); @@ -1282,7 +1323,7 @@ static int process_client_msg(struct command_ctx *cmd_ctx, int *sock, * since it was set above and can ONLY be set in this thread. */ ret = consumer_create_socket(&the_ustconsumer32_data, - cmd_ctx->session->ust_session->consumer); + cmd_ctx->session->ust_session->consumer); if (ret < 0) { goto error; } @@ -1295,8 +1336,8 @@ static int process_client_msg(struct command_ctx *cmd_ctx, int *sock, skip_domain: /* Validate consumer daemon state when start/stop trace command */ - if (cmd_ctx->lsm.cmd_type == LTTNG_START_TRACE || - cmd_ctx->lsm.cmd_type == LTTNG_STOP_TRACE) { + if (cmd_ctx->lsm.cmd_type == LTTCOMM_SESSIOND_COMMAND_START_TRACE || + cmd_ctx->lsm.cmd_type == LTTCOMM_SESSIOND_COMMAND_STOP_TRACE) { switch (cmd_ctx->lsm.domain.type) { case LTTNG_DOMAIN_NONE: break; @@ -1327,8 +1368,8 @@ skip_domain: */ if (need_tracing_session) { if (!session_access_ok(cmd_ctx->session, - LTTNG_SOCK_GET_UID_CRED(&cmd_ctx->creds)) || - cmd_ctx->session->destroyed) { + LTTNG_SOCK_GET_UID_CRED(&cmd_ctx->creds)) || + cmd_ctx->session->destroyed) { ret = LTTNG_ERR_EPERM; goto error; } @@ -1351,12 +1392,11 @@ skip_domain: /* Process by command type */ switch (cmd_ctx->lsm.cmd_type) { - case LTTNG_ADD_CONTEXT: + case LTTCOMM_SESSIOND_COMMAND_ADD_CONTEXT: { - struct lttng_event_context *event_context; + struct lttng_event_context *event_context = nullptr; const enum lttng_error_code ret_code = - receive_lttng_event_context( - cmd_ctx, *sock, sock_error, &event_context); + receive_lttng_event_context(cmd_ctx, *sock, sock_error, &event_context); if (ret_code != LTTNG_OK) { ret = (int) ret_code; @@ -1367,41 +1407,35 @@ skip_domain: lttng_event_context_destroy(event_context); break; } - case LTTNG_DISABLE_CHANNEL: + case LTTCOMM_SESSIOND_COMMAND_DISABLE_CHANNEL: { - ret = cmd_disable_channel(cmd_ctx->session, cmd_ctx->lsm.domain.type, - cmd_ctx->lsm.u.disable.channel_name); + ret = cmd_disable_channel(cmd_ctx->session, + cmd_ctx->lsm.domain.type, + cmd_ctx->lsm.u.disable.channel_name); break; } - case LTTNG_ENABLE_CHANNEL: + case LTTCOMM_SESSIOND_COMMAND_ENABLE_CHANNEL: { - ret = cmd_enable_channel( - cmd_ctx, *sock, the_kernel_poll_pipe[1]); + ret = cmd_enable_channel(cmd_ctx, *sock, the_kernel_poll_pipe[1]); break; } - case LTTNG_PROCESS_ATTR_TRACKER_ADD_INCLUDE_VALUE: - case LTTNG_PROCESS_ATTR_TRACKER_REMOVE_INCLUDE_VALUE: + case LTTCOMM_SESSIOND_COMMAND_PROCESS_ATTR_TRACKER_ADD_INCLUDE_VALUE: + case LTTCOMM_SESSIOND_COMMAND_PROCESS_ATTR_TRACKER_REMOVE_INCLUDE_VALUE: { struct lttng_dynamic_buffer payload; struct lttng_buffer_view payload_view; - const bool add_value = - cmd_ctx->lsm.cmd_type == - LTTNG_PROCESS_ATTR_TRACKER_ADD_INCLUDE_VALUE; + const bool add_value = cmd_ctx->lsm.cmd_type == + LTTCOMM_SESSIOND_COMMAND_PROCESS_ATTR_TRACKER_ADD_INCLUDE_VALUE; const size_t name_len = - cmd_ctx->lsm.u.process_attr_tracker_add_remove_include_value - .name_len; + cmd_ctx->lsm.u.process_attr_tracker_add_remove_include_value.name_len; const enum lttng_domain_type domain_type = - (enum lttng_domain_type) - cmd_ctx->lsm.domain.type; + (enum lttng_domain_type) cmd_ctx->lsm.domain.type; const enum lttng_process_attr process_attr = - (enum lttng_process_attr) cmd_ctx->lsm.u - .process_attr_tracker_add_remove_include_value - .process_attr; + (enum lttng_process_attr) cmd_ctx->lsm.u + .process_attr_tracker_add_remove_include_value.process_attr; const enum lttng_process_attr_value_type value_type = - (enum lttng_process_attr_value_type) cmd_ctx - ->lsm.u - .process_attr_tracker_add_remove_include_value - .value_type; + (enum lttng_process_attr_value_type) cmd_ctx->lsm.u + .process_attr_tracker_add_remove_include_value.value_type; struct process_attr_value *value; enum lttng_error_code ret_code; long login_name_max; @@ -1423,8 +1457,9 @@ skip_domain: * LOGIN_NAME_MAX is defined to 256. */ ERR("Rejecting process attribute tracker value %s as the provided exceeds the maximal allowed length: argument length = %zu, maximal length = %ld", - add_value ? "addition" : "removal", - name_len, login_name_max); + add_value ? "addition" : "removal", + name_len, + login_name_max); ret = LTTNG_ERR_INVALID; goto error; } @@ -1438,24 +1473,22 @@ skip_domain: ret = lttng_dynamic_buffer_set_size(&payload, name_len); if (ret) { ERR("Failed to allocate buffer to receive payload of %s process attribute tracker value argument", - add_value ? "add" : "remove"); + add_value ? "add" : "remove"); ret = LTTNG_ERR_NOMEM; goto error_add_remove_tracker_value; } - ret = lttcomm_recv_unix_sock( - *sock, payload.data, name_len); + ret = lttcomm_recv_unix_sock(*sock, payload.data, name_len); if (ret <= 0) { ERR("Failed to receive payload of %s process attribute tracker value argument", - add_value ? "add" : "remove"); + add_value ? "add" : "remove"); *sock_error = 1; ret = LTTNG_ERR_INVALID_PROTOCOL; goto error_add_remove_tracker_value; } } - payload_view = lttng_buffer_view_from_dynamic_buffer( - &payload, 0, name_len); + payload_view = lttng_buffer_view_from_dynamic_buffer(&payload, 0, name_len); if (name_len > 0 && !lttng_buffer_view_is_valid(&payload_view)) { ret = LTTNG_ERR_INVALID_PROTOCOL; goto error_add_remove_tracker_value; @@ -1466,11 +1499,13 @@ skip_domain: * attribute tracker that is specified and convert the value to * add/remove to the internal sessiond representation. */ - ret_code = process_attr_value_from_comm(domain_type, - process_attr, value_type, - &cmd_ctx->lsm.u.process_attr_tracker_add_remove_include_value - .integral_value, - &payload_view, &value); + ret_code = process_attr_value_from_comm( + domain_type, + process_attr, + value_type, + &cmd_ctx->lsm.u.process_attr_tracker_add_remove_include_value.integral_value, + &payload_view, + &value); if (ret_code != LTTNG_OK) { ret = ret_code; goto error_add_remove_tracker_value; @@ -1478,39 +1513,34 @@ skip_domain: if (add_value) { ret = cmd_process_attr_tracker_inclusion_set_add_value( - cmd_ctx->session, domain_type, - process_attr, value); + cmd_ctx->session, domain_type, process_attr, value); } else { ret = cmd_process_attr_tracker_inclusion_set_remove_value( - cmd_ctx->session, domain_type, - process_attr, value); + cmd_ctx->session, domain_type, process_attr, value); } process_attr_value_destroy(value); error_add_remove_tracker_value: lttng_dynamic_buffer_reset(&payload); break; } - case LTTNG_PROCESS_ATTR_TRACKER_GET_POLICY: + case LTTCOMM_SESSIOND_COMMAND_PROCESS_ATTR_TRACKER_GET_POLICY: { enum lttng_tracking_policy tracking_policy; const enum lttng_domain_type domain_type = - (enum lttng_domain_type) - cmd_ctx->lsm.domain.type; + (enum lttng_domain_type) cmd_ctx->lsm.domain.type; const enum lttng_process_attr process_attr = - (enum lttng_process_attr) cmd_ctx->lsm.u - .process_attr_tracker_get_tracking_policy - .process_attr; + (enum lttng_process_attr) cmd_ctx->lsm.u + .process_attr_tracker_get_tracking_policy.process_attr; ret = cmd_process_attr_tracker_get_tracking_policy( - cmd_ctx->session, domain_type, process_attr, - &tracking_policy); + cmd_ctx->session, domain_type, process_attr, &tracking_policy); if (ret != LTTNG_OK) { goto error; } uint32_t tracking_policy_u32 = tracking_policy; - ret = setup_lttng_msg_no_cmd_header(cmd_ctx, - &tracking_policy_u32, sizeof(uint32_t)); + ret = setup_lttng_msg_no_cmd_header( + cmd_ctx, &tracking_policy_u32, sizeof(uint32_t)); if (ret < 0) { ret = LTTNG_ERR_NOMEM; goto error; @@ -1518,43 +1548,36 @@ skip_domain: ret = LTTNG_OK; break; } - case LTTNG_PROCESS_ATTR_TRACKER_SET_POLICY: + case LTTCOMM_SESSIOND_COMMAND_PROCESS_ATTR_TRACKER_SET_POLICY: { const enum lttng_tracking_policy tracking_policy = - (enum lttng_tracking_policy) cmd_ctx->lsm.u - .process_attr_tracker_set_tracking_policy - .tracking_policy; + (enum lttng_tracking_policy) cmd_ctx->lsm.u + .process_attr_tracker_set_tracking_policy.tracking_policy; const enum lttng_domain_type domain_type = - (enum lttng_domain_type) - cmd_ctx->lsm.domain.type; + (enum lttng_domain_type) cmd_ctx->lsm.domain.type; const enum lttng_process_attr process_attr = - (enum lttng_process_attr) cmd_ctx->lsm.u - .process_attr_tracker_set_tracking_policy - .process_attr; + (enum lttng_process_attr) cmd_ctx->lsm.u + .process_attr_tracker_set_tracking_policy.process_attr; ret = cmd_process_attr_tracker_set_tracking_policy( - cmd_ctx->session, domain_type, process_attr, - tracking_policy); + cmd_ctx->session, domain_type, process_attr, tracking_policy); if (ret != LTTNG_OK) { goto error; } break; } - case LTTNG_PROCESS_ATTR_TRACKER_GET_INCLUSION_SET: + case LTTCOMM_SESSIOND_COMMAND_PROCESS_ATTR_TRACKER_GET_INCLUSION_SET: { struct lttng_process_attr_values *values; struct lttng_dynamic_buffer reply; const enum lttng_domain_type domain_type = - (enum lttng_domain_type) - cmd_ctx->lsm.domain.type; + (enum lttng_domain_type) cmd_ctx->lsm.domain.type; const enum lttng_process_attr process_attr = - (enum lttng_process_attr) cmd_ctx->lsm.u - .process_attr_tracker_get_inclusion_set - .process_attr; + (enum lttng_process_attr) + cmd_ctx->lsm.u.process_attr_tracker_get_inclusion_set.process_attr; ret = cmd_process_attr_tracker_get_inclusion_set( - cmd_ctx->session, domain_type, process_attr, - &values); + cmd_ctx->session, domain_type, process_attr, &values); if (ret != LTTNG_OK) { goto error; } @@ -1565,8 +1588,7 @@ skip_domain: goto error_tracker_get_inclusion_set; } - ret = setup_lttng_msg_no_cmd_header( - cmd_ctx, reply.data, reply.size); + ret = setup_lttng_msg_no_cmd_header(cmd_ctx, reply.data, reply.size); if (ret < 0) { ret = LTTNG_ERR_NOMEM; goto error_tracker_get_inclusion_set; @@ -1578,16 +1600,20 @@ skip_domain: lttng_dynamic_buffer_reset(&reply); break; } - case LTTNG_ENABLE_EVENT: - case LTTNG_DISABLE_EVENT: + case LTTCOMM_SESSIOND_COMMAND_ENABLE_EVENT: + case LTTCOMM_SESSIOND_COMMAND_DISABLE_EVENT: { struct lttng_event *event; char *filter_expression; struct lttng_event_exclusion *exclusions; struct lttng_bytecode *bytecode; - const enum lttng_error_code ret_code = receive_lttng_event( - cmd_ctx, *sock, sock_error, &event, - &filter_expression, &bytecode, &exclusions); + const enum lttng_error_code ret_code = receive_lttng_event(cmd_ctx, + *sock, + sock_error, + &event, + &filter_expression, + &bytecode, + &exclusions); if (ret_code != LTTNG_OK) { ret = (int) ret_code; @@ -1598,18 +1624,18 @@ skip_domain: * Ownership of filter_expression, exclusions, and bytecode is * always transferred. */ - ret = cmd_ctx->lsm.cmd_type == LTTNG_ENABLE_EVENT ? - cmd_enable_event(cmd_ctx, event, - filter_expression, exclusions, - bytecode, - the_kernel_poll_pipe[1]) : - cmd_disable_event(cmd_ctx, event, - filter_expression, bytecode, - exclusions); + ret = cmd_ctx->lsm.cmd_type == LTTCOMM_SESSIOND_COMMAND_ENABLE_EVENT ? + cmd_enable_event(cmd_ctx, + event, + filter_expression, + exclusions, + bytecode, + the_kernel_poll_pipe[1]) : + cmd_disable_event(cmd_ctx, event, filter_expression, bytecode, exclusions); lttng_event_destroy(event); break; } - case LTTNG_LIST_TRACEPOINTS: + case LTTCOMM_SESSIOND_COMMAND_LIST_TRACEPOINTS: { enum lttng_error_code ret_code; size_t original_payload_size; @@ -1625,52 +1651,52 @@ skip_domain: original_payload_size = cmd_ctx->reply_payload.buffer.size; session_lock_list(); - ret_code = cmd_list_tracepoints(cmd_ctx->lsm.domain.type, - &cmd_ctx->reply_payload); + ret_code = cmd_list_tracepoints(cmd_ctx->lsm.domain.type, &cmd_ctx->reply_payload); session_unlock_list(); if (ret_code != LTTNG_OK) { ret = (int) ret_code; goto error; } - payload_size = cmd_ctx->reply_payload.buffer.size - - command_header_size - original_payload_size; + payload_size = cmd_ctx->reply_payload.buffer.size - command_header_size - + original_payload_size; update_lttng_msg(cmd_ctx, command_header_size, payload_size); ret = LTTNG_OK; break; } - case LTTNG_LIST_TRACEPOINT_FIELDS: + case LTTCOMM_SESSIOND_COMMAND_LIST_TRACEPOINT_FIELDS: { - struct lttng_event_field *fields; - ssize_t nb_fields; + enum lttng_error_code ret_code; + size_t original_payload_size; + size_t payload_size; + const size_t command_header_size = sizeof(struct lttcomm_list_command_header); + + ret = setup_empty_lttng_msg(cmd_ctx); + if (ret) { + ret = LTTNG_ERR_NOMEM; + goto setup_error; + } + + original_payload_size = cmd_ctx->reply_payload.buffer.size; session_lock_list(); - nb_fields = cmd_list_tracepoint_fields(cmd_ctx->lsm.domain.type, - &fields); + ret_code = cmd_list_tracepoint_fields(cmd_ctx->lsm.domain.type, + &cmd_ctx->reply_payload); session_unlock_list(); - if (nb_fields < 0) { - /* Return value is a negative lttng_error_code. */ - ret = -nb_fields; + if (ret_code != LTTNG_OK) { + ret = (int) ret_code; goto error; } - /* - * Setup lttng message with payload size set to the event list size in - * bytes and then copy list into the llm payload. - */ - ret = setup_lttng_msg_no_cmd_header(cmd_ctx, fields, - sizeof(struct lttng_event_field) * nb_fields); - free(fields); - - if (ret < 0) { - goto setup_error; - } + payload_size = cmd_ctx->reply_payload.buffer.size - command_header_size - + original_payload_size; + update_lttng_msg(cmd_ctx, command_header_size, payload_size); ret = LTTNG_OK; break; } - case LTTNG_LIST_SYSCALLS: + case LTTCOMM_SESSIOND_COMMAND_LIST_SYSCALLS: { enum lttng_error_code ret_code; size_t original_payload_size; @@ -1691,14 +1717,14 @@ skip_domain: goto error; } - payload_size = cmd_ctx->reply_payload.buffer.size - - command_header_size - original_payload_size; + payload_size = cmd_ctx->reply_payload.buffer.size - command_header_size - + original_payload_size; update_lttng_msg(cmd_ctx, command_header_size, payload_size); ret = LTTNG_OK; break; } - case LTTNG_SET_CONSUMER_URI: + case LTTCOMM_SESSIOND_COMMAND_SET_CONSUMER_URI: { size_t nb_uri, len; struct lttng_uri *uris; @@ -1711,8 +1737,8 @@ skip_domain: goto error; } - uris = (lttng_uri *) zmalloc(len); - if (uris == NULL) { + uris = calloc(nb_uri); + if (uris == nullptr) { ret = LTTNG_ERR_FATAL; goto error; } @@ -1734,21 +1760,18 @@ skip_domain: goto error; } - break; } - case LTTNG_START_TRACE: + case LTTCOMM_SESSIOND_COMMAND_START_TRACE: { /* * On the first start, if we have a kernel session and we have * enabled time or size-based rotations, we have to make sure * the kernel tracer supports it. */ - if (!cmd_ctx->session->has_been_started && \ - cmd_ctx->session->kernel_session && \ - (cmd_ctx->session->rotate_timer_period || \ - cmd_ctx->session->rotate_size) && \ - !check_rotate_compatible()) { + if (!cmd_ctx->session->has_been_started && cmd_ctx->session->kernel_session && + (cmd_ctx->session->rotate_timer_period || cmd_ctx->session->rotate_size) && + !check_rotate_compatible()) { DBG("Kernel tracer version is not compatible with the rotation feature"); ret = LTTNG_ERR_ROTATION_WRONG_VERSION; goto error; @@ -1756,21 +1779,20 @@ skip_domain: ret = cmd_start_trace(cmd_ctx->session); break; } - case LTTNG_STOP_TRACE: + case LTTCOMM_SESSIOND_COMMAND_STOP_TRACE: { ret = cmd_stop_trace(cmd_ctx->session); break; } - case LTTNG_DESTROY_SESSION: + case LTTCOMM_SESSIOND_COMMAND_DESTROY_SESSION: { - ret = cmd_destroy_session(cmd_ctx->session, - the_notification_thread_handle, sock); + ret = cmd_destroy_session(cmd_ctx->session, sock); break; } - case LTTNG_LIST_DOMAINS: + case LTTCOMM_SESSIOND_COMMAND_LIST_DOMAINS: { ssize_t nb_dom; - struct lttng_domain *domains = NULL; + struct lttng_domain *domains = nullptr; nb_dom = cmd_list_domains(cmd_ctx->session, &domains); if (nb_dom < 0) { @@ -1779,8 +1801,8 @@ skip_domain: goto error; } - ret = setup_lttng_msg_no_cmd_header(cmd_ctx, domains, - nb_dom * sizeof(struct lttng_domain)); + ret = setup_lttng_msg_no_cmd_header( + cmd_ctx, domains, nb_dom * sizeof(struct lttng_domain)); free(domains); if (ret < 0) { @@ -1790,7 +1812,7 @@ skip_domain: ret = LTTNG_OK; break; } - case LTTNG_LIST_CHANNELS: + case LTTCOMM_SESSIOND_COMMAND_LIST_CHANNELS: { enum lttng_error_code ret_code; size_t original_payload_size; @@ -1805,21 +1827,21 @@ skip_domain: original_payload_size = cmd_ctx->reply_payload.buffer.size; - ret_code = cmd_list_channels(cmd_ctx->lsm.domain.type, - cmd_ctx->session, &cmd_ctx->reply_payload); + ret_code = cmd_list_channels( + cmd_ctx->lsm.domain.type, cmd_ctx->session, &cmd_ctx->reply_payload); if (ret_code != LTTNG_OK) { ret = (int) ret_code; goto error; } - payload_size = cmd_ctx->reply_payload.buffer.size - - command_header_size - original_payload_size; + payload_size = cmd_ctx->reply_payload.buffer.size - command_header_size - + original_payload_size; update_lttng_msg(cmd_ctx, command_header_size, payload_size); ret = LTTNG_OK; break; } - case LTTNG_LIST_EVENTS: + case LTTCOMM_SESSIOND_COMMAND_LIST_EVENTS: { enum lttng_error_code ret_code; size_t original_payload_size; @@ -1835,48 +1857,50 @@ skip_domain: original_payload_size = cmd_ctx->reply_payload.buffer.size; ret_code = cmd_list_events(cmd_ctx->lsm.domain.type, - cmd_ctx->session, - cmd_ctx->lsm.u.list.channel_name, &cmd_ctx->reply_payload); + cmd_ctx->session, + cmd_ctx->lsm.u.list.channel_name, + &cmd_ctx->reply_payload); if (ret_code != LTTNG_OK) { ret = (int) ret_code; goto error; } - payload_size = cmd_ctx->reply_payload.buffer.size - - command_header_size - original_payload_size; + payload_size = cmd_ctx->reply_payload.buffer.size - command_header_size - + original_payload_size; update_lttng_msg(cmd_ctx, command_header_size, payload_size); ret = LTTNG_OK; break; } - case LTTNG_LIST_SESSIONS: + case LTTCOMM_SESSIOND_COMMAND_LIST_SESSIONS: { unsigned int nr_sessions; - lttng_session *sessions_payload; - size_t payload_len; + lttng_session *sessions_payload = nullptr; + size_t payload_len = 0; session_lock_list(); - nr_sessions = lttng_sessions_count( - LTTNG_SOCK_GET_UID_CRED(&cmd_ctx->creds), - LTTNG_SOCK_GET_GID_CRED(&cmd_ctx->creds)); + nr_sessions = lttng_sessions_count(LTTNG_SOCK_GET_UID_CRED(&cmd_ctx->creds), + LTTNG_SOCK_GET_GID_CRED(&cmd_ctx->creds)); - payload_len = (sizeof(struct lttng_session) * nr_sessions) + + if (nr_sessions > 0) { + payload_len = (sizeof(struct lttng_session) * nr_sessions) + (sizeof(struct lttng_session_extended) * nr_sessions); - sessions_payload = (lttng_session *) zmalloc(payload_len); + sessions_payload = zmalloc(payload_len); + if (!sessions_payload) { + session_unlock_list(); + ret = -ENOMEM; + goto setup_error; + } - if (!sessions_payload) { - session_unlock_list(); - ret = -ENOMEM; - goto setup_error; + cmd_list_lttng_sessions(sessions_payload, + nr_sessions, + LTTNG_SOCK_GET_UID_CRED(&cmd_ctx->creds), + LTTNG_SOCK_GET_GID_CRED(&cmd_ctx->creds)); } - cmd_list_lttng_sessions(sessions_payload, nr_sessions, - LTTNG_SOCK_GET_UID_CRED(&cmd_ctx->creds), - LTTNG_SOCK_GET_GID_CRED(&cmd_ctx->creds)); session_unlock_list(); - ret = setup_lttng_msg_no_cmd_header(cmd_ctx, sessions_payload, - payload_len); + ret = setup_lttng_msg_no_cmd_header(cmd_ctx, sessions_payload, payload_len); free(sessions_payload); if (ret < 0) { @@ -1886,7 +1910,7 @@ skip_domain: ret = LTTNG_OK; break; } - case LTTNG_REGISTER_CONSUMER: + case LTTCOMM_SESSIOND_COMMAND_REGISTER_CONSUMER: { struct consumer_data *cdata; @@ -1899,11 +1923,11 @@ skip_domain: goto error; } - ret = cmd_register_consumer(cmd_ctx->session, cmd_ctx->lsm.domain.type, - cmd_ctx->lsm.u.reg.path, cdata); + ret = cmd_register_consumer( + cmd_ctx->session, cmd_ctx->lsm.domain.type, cmd_ctx->lsm.u.reg.path, cdata); break; } - case LTTNG_DATA_PENDING: + case LTTCOMM_SESSIOND_COMMAND_DATA_PENDING: { int pending_ret; uint8_t pending_ret_byte; @@ -1935,8 +1959,7 @@ skip_domain: pending_ret_byte = (uint8_t) pending_ret; /* 1 byte to return whether or not data is pending */ - ret = setup_lttng_msg_no_cmd_header(cmd_ctx, - &pending_ret_byte, 1); + ret = setup_lttng_msg_no_cmd_header(cmd_ctx, &pending_ret_byte, 1); if (ret < 0) { goto setup_error; @@ -1945,22 +1968,19 @@ skip_domain: ret = LTTNG_OK; break; } - case LTTNG_SNAPSHOT_ADD_OUTPUT: + case LTTCOMM_SESSIOND_COMMAND_SNAPSHOT_ADD_OUTPUT: { uint32_t snapshot_id; struct lttcomm_lttng_output_id reply; lttng_snapshot_output output = cmd_ctx->lsm.u.snapshot_output.output; - ret = cmd_snapshot_add_output(cmd_ctx->session, - &output, - &snapshot_id); + ret = cmd_snapshot_add_output(cmd_ctx->session, &output, &snapshot_id); if (ret != LTTNG_OK) { goto error; } reply.id = snapshot_id; - ret = setup_lttng_msg_no_cmd_header(cmd_ctx, &reply, - sizeof(reply)); + ret = setup_lttng_msg_no_cmd_header(cmd_ctx, &reply, sizeof(reply)); if (ret < 0) { goto setup_error; } @@ -1969,16 +1989,16 @@ skip_domain: ret = LTTNG_OK; break; } - case LTTNG_SNAPSHOT_DEL_OUTPUT: + case LTTCOMM_SESSIOND_COMMAND_SNAPSHOT_DEL_OUTPUT: { lttng_snapshot_output output = cmd_ctx->lsm.u.snapshot_output.output; ret = cmd_snapshot_del_output(cmd_ctx->session, &output); break; } - case LTTNG_SNAPSHOT_LIST_OUTPUT: + case LTTCOMM_SESSIOND_COMMAND_SNAPSHOT_LIST_OUTPUT: { ssize_t nb_output; - struct lttng_snapshot_output *outputs = NULL; + struct lttng_snapshot_output *outputs = nullptr; nb_output = cmd_snapshot_list_outputs(cmd_ctx->session, &outputs); if (nb_output < 0) { @@ -1987,8 +2007,8 @@ skip_domain: } LTTNG_ASSERT((nb_output > 0 && outputs) || nb_output == 0); - ret = setup_lttng_msg_no_cmd_header(cmd_ctx, outputs, - nb_output * sizeof(struct lttng_snapshot_output)); + ret = setup_lttng_msg_no_cmd_header( + cmd_ctx, outputs, nb_output * sizeof(struct lttng_snapshot_output)); free(outputs); if (ret < 0) { @@ -1998,18 +2018,18 @@ skip_domain: ret = LTTNG_OK; break; } - case LTTNG_SNAPSHOT_RECORD: + case LTTCOMM_SESSIOND_COMMAND_SNAPSHOT_RECORD: { lttng_snapshot_output output = cmd_ctx->lsm.u.snapshot_record.output; - ret = cmd_snapshot_record(cmd_ctx->session, - &output, - cmd_ctx->lsm.u.snapshot_record.wait); + ret = cmd_snapshot_record(cmd_ctx->session, &output, 0); // RFC: set to zero since + // it's ignored by + // cmd_snapshot_record break; } - case LTTNG_CREATE_SESSION_EXT: + case LTTCOMM_SESSIOND_COMMAND_CREATE_SESSION_EXT: { struct lttng_dynamic_buffer payload; - struct lttng_session_descriptor *return_descriptor = NULL; + struct lttng_session_descriptor *return_descriptor = nullptr; lttng_dynamic_buffer_init(&payload); ret = cmd_create_session(cmd_ctx, *sock, &return_descriptor); @@ -2017,16 +2037,14 @@ skip_domain: goto error; } - ret = lttng_session_descriptor_serialize(return_descriptor, - &payload); + ret = lttng_session_descriptor_serialize(return_descriptor, &payload); if (ret) { ERR("Failed to serialize session descriptor in reply to \"create session\" command"); lttng_session_descriptor_destroy(return_descriptor); ret = LTTNG_ERR_NOMEM; goto error; } - ret = setup_lttng_msg_no_cmd_header(cmd_ctx, payload.data, - payload.size); + ret = setup_lttng_msg_no_cmd_header(cmd_ctx, payload.data, payload.size); if (ret) { lttng_session_descriptor_destroy(return_descriptor); ret = LTTNG_ERR_NOMEM; @@ -2037,29 +2055,28 @@ skip_domain: ret = LTTNG_OK; break; } - case LTTNG_SAVE_SESSION: + case LTTCOMM_SESSIOND_COMMAND_SAVE_SESSION: { - ret = cmd_save_sessions(&cmd_ctx->lsm.u.save_session.attr, - &cmd_ctx->creds); + ret = cmd_save_sessions(&cmd_ctx->lsm.u.save_session.attr, &cmd_ctx->creds); break; } - case LTTNG_SET_SESSION_SHM_PATH: + case LTTCOMM_SESSIOND_COMMAND_SET_SESSION_SHM_PATH: { ret = cmd_set_session_shm_path(cmd_ctx->session, - cmd_ctx->lsm.u.set_shm_path.shm_path); + cmd_ctx->lsm.u.set_shm_path.shm_path); break; } - case LTTNG_REGENERATE_METADATA: + case LTTCOMM_SESSIOND_COMMAND_REGENERATE_METADATA: { ret = cmd_regenerate_metadata(cmd_ctx->session); break; } - case LTTNG_REGENERATE_STATEDUMP: + case LTTCOMM_SESSIOND_COMMAND_REGENERATE_STATEDUMP: { ret = cmd_regenerate_statedump(cmd_ctx->session); break; } - case LTTNG_REGISTER_TRIGGER: + case LTTCOMM_SESSIOND_COMMAND_REGISTER_TRIGGER: { struct lttng_trigger *payload_trigger; struct lttng_trigger *return_trigger; @@ -2076,18 +2093,18 @@ skip_domain: goto setup_error; } - ret = receive_lttng_trigger( - cmd_ctx, *sock, sock_error, &payload_trigger); + ret = receive_lttng_trigger(cmd_ctx, *sock, sock_error, &payload_trigger); if (ret != LTTNG_OK) { goto error; } original_reply_payload_size = cmd_ctx->reply_payload.buffer.size; - ret = cmd_register_trigger(&cmd_creds, payload_trigger, - cmd_ctx->lsm.u.trigger.is_trigger_anonymous, - the_notification_thread_handle, - &return_trigger); + ret = cmd_register_trigger(&cmd_creds, + payload_trigger, + cmd_ctx->lsm.u.trigger.is_trigger_anonymous, + the_notification_thread_handle, + &return_trigger); if (ret != LTTNG_OK) { lttng_trigger_put(payload_trigger); goto error; @@ -2102,15 +2119,15 @@ skip_domain: goto error; } - reply_payload_size = cmd_ctx->reply_payload.buffer.size - - original_reply_payload_size; + reply_payload_size = + cmd_ctx->reply_payload.buffer.size - original_reply_payload_size; update_lttng_msg(cmd_ctx, 0, reply_payload_size); ret = LTTNG_OK; break; } - case LTTNG_UNREGISTER_TRIGGER: + case LTTCOMM_SESSIOND_COMMAND_UNREGISTER_TRIGGER: { struct lttng_trigger *payload_trigger; const struct lttng_credentials cmd_creds = { @@ -2118,18 +2135,17 @@ skip_domain: .gid = LTTNG_OPTIONAL_INIT_VALUE(cmd_ctx->creds.gid), }; - ret = receive_lttng_trigger( - cmd_ctx, *sock, sock_error, &payload_trigger); + ret = receive_lttng_trigger(cmd_ctx, *sock, sock_error, &payload_trigger); if (ret != LTTNG_OK) { goto error; } - ret = cmd_unregister_trigger(&cmd_creds, payload_trigger, - the_notification_thread_handle); + ret = cmd_unregister_trigger( + &cmd_creds, payload_trigger, the_notification_thread_handle); lttng_trigger_put(payload_trigger); break; } - case LTTNG_ROTATE_SESSION: + case LTTCOMM_SESSIOND_COMMAND_ROTATE_SESSION: { struct lttng_rotate_session_return rotate_return; @@ -2142,16 +2158,16 @@ skip_domain: goto error; } - ret = cmd_rotate_session(cmd_ctx->session, &rotate_return, - false, - LTTNG_TRACE_CHUNK_COMMAND_TYPE_MOVE_TO_COMPLETED); + ret = cmd_rotate_session(cmd_ctx->session, + &rotate_return, + false, + LTTNG_TRACE_CHUNK_COMMAND_TYPE_MOVE_TO_COMPLETED); if (ret < 0) { ret = -ret; goto error; } - ret = setup_lttng_msg_no_cmd_header(cmd_ctx, &rotate_return, - sizeof(rotate_return)); + ret = setup_lttng_msg_no_cmd_header(cmd_ctx, &rotate_return, sizeof(rotate_return)); if (ret < 0) { ret = -ret; goto error; @@ -2160,20 +2176,21 @@ skip_domain: ret = LTTNG_OK; break; } - case LTTNG_ROTATION_GET_INFO: + case LTTCOMM_SESSIOND_COMMAND_ROTATION_GET_INFO: { struct lttng_rotation_get_info_return get_info_return; memset(&get_info_return, 0, sizeof(get_info_return)); - ret = cmd_rotate_get_info(cmd_ctx->session, &get_info_return, - cmd_ctx->lsm.u.get_rotation_info.rotation_id); + ret = cmd_rotate_get_info(cmd_ctx->session, + &get_info_return, + cmd_ctx->lsm.u.get_rotation_info.rotation_id); if (ret < 0) { ret = -ret; goto error; } - ret = setup_lttng_msg_no_cmd_header(cmd_ctx, &get_info_return, - sizeof(get_info_return)); + ret = setup_lttng_msg_no_cmd_header( + cmd_ctx, &get_info_return, sizeof(get_info_return)); if (ret < 0) { ret = -ret; goto error; @@ -2182,7 +2199,7 @@ skip_domain: ret = LTTNG_OK; break; } - case LTTNG_ROTATION_SET_SCHEDULE: + case LTTCOMM_SESSIOND_COMMAND_ROTATION_SET_SCHEDULE: { bool set_schedule; enum lttng_rotation_schedule_type schedule_type; @@ -2195,19 +2212,19 @@ skip_domain: } set_schedule = cmd_ctx->lsm.u.rotation_set_schedule.set == 1; - schedule_type = (enum lttng_rotation_schedule_type) cmd_ctx->lsm.u.rotation_set_schedule.type; + schedule_type = (enum lttng_rotation_schedule_type) + cmd_ctx->lsm.u.rotation_set_schedule.type; value = cmd_ctx->lsm.u.rotation_set_schedule.value; - ret = cmd_rotation_set_schedule(cmd_ctx->session, set_schedule, - schedule_type, value, - the_notification_thread_handle); + ret = cmd_rotation_set_schedule( + cmd_ctx->session, set_schedule, schedule_type, value); if (ret != LTTNG_OK) { goto error; } break; } - case LTTNG_SESSION_LIST_ROTATION_SCHEDULES: + case LTTCOMM_SESSIOND_COMMAND_SESSION_LIST_ROTATION_SCHEDULES: { lttng_session_list_schedules_return schedules; @@ -2216,8 +2233,7 @@ skip_domain: schedules.size.set = !!cmd_ctx->session->rotate_size; schedules.size.value = cmd_ctx->session->rotate_size; - ret = setup_lttng_msg_no_cmd_header(cmd_ctx, &schedules, - sizeof(schedules)); + ret = setup_lttng_msg_no_cmd_header(cmd_ctx, &schedules, sizeof(schedules)); if (ret < 0) { ret = -ret; goto error; @@ -2226,14 +2242,14 @@ skip_domain: ret = LTTNG_OK; break; } - case LTTNG_CLEAR_SESSION: + case LTTCOMM_SESSIOND_COMMAND_CLEAR_SESSION: { ret = cmd_clear_session(cmd_ctx->session, sock); break; } - case LTTNG_LIST_TRIGGERS: + case LTTCOMM_SESSIOND_COMMAND_LIST_TRIGGERS: { - struct lttng_triggers *return_triggers = NULL; + struct lttng_triggers *return_triggers = nullptr; size_t original_payload_size; size_t payload_size; @@ -2245,15 +2261,13 @@ skip_domain: original_payload_size = cmd_ctx->reply_payload.buffer.size; - ret = cmd_list_triggers(cmd_ctx, the_notification_thread_handle, - &return_triggers); + ret = cmd_list_triggers(cmd_ctx, the_notification_thread_handle, &return_triggers); if (ret != LTTNG_OK) { goto error; } LTTNG_ASSERT(return_triggers); - ret = lttng_triggers_serialize( - return_triggers, &cmd_ctx->reply_payload); + ret = lttng_triggers_serialize(return_triggers, &cmd_ctx->reply_payload); lttng_triggers_destroy(return_triggers); if (ret) { ERR("Failed to serialize triggers in reply to `list triggers` command"); @@ -2261,22 +2275,21 @@ skip_domain: goto error; } - payload_size = cmd_ctx->reply_payload.buffer.size - - original_payload_size; + payload_size = cmd_ctx->reply_payload.buffer.size - original_payload_size; update_lttng_msg(cmd_ctx, 0, payload_size); ret = LTTNG_OK; break; } - case LTTNG_EXECUTE_ERROR_QUERY: + case LTTCOMM_SESSIOND_COMMAND_EXECUTE_ERROR_QUERY: { struct lttng_error_query *query; const struct lttng_credentials cmd_creds = { .uid = LTTNG_OPTIONAL_INIT_VALUE(cmd_ctx->creds.uid), .gid = LTTNG_OPTIONAL_INIT_VALUE(cmd_ctx->creds.gid), }; - struct lttng_error_query_results *results = NULL; + struct lttng_error_query_results *results = nullptr; size_t original_payload_size; size_t payload_size; @@ -2288,22 +2301,20 @@ skip_domain: original_payload_size = cmd_ctx->reply_payload.buffer.size; - ret = receive_lttng_error_query( - cmd_ctx, *sock, sock_error, &query); + ret = receive_lttng_error_query(cmd_ctx, *sock, sock_error, &query); if (ret != LTTNG_OK) { goto error; } - ret = cmd_execute_error_query(&cmd_creds, query, &results, - the_notification_thread_handle); + ret = cmd_execute_error_query( + &cmd_creds, query, &results, the_notification_thread_handle); lttng_error_query_destroy(query); if (ret != LTTNG_OK) { goto error; } LTTNG_ASSERT(results); - ret = lttng_error_query_results_serialize( - results, &cmd_ctx->reply_payload); + ret = lttng_error_query_results_serialize(results, &cmd_ctx->reply_payload); lttng_error_query_results_destroy(results); if (ret) { ERR("Failed to serialize error query result set in reply to `execute error query` command"); @@ -2311,8 +2322,7 @@ skip_domain: goto error; } - payload_size = cmd_ctx->reply_payload.buffer.size - - original_payload_size; + payload_size = cmd_ctx->reply_payload.buffer.size - original_payload_size; update_lttng_msg(cmd_ctx, 0, payload_size); @@ -2328,7 +2338,7 @@ skip_domain: error: if (cmd_ctx->reply_payload.buffer.size == 0) { DBG("Missing llm header, creating one."); - if (setup_lttng_msg_no_cmd_header(cmd_ctx, NULL, 0) < 0) { + if (setup_lttng_msg_no_cmd_header(cmd_ctx, nullptr, 0) < 0) { goto setup_error; } } @@ -2338,7 +2348,7 @@ setup_error: if (cmd_ctx->session) { session_unlock(cmd_ctx->session); session_put(cmd_ctx->session); - cmd_ctx->session = NULL; + cmd_ctx->session = nullptr; } if (need_tracing_session) { session_unlock_list(); @@ -2348,17 +2358,14 @@ init_setup_error: return ret; } -static int create_client_sock(void) +static int create_client_sock() { int ret, client_sock; - const mode_t old_umask = umask(0); /* Create client tool unix socket */ - client_sock = lttcomm_create_unix_sock( - the_config.client_unix_sock_path.value); + client_sock = lttcomm_create_unix_sock(the_config.client_unix_sock_path.value); if (client_sock < 0) { - ERR("Create unix sock failed: %s", - the_config.client_unix_sock_path.value); + ERR("Create unix sock failed: %s", the_config.client_unix_sock_path.value); ret = -1; goto end; } @@ -2367,16 +2374,15 @@ static int create_client_sock(void) ret = utils_set_fd_cloexec(client_sock); if (ret < 0) { ERR("Unable to set CLOEXEC flag to the client Unix socket (fd: %d). " - "Continuing but note that the consumer daemon will have a " - "reference to this socket on exec()", client_sock); + "Continuing but note that the consumer daemon will have a " + "reference to this socket on exec()", + client_sock); } /* File permission MUST be 660 */ - ret = chmod(the_config.client_unix_sock_path.value, - S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP); + ret = chmod(the_config.client_unix_sock_path.value, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP); if (ret < 0) { - ERR("Set file permissions failed: %s", - the_config.client_unix_sock_path.value); + ERR("Set file permissions failed: %s", the_config.client_unix_sock_path.value); PERROR("chmod"); (void) lttcomm_close_unix_sock(client_sock); ret = -1; @@ -2385,7 +2391,6 @@ static int create_client_sock(void) DBG("Created client socket (fd = %i)", client_sock); ret = client_sock; end: - umask(old_umask); return ret; } @@ -2396,7 +2401,7 @@ static void cleanup_client_thread(void *data) lttng_pipe_destroy(quit_pipe); } -static void thread_init_cleanup(void *data) +static void thread_init_cleanup(void *data __attribute__((unused))) { set_thread_status(false); } @@ -2407,9 +2412,9 @@ static void thread_init_cleanup(void *data) */ static void *thread_manage_clients(void *data) { - int sock = -1, ret, i, pollfd, err = -1; + int sock = -1, ret, i, err = -1; int sock_error; - uint32_t revents, nb_fd; + uint32_t nb_fd; struct lttng_poll_event events; const int client_sock = thread_state.client_sock; struct lttng_pipe *quit_pipe = (lttng_pipe *) data; @@ -2422,7 +2427,7 @@ static void *thread_manage_clients(void *data) is_root = (getuid() == 0); - pthread_cleanup_push(thread_init_cleanup, NULL); + pthread_cleanup_push(thread_init_cleanup, nullptr); rcu_register_thread(); @@ -2451,7 +2456,7 @@ static void *thread_manage_clients(void *data) } /* Add thread quit pipe */ - ret = lttng_poll_add(&events, thread_quit_pipe_fd, LPOLLIN | LPOLLERR); + ret = lttng_poll_add(&events, thread_quit_pipe_fd, LPOLLIN); if (ret < 0) { goto error; } @@ -2471,13 +2476,13 @@ static void *thread_manage_clients(void *data) health_code_update(); - while (1) { + while (true) { const struct cmd_completion_handler *cmd_completion_handler; cmd_ctx.creds.uid = UINT32_MAX; cmd_ctx.creds.gid = UINT32_MAX; cmd_ctx.creds.pid = 0; - cmd_ctx.session = NULL; + cmd_ctx.session = nullptr; lttng_payload_clear(&cmd_ctx.reply_payload); cmd_ctx.lttng_msg_size = 0; @@ -2501,25 +2506,28 @@ static void *thread_manage_clients(void *data) nb_fd = ret; for (i = 0; i < nb_fd; i++) { - revents = LTTNG_POLL_GETEV(&events, i); - pollfd = LTTNG_POLL_GETFD(&events, i); + /* Fetch once the poll data. */ + const auto revents = LTTNG_POLL_GETEV(&events, i); + const auto pollfd = LTTNG_POLL_GETFD(&events, i); health_code_update(); + /* Activity on thread quit pipe, exiting. */ if (pollfd == thread_quit_pipe_fd) { + DBG("Activity on thread quit pipe"); err = 0; goto exit; + } + + /* Event on the registration socket */ + if (revents & LPOLLIN) { + continue; + } else if (revents & (LPOLLERR | LPOLLHUP | LPOLLRDHUP)) { + ERR("Client socket poll error"); + goto error; } else { - /* Event on the registration socket */ - if (revents & LPOLLIN) { - continue; - } else if (revents & (LPOLLERR | LPOLLHUP | LPOLLRDHUP)) { - ERR("Client socket poll error"); - goto error; - } else { - ERR("Unexpected poll events %u for sock %d", revents, pollfd); - goto error; - } + ERR("Unexpected poll events %u for sock %d", revents, pollfd); + goto error; } } @@ -2552,8 +2560,8 @@ static void *thread_manage_clients(void *data) * the client. */ DBG("Receiving data from client ..."); - ret = lttcomm_recv_creds_unix_sock(sock, &cmd_ctx.lsm, - sizeof(struct lttcomm_session_msg), &cmd_ctx.creds); + ret = lttcomm_recv_creds_unix_sock( + sock, &cmd_ctx.lsm, sizeof(struct lttcomm_session_msg), &cmd_ctx.creds); if (ret != sizeof(struct lttcomm_session_msg)) { DBG("Incomplete recv() from client... continuing"); ret = close(sock); @@ -2576,31 +2584,45 @@ static void *thread_manage_clients(void *data) * informations for the client. The command context struct contains * everything this function may needs. */ - ret = process_client_msg(&cmd_ctx, &sock, &sock_error); - rcu_thread_offline(); - if (ret < 0) { - if (sock >= 0) { - ret = close(sock); - if (ret) { - PERROR("close"); + try { + ret = process_client_msg(&cmd_ctx, &sock, &sock_error); + rcu_thread_offline(); + if (ret < 0) { + if (sock >= 0) { + ret = close(sock); + if (ret) { + PERROR("close"); + } } + sock = -1; + /* + * TODO: Inform client somehow of the fatal error. At + * this point, ret < 0 means that a zmalloc failed + * (ENOMEM). Error detected but still accept + * command, unless a socket error has been + * detected. + */ + continue; } - sock = -1; - /* - * TODO: Inform client somehow of the fatal error. At - * this point, ret < 0 means that a zmalloc failed - * (ENOMEM). Error detected but still accept - * command, unless a socket error has been - * detected. - */ - continue; + } catch (const std::bad_alloc& ex) { + WARN_FMT("Failed to allocate memory while handling client request: {}", + ex.what()); + ret = LTTNG_ERR_NOMEM; + } catch (const lttng::ctl::error& ex) { + WARN_FMT("Client request failed: {}", ex.what()); + ret = ex.code(); + } catch (const std::exception& ex) { + WARN_FMT("Client request failed: {}", ex.what()); + ret = LTTNG_ERR_UNK; } if (ret < LTTNG_OK || ret >= LTTNG_ERR_NR) { WARN("Command returned an invalid status code, returning unknown error: " - "command type = %s (%d), ret = %d", - lttcomm_sessiond_command_str((lttcomm_sessiond_command) cmd_ctx.lsm.cmd_type), - cmd_ctx.lsm.cmd_type, ret); + "command type = %s (%d), ret = %d", + lttcomm_sessiond_command_str( + (lttcomm_sessiond_command) cmd_ctx.lsm.cmd_type), + cmd_ctx.lsm.cmd_type, + ret); ret = LTTNG_ERR_UNK; } @@ -2608,8 +2630,7 @@ static void *thread_manage_clients(void *data) if (cmd_completion_handler) { enum lttng_error_code completion_code; - completion_code = cmd_completion_handler->run( - cmd_completion_handler->data); + completion_code = cmd_completion_handler->run(cmd_completion_handler->data); if (completion_code != LTTNG_OK) { continue; } @@ -2619,11 +2640,9 @@ static void *thread_manage_clients(void *data) if (sock >= 0) { struct lttng_payload_view view = - lttng_payload_view_from_payload( - &cmd_ctx.reply_payload, - 0, -1); - struct lttcomm_lttng_msg *llm = (typeof( - llm)) cmd_ctx.reply_payload.buffer.data; + lttng_payload_view_from_payload(&cmd_ctx.reply_payload, 0, -1); + struct lttcomm_lttng_msg *llm = + (typeof(llm)) cmd_ctx.reply_payload.buffer.data; LTTNG_ASSERT(cmd_ctx.reply_payload.buffer.size >= sizeof(*llm)); LTTNG_ASSERT(cmd_ctx.lttng_msg_size == cmd_ctx.reply_payload.buffer.size); @@ -2631,9 +2650,9 @@ static void *thread_manage_clients(void *data) llm->fd_count = lttng_payload_view_get_fd_handle_count(&view); DBG("Sending response (size: %d, retcode: %s (%d))", - cmd_ctx.lttng_msg_size, - lttng_strerror(-llm->ret_code), - llm->ret_code); + cmd_ctx.lttng_msg_size, + lttng_strerror(-llm->ret_code), + llm->ret_code); ret = send_unix_sock(sock, &view); if (ret < 0) { ERR("Failed to send data back to client"); @@ -2679,11 +2698,10 @@ error_create_poll: DBG("Client thread dying"); lttng_payload_reset(&cmd_ctx.reply_payload); rcu_unregister_thread(); - return NULL; + return nullptr; } -static -bool shutdown_client_thread(void *thread_data) +static bool shutdown_client_thread(void *thread_data) { struct lttng_pipe *client_quit_pipe = (lttng_pipe *) thread_data; const int write_fd = lttng_pipe_get_writefd(client_quit_pipe); @@ -2691,11 +2709,11 @@ bool shutdown_client_thread(void *thread_data) return notify_thread_pipe(write_fd) == 1; } -struct lttng_thread *launch_client_thread(void) +struct lttng_thread *launch_client_thread() { bool thread_running; struct lttng_pipe *client_quit_pipe; - struct lttng_thread *thread = NULL; + struct lttng_thread *thread = nullptr; int client_sock_fd = -1; sem_init(&thread_state.ready, 0, 0); @@ -2711,16 +2729,16 @@ struct lttng_thread *launch_client_thread(void) thread_state.client_sock = client_sock_fd; thread = lttng_thread_create("Client management", - thread_manage_clients, - shutdown_client_thread, - cleanup_client_thread, - client_quit_pipe); + thread_manage_clients, + shutdown_client_thread, + cleanup_client_thread, + client_quit_pipe); if (!thread) { goto error; } /* The client thread now owns the client sock fd and the quit pipe. */ client_sock_fd = -1; - client_quit_pipe = NULL; + client_quit_pipe = nullptr; /* * This thread is part of the threads that need to be fully @@ -2739,5 +2757,5 @@ error: } lttng_thread_put(thread); cleanup_client_thread(client_quit_pipe); - return NULL; + return nullptr; }