X-Git-Url: https://git.lttng.org/?a=blobdiff_plain;f=src%2Fbin%2Flttng-sessiond%2Fclient.cpp;h=3a83f06b9d4ef862f5d8acf6a7439686bcf1b103;hb=37a5ef391d8d282fb8c8978e4761413b69d56072;hp=189c8eb34f4e9968408bc0789d1f83cf4f0122db;hpb=8ddd72efb54e568ddead0aa3fbc05a3ced24da7d;p=lttng-tools.git diff --git a/src/bin/lttng-sessiond/client.cpp b/src/bin/lttng-sessiond/client.cpp index 189c8eb34..3a83f06b9 100644 --- a/src/bin/lttng-sessiond/client.cpp +++ b/src/bin/lttng-sessiond/client.cpp @@ -7,25 +7,25 @@ * */ -#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 "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 "lttng/lttng-error.h" #include "lttng/tracker.h" -#include -#include -#include -#include -#include -#include -#include -#include -#include +#include +#include +#include +#include +#include +#include +#include +#include +#include #include #include #include @@ -33,25 +33,27 @@ #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 { +#include "agent-thread.hpp" +#include "clear.hpp" +#include "client.hpp" +#include "cmd.hpp" +#include "health-sessiond.hpp" +#include "kernel.hpp" +#include "lttng-sessiond.hpp" +#include "manage-consumer.hpp" +#include "save.hpp" +#include "testpoint.hpp" +#include "utils.hpp" + +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) { @@ -264,7 +266,7 @@ static pid_t spawn_consumerd(struct consumer_data *consumer_data) tmp = ""; } tmplen = strlen(the_config.consumerd64_lib_dir.value) + 1 /* : */ + strlen(tmp); - tmpnew = (char *) zmalloc(tmplen + 1 /* \0 */); + tmpnew = zmalloc(tmplen + 1 /* \0 */); if (!tmpnew) { ret = -ENOMEM; goto error; @@ -306,7 +308,7 @@ static pid_t spawn_consumerd(struct consumer_data *consumer_data) tmp = ""; } tmplen = strlen(the_config.consumerd32_lib_dir.value) + 1 /* : */ + strlen(tmp); - tmpnew = (char *) zmalloc(tmplen + 1 /* \0 */); + tmpnew = zmalloc(tmplen + 1 /* \0 */); if (!tmpnew) { ret = -ENOMEM; goto error; @@ -583,7 +585,8 @@ 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; @@ -763,11 +766,15 @@ static enum lttng_error_code receive_lttng_event(struct command_ctx *cmd_ctx, ssize_t sock_recv_len; enum lttng_error_code ret_code; struct lttng_payload event_payload; + struct lttng_event *local_event = NULL; + char *local_filter_expression = NULL; + struct lttng_bytecode *local_bytecode = NULL; + struct lttng_event_exclusion *local_exclusion = NULL; 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(); @@ -810,23 +817,111 @@ 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); - 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"); + len = lttng_event_create_from_payload(&event_view, &local_event, + &local_exclusion, &local_filter_expression, + &local_bytecode); + + 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 = NULL; + local_exclusion = NULL; + local_filter_expression = NULL; + local_bytecode = NULL; + 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) +{ + int ret; + 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 = NULL; + + lttng_payload_init(&event_context_payload); + + 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); + if (sock_recv_len < 0 || sock_recv_len != event_context_len) { + ERR("Failed to receive event context in command payload"); + *sock_error = 1; + ret_code = LTTNG_ERR_INVALID_PROTOCOL; + goto end; + } + + /* Deserialize event. */ + { + ssize_t len; + struct lttng_payload_view event_context_view = + 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 (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 = NULL; + ret_code = LTTNG_OK; + +end: + lttng_event_context_destroy(context); + lttng_payload_reset(&event_context_payload); return ret_code; } @@ -908,6 +1003,13 @@ static int process_client_msg(struct command_ctx *cmd_ctx, int *sock, 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); @@ -915,28 +1017,28 @@ static int process_client_msg(struct command_ctx *cmd_ctx, int *sock, *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: @@ -945,9 +1047,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: @@ -966,7 +1068,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; @@ -982,22 +1084,22 @@ static int process_client_msg(struct command_ctx *cmd_ctx, int *sock, * 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: + 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 */ @@ -1010,16 +1112,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: @@ -1048,8 +1150,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) { @@ -1117,7 +1219,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) { @@ -1179,7 +1281,7 @@ static int process_client_msg(struct command_ctx *cmd_ctx, int *sock, 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) { + 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) { @@ -1208,7 +1310,7 @@ static int process_client_msg(struct command_ctx *cmd_ctx, int *sock, 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) { + 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) { @@ -1241,8 +1343,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; @@ -1297,101 +1399,42 @@ skip_domain: /* Process by command type */ switch (cmd_ctx->lsm.cmd_type) { - case LTTNG_ADD_CONTEXT: + case LTTCOMM_SESSIOND_COMMAND_ADD_CONTEXT: { - lttng_event_context ctx; - - /* - * An LTTNG_ADD_CONTEXT command might have a supplementary - * payload if the context being added is an application context. - */ - if (cmd_ctx->lsm.u.context.ctx.ctx == - LTTNG_EVENT_CONTEXT_APP_CONTEXT) { - char *provider_name = NULL, *context_name = NULL; - size_t provider_name_len = - cmd_ctx->lsm.u.context.provider_name_len; - size_t context_name_len = - cmd_ctx->lsm.u.context.context_name_len; - - if (provider_name_len == 0 || context_name_len == 0) { - /* - * Application provider and context names MUST - * be provided. - */ - ret = -LTTNG_ERR_INVALID; - goto error; - } - - provider_name = (char *) zmalloc(provider_name_len + 1); - if (!provider_name) { - ret = -LTTNG_ERR_NOMEM; - goto error; - } - cmd_ctx->lsm.u.context.ctx.u.app_ctx.provider_name = - provider_name; + struct lttng_event_context *event_context = NULL; + const enum lttng_error_code ret_code = + receive_lttng_event_context( + cmd_ctx, *sock, sock_error, &event_context); - context_name = (char *) zmalloc(context_name_len + 1); - if (!context_name) { - ret = -LTTNG_ERR_NOMEM; - goto error_add_context; - } - cmd_ctx->lsm.u.context.ctx.u.app_ctx.ctx_name = - context_name; - - ret = lttcomm_recv_unix_sock(*sock, provider_name, - provider_name_len); - if (ret < 0) { - goto error_add_context; - } - - ret = lttcomm_recv_unix_sock(*sock, context_name, - context_name_len); - if (ret < 0) { - goto error_add_context; - } - } - - /* - * cmd_add_context assumes ownership of the provider and context - * names. - */ - ctx = cmd_ctx->lsm.u.context.ctx; - ret = cmd_add_context(cmd_ctx->session, - cmd_ctx->lsm.domain.type, - cmd_ctx->lsm.u.context.channel_name, - &ctx, - the_kernel_poll_pipe[1]); - - cmd_ctx->lsm.u.context.ctx.u.app_ctx.provider_name = NULL; - cmd_ctx->lsm.u.context.ctx.u.app_ctx.ctx_name = NULL; -error_add_context: - free(cmd_ctx->lsm.u.context.ctx.u.app_ctx.provider_name); - free(cmd_ctx->lsm.u.context.ctx.u.app_ctx.ctx_name); - if (ret < 0) { + if (ret_code != LTTNG_OK) { + ret = (int) ret_code; goto error; } + + ret = cmd_add_context(cmd_ctx, event_context, the_kernel_poll_pipe[1]); + 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); break; } - case LTTNG_ENABLE_CHANNEL: + case LTTCOMM_SESSIOND_COMMAND_ENABLE_CHANNEL: { 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; + 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; @@ -1495,7 +1538,7 @@ error_add_context: 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 = @@ -1523,7 +1566,7 @@ error_add_context: 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 @@ -1545,7 +1588,7 @@ error_add_context: } 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; @@ -1583,8 +1626,8 @@ error_add_context: 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; @@ -1603,7 +1646,7 @@ error_add_context: * Ownership of filter_expression, exclusions, and bytecode is * always transferred. */ - ret = cmd_ctx->lsm.cmd_type == LTTNG_ENABLE_EVENT ? + ret = cmd_ctx->lsm.cmd_type == LTTCOMM_SESSIOND_COMMAND_ENABLE_EVENT ? cmd_enable_event(cmd_ctx, event, filter_expression, exclusions, bytecode, @@ -1614,7 +1657,7 @@ error_add_context: 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; @@ -1645,37 +1688,38 @@ error_add_context: 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; @@ -1703,7 +1747,7 @@ error_add_context: 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; @@ -1716,7 +1760,7 @@ error_add_context: goto error; } - uris = (lttng_uri *) zmalloc(len); + uris = calloc(nb_uri); if (uris == NULL) { ret = LTTNG_ERR_FATAL; goto error; @@ -1742,7 +1786,7 @@ error_add_context: break; } - case LTTNG_START_TRACE: + case LTTCOMM_SESSIOND_COMMAND_START_TRACE: { /* * On the first start, if we have a kernel session and we have @@ -1761,18 +1805,18 @@ error_add_context: 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); break; } - case LTTNG_LIST_DOMAINS: + case LTTCOMM_SESSIOND_COMMAND_LIST_DOMAINS: { ssize_t nb_dom; struct lttng_domain *domains = NULL; @@ -1795,7 +1839,7 @@ error_add_context: 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; @@ -1824,7 +1868,7 @@ error_add_context: 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; @@ -1854,34 +1898,38 @@ error_add_context: 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)); - payload_len = (sizeof(struct lttng_session) * nr_sessions) + - (sizeof(struct lttng_session_extended) * nr_sessions); - sessions_payload = (lttng_session *) zmalloc(payload_len); + if (nr_sessions > 0) { + payload_len = (sizeof(struct lttng_session) * + nr_sessions) + + (sizeof(struct lttng_session_extended) * + nr_sessions); + 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) { @@ -1891,7 +1939,7 @@ error_add_context: ret = LTTNG_OK; break; } - case LTTNG_REGISTER_CONSUMER: + case LTTCOMM_SESSIOND_COMMAND_REGISTER_CONSUMER: { struct consumer_data *cdata; @@ -1908,7 +1956,7 @@ error_add_context: 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; @@ -1950,7 +1998,7 @@ error_add_context: 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; @@ -1974,13 +2022,13 @@ error_add_context: 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; @@ -2003,15 +2051,14 @@ error_add_context: 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); + &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; @@ -2042,29 +2089,29 @@ error_add_context: 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); 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); 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; @@ -2115,7 +2162,7 @@ error_add_context: 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 = { @@ -2134,7 +2181,7 @@ error_add_context: lttng_trigger_put(payload_trigger); break; } - case LTTNG_ROTATE_SESSION: + case LTTCOMM_SESSIOND_COMMAND_ROTATE_SESSION: { struct lttng_rotate_session_return rotate_return; @@ -2165,7 +2212,7 @@ error_add_context: 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; @@ -2187,7 +2234,7 @@ error_add_context: 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; @@ -2212,7 +2259,7 @@ error_add_context: break; } - case LTTNG_SESSION_LIST_ROTATION_SCHEDULES: + case LTTCOMM_SESSIOND_COMMAND_SESSION_LIST_ROTATION_SCHEDULES: { lttng_session_list_schedules_return schedules; @@ -2231,12 +2278,12 @@ error_add_context: 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; size_t original_payload_size; @@ -2274,7 +2321,7 @@ error_add_context: 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 = { @@ -2356,7 +2403,6 @@ init_setup_error: static int create_client_sock(void) { int ret, client_sock; - const mode_t old_umask = umask(0); /* Create client tool unix socket */ client_sock = lttcomm_create_unix_sock( @@ -2390,7 +2436,6 @@ static int create_client_sock(void) DBG("Created client socket (fd = %i)", client_sock); ret = client_sock; end: - umask(old_umask); return ret; } @@ -2401,7 +2446,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); }