X-Git-Url: https://git.lttng.org/?a=blobdiff_plain;f=src%2Fbin%2Flttng-sessiond%2Fclient.c;h=c798234ae90cc0a48eb68fbb9c236122c514caf2;hb=7a0b90089e190dcd7a891a8b63242c273124b6d7;hp=9e4d446aec60359c0311856339ddebb349d17bd5;hpb=19f912db83b1c2763c0708ef3e86d4c69841d3c3;p=lttng-tools.git diff --git a/src/bin/lttng-sessiond/client.c b/src/bin/lttng-sessiond/client.c index 9e4d446ae..c798234ae 100644 --- a/src/bin/lttng-sessiond/client.c +++ b/src/bin/lttng-sessiond/client.c @@ -1,5 +1,5 @@ /* - * Copyright (C) 2011 David Goulet + * Copyright (C) 2011 EfficiOS Inc. * Copyright (C) 2011 Mathieu Desnoyers * Copyright (C) 2013 Jérémie Galarneau * @@ -9,20 +9,19 @@ #include "common/buffer-view.h" #include "common/compat/socket.h" -#include "common/dynamic-buffer.h" #include "common/dynamic-array.h" -#include "common/payload.h" -#include "common/payload-view.h" +#include "common/dynamic-buffer.h" #include "common/fd-handle.h" -#include "common/sessiond-comm/sessiond-comm.h" -#include "common/payload.h" #include "common/payload-view.h" +#include "common/payload.h" +#include "common/sessiond-comm/sessiond-comm.h" #include "lttng/lttng-error.h" #include "lttng/tracker.h" #include #include #include #include +#include #include #include #include @@ -30,19 +29,21 @@ #include #include #include +#include #include #include +#include "agent-thread.h" +#include "clear.h" #include "client.h" -#include "lttng-sessiond.h" #include "cmd.h" +#include "health-sessiond.h" #include "kernel.h" +#include "lttng-sessiond.h" +#include "manage-consumer.h" #include "save.h" -#include "health-sessiond.h" #include "testpoint.h" #include "utils.h" -#include "manage-consumer.h" -#include "clear.h" static bool is_root; @@ -207,7 +208,7 @@ static pid_t spawn_consumerd(struct consumer_data *consumer_data) /* * Exec consumerd. */ - if (config.verbose_consumer) { + if (the_config.verbose_consumer) { verbosity = "--verbose"; } else if (lttng_opt_quiet) { verbosity = "--quiet"; @@ -223,35 +224,37 @@ 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", 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", config.consumerd32_bin_path.value ? : "NULL"); - if (stat(config.consumerd64_bin_path.value, &st) == 0) { + 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 = config.consumerd64_bin_path.value; + consumer_to_use = the_config.consumerd64_bin_path.value; } else if (stat(INSTALL_BIN_PATH "/" DEFAULT_CONSUMERD_FILE, &st) == 0) { DBG3("Found location #2"); consumer_to_use = INSTALL_BIN_PATH "/" DEFAULT_CONSUMERD_FILE; - } else if (config.consumerd32_bin_path.value && - stat(config.consumerd32_bin_path.value, &st) == 0) { + } else if (the_config.consumerd32_bin_path.value && + stat(the_config.consumerd32_bin_path.value, &st) == 0) { DBG3("Found location #3"); - consumer_to_use = config.consumerd32_bin_path.value; + consumer_to_use = the_config.consumerd32_bin_path.value; } else { DBG("Could not find any valid consumerd executable"); 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", config.tracing_group_name.value, - NULL); + (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: { - if (config.consumerd64_lib_dir.value) { + if (the_config.consumerd64_lib_dir.value) { const char *tmp; size_t tmplen; char *tmpnew; @@ -260,13 +263,13 @@ static pid_t spawn_consumerd(struct consumer_data *consumer_data) if (!tmp) { tmp = ""; } - tmplen = strlen(config.consumerd64_lib_dir.value) + 1 /* : */ + strlen(tmp); + tmplen = strlen(the_config.consumerd64_lib_dir.value) + 1 /* : */ + strlen(tmp); tmpnew = zmalloc(tmplen + 1 /* \0 */); if (!tmpnew) { ret = -ENOMEM; goto error; } - strcat(tmpnew, config.consumerd64_lib_dir.value); + strcat(tmpnew, the_config.consumerd64_lib_dir.value); if (tmp[0] != '\0') { strcat(tmpnew, ":"); strcat(tmpnew, tmp); @@ -278,17 +281,22 @@ static pid_t spawn_consumerd(struct consumer_data *consumer_data) goto error; } } - DBG("Using 64-bit UST consumer at: %s", config.consumerd64_bin_path.value); - (void) execl(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", config.tracing_group_name.value, + DBG("Using 64-bit UST consumer at: %s", + 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); break; } case LTTNG_CONSUMER32_UST: { - if (config.consumerd32_lib_dir.value) { + if (the_config.consumerd32_lib_dir.value) { const char *tmp; size_t tmplen; char *tmpnew; @@ -297,13 +305,13 @@ static pid_t spawn_consumerd(struct consumer_data *consumer_data) if (!tmp) { tmp = ""; } - tmplen = strlen(config.consumerd32_lib_dir.value) + 1 /* : */ + strlen(tmp); + tmplen = strlen(the_config.consumerd32_lib_dir.value) + 1 /* : */ + strlen(tmp); tmpnew = zmalloc(tmplen + 1 /* \0 */); if (!tmpnew) { ret = -ENOMEM; goto error; } - strcat(tmpnew, config.consumerd32_lib_dir.value); + strcat(tmpnew, the_config.consumerd32_lib_dir.value); if (tmp[0] != '\0') { strcat(tmpnew, ":"); strcat(tmpnew, tmp); @@ -315,11 +323,16 @@ static pid_t spawn_consumerd(struct consumer_data *consumer_data) goto error; } } - DBG("Using 32-bit UST consumer at: %s", config.consumerd32_bin_path.value); - (void) execl(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", config.tracing_group_name.value, + DBG("Using 32-bit UST consumer at: %s", + 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); break; } @@ -597,128 +610,187 @@ static unsigned int lttng_sessions_count(uid_t uid, gid_t gid) return i; } -static int receive_userspace_probe(struct command_ctx *cmd_ctx, int sock, - int *sock_error, struct lttng_event *event) +static enum lttng_error_code receive_lttng_trigger(struct command_ctx *cmd_ctx, + int sock, + int *sock_error, + struct lttng_trigger **_trigger) { - int fd = -1, ret; - struct lttng_userspace_probe_location *probe_location; - struct lttng_payload probe_location_payload; - struct fd_handle *handle = NULL; - - /* - * Create a payload to store the serialized version of the probe - * location. - */ - lttng_payload_init(&probe_location_payload); + 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; - ret = lttng_dynamic_buffer_set_size(&probe_location_payload.buffer, - cmd_ctx->lsm.u.enable.userspace_probe_location_len); + 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); if (ret) { - ret = LTTNG_ERR_NOMEM; - goto error; - } - - /* - * Receive the probe location. - */ - ret = lttcomm_recv_unix_sock(sock, probe_location_payload.buffer.data, - probe_location_payload.buffer.size); - if (ret <= 0) { - DBG("Nothing recv() from client var len data... continuing"); - *sock_error = 1; - ret = LTTNG_ERR_PROBE_LOCATION_INVAL; - goto error; + ret_code = LTTNG_ERR_NOMEM; + goto end; } - /* - * Receive the file descriptor to the target binary from the client. - */ - DBG("Receiving userspace probe target FD from client ..."); - ret = lttcomm_recv_fds_unix_sock(sock, &fd, 1); - if (ret <= 0) { - DBG("Nothing recv() from client userspace probe fd... continuing"); + 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; - ret = LTTNG_ERR_PROBE_LOCATION_INVAL; - goto error; + ret_code = LTTNG_ERR_INVALID_PROTOCOL; + goto end; } - handle = fd_handle_create(fd); - if (!handle) { - ret = LTTNG_ERR_NOMEM; - goto error; + /* 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)) { + 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); + 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); + ret_code = LTTNG_ERR_FATAL; + *sock_error = 1; + goto end; + } } - /* Transferred to the handle. */ - fd = -1; + /* Deserialize trigger. */ + { + struct lttng_payload_view view = + lttng_payload_view_from_payload( + &trigger_payload, 0, -1); - ret = lttng_payload_push_fd_handle(&probe_location_payload, handle); - if (ret) { - ERR("Failed to add userspace probe file descriptor to payload"); - ret = LTTNG_ERR_NOMEM; - goto error; + 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); + goto end; + } } - fd_handle_put(handle); - handle = NULL; + *_trigger = trigger; + ret_code = LTTNG_OK; - { - struct lttng_payload_view view = lttng_payload_view_from_payload( - &probe_location_payload, 0, -1); +end: + lttng_payload_reset(&trigger_payload); + return ret_code; +} + +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 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; - /* Extract the probe location from the serialized version. */ - ret = lttng_userspace_probe_location_create_from_payload( - &view, &probe_location); + lttng_payload_init(&query_payload); + query_len = (size_t) cmd_ctx->lsm.u.error_query.length; + ret = lttng_dynamic_buffer_set_size(&query_payload.buffer, query_len); + if (ret) { + ret_code = LTTNG_ERR_NOMEM; + goto end; } - if (ret < 0) { - WARN("Failed to create a userspace probe location from the received buffer"); - ret = LTTNG_ERR_PROBE_LOCATION_INVAL; - goto error; + + 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; + ret_code = LTTNG_ERR_INVALID_PROTOCOL; + goto end; } - /* Attach the probe location to the event. */ - ret = lttng_event_set_userspace_probe_location(event, probe_location); - if (ret) { - ret = LTTNG_ERR_PROBE_LOCATION_INVAL; - goto error; + /* 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)) { + 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); + 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); + ret_code = LTTNG_ERR_FATAL; + *sock_error = 1; + goto end; + } } -error: - if (fd >= 0) { - if (close(fd)) { - PERROR("Failed to close userspace probe location binary fd"); + /* Deserialize error query. */ + { + struct lttng_payload_view view = + lttng_payload_view_from_payload( + &query_payload, 0, -1); + + 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; } } - fd_handle_put(handle); - lttng_payload_reset(&probe_location_payload); - return ret; + *_query = query; + ret_code = LTTNG_OK; + +end: + lttng_payload_reset(&query_payload); + return ret_code; } -static enum lttng_error_code receive_lttng_trigger(struct command_ctx *cmd_ctx, +static enum lttng_error_code receive_lttng_event(struct command_ctx *cmd_ctx, int sock, int *sock_error, - struct lttng_trigger **_trigger) + struct lttng_event **out_event, + char **out_filter_expression, + struct lttng_bytecode **out_bytecode, + struct lttng_event_exclusion **out_exclusion) { int ret; - size_t trigger_len; + size_t event_len; ssize_t sock_recv_len; enum lttng_error_code ret_code; - struct lttng_payload trigger_payload; - struct lttng_trigger *trigger; + 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) { + event_len = (size_t) cmd_ctx->lsm.u.enable.length; + } else if (cmd_ctx->lsm.cmd_type == LTTNG_DISABLE_EVENT) { + event_len = (size_t) cmd_ctx->lsm.u.disable.length; + } else { + abort(); + } - 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(&event_payload.buffer, event_len); if (ret) { ret_code = LTTNG_ERR_NOMEM; goto end; } 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, 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; ret_code = LTTNG_ERR_INVALID_PROTOCOL; goto end; @@ -727,16 +799,16 @@ 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); + 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 trigger in command payload: expected fd count = %u, ret = %d", + 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); 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", + ERR("Failed to receive file descriptors for event in command payload: expected fd count = %u, ret = %d", cmd_ctx->lsm.fd_count, (int) ret); ret_code = LTTNG_ERR_FATAL; *sock_error = 1; @@ -744,24 +816,113 @@ static enum lttng_error_code receive_lttng_trigger(struct command_ctx *cmd_ctx, } } - /* Deserialize trigger. */ + /* Deserialize event. */ { - struct lttng_payload_view view = + ssize_t len; + struct lttng_payload_view event_view = lttng_payload_view_from_payload( - &trigger_payload, 0, -1); + &event_payload, 0, -1); - 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; + 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; } } - *_trigger = trigger; + *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; } @@ -782,7 +943,8 @@ static int check_rotate_compatible(void) { int ret = 1; - if (kernel_tracer_version.major != 2 || 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; } @@ -844,6 +1006,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((enum 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(cmd_ctx->lsm.cmd_type), cmd_ctx->lsm.cmd_type); @@ -874,6 +1043,7 @@ static int process_client_msg(struct command_ctx *cmd_ctx, int *sock, case LTTNG_SESSION_LIST_ROTATION_SCHEDULES: case LTTNG_CLEAR_SESSION: case LTTNG_LIST_TRIGGERS: + case LTTNG_EXECUTE_ERROR_QUERY: need_domain = false; break; default: @@ -884,6 +1054,7 @@ static int process_client_msg(struct command_ctx *cmd_ctx, int *sock, switch (cmd_ctx->lsm.cmd_type) { case LTTNG_REGISTER_TRIGGER: case LTTNG_UNREGISTER_TRIGGER: + case LTTNG_EXECUTE_ERROR_QUERY: need_consumerd = false; break; default: @@ -891,8 +1062,8 @@ static int process_client_msg(struct command_ctx *cmd_ctx, int *sock, break; } - if (config.no_kernel && need_domain - && cmd_ctx->lsm.domain.type == LTTNG_DOMAIN_KERNEL) { + if (the_config.no_kernel && need_domain && + cmd_ctx->lsm.domain.type == LTTNG_DOMAIN_KERNEL) { if (!is_root) { ret = LTTNG_ERR_NEED_ROOT_SESSIOND; } else { @@ -903,13 +1074,13 @@ 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) { - pthread_mutex_lock(&kconsumer_data.pid_mutex); - if (kconsumer_data.pid > 0) { + pthread_mutex_lock(&the_kconsumer_data.pid_mutex); + if (the_kconsumer_data.pid > 0) { ret = LTTNG_ERR_KERN_CONSUMER_FAIL; - pthread_mutex_unlock(&kconsumer_data.pid_mutex); + pthread_mutex_unlock(&the_kconsumer_data.pid_mutex); goto error; } - pthread_mutex_unlock(&kconsumer_data.pid_mutex); + pthread_mutex_unlock(&the_kconsumer_data.pid_mutex); } /* @@ -933,6 +1104,7 @@ static int process_client_msg(struct command_ctx *cmd_ctx, int *sock, case LTTNG_ROTATION_GET_INFO: case LTTNG_REGISTER_TRIGGER: case LTTNG_LIST_TRIGGERS: + case LTTNG_EXECUTE_ERROR_QUERY: break; default: /* Setup lttng message with no payload */ @@ -954,6 +1126,7 @@ static int process_client_msg(struct command_ctx *cmd_ctx, int *sock, case LTTNG_REGISTER_TRIGGER: case LTTNG_UNREGISTER_TRIGGER: case LTTNG_LIST_TRIGGERS: + case LTTNG_EXECUTE_ERROR_QUERY: need_tracing_session = false; break; default: @@ -1032,8 +1205,8 @@ 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(&kernel_consumerd_state) == - CONSUMER_ERROR) { + if (need_consumerd && uatomic_read(&the_kernel_consumerd_state) == + CONSUMER_ERROR) { ret = LTTNG_ERR_NO_KERNCONSUMERD; goto error; } @@ -1049,25 +1222,25 @@ static int process_client_msg(struct command_ctx *cmd_ctx, int *sock, } /* Start the kernel consumer daemon */ - pthread_mutex_lock(&kconsumer_data.pid_mutex); - if (kconsumer_data.pid == 0 && + pthread_mutex_lock(&the_kconsumer_data.pid_mutex); + if (the_kconsumer_data.pid == 0 && cmd_ctx->lsm.cmd_type != LTTNG_REGISTER_CONSUMER) { - pthread_mutex_unlock(&kconsumer_data.pid_mutex); - ret = start_consumerd(&kconsumer_data); + pthread_mutex_unlock(&the_kconsumer_data.pid_mutex); + ret = start_consumerd(&the_kconsumer_data); if (ret < 0) { ret = LTTNG_ERR_KERN_CONSUMER_FAIL; goto error; } - uatomic_set(&kernel_consumerd_state, CONSUMER_STARTED); + uatomic_set(&the_kernel_consumerd_state, CONSUMER_STARTED); } else { - pthread_mutex_unlock(&kconsumer_data.pid_mutex); + pthread_mutex_unlock(&the_kconsumer_data.pid_mutex); } /* * The consumer was just spawned so we need to add the socket to * the consumer output of the session if exist. */ - ret = consumer_create_socket(&kconsumer_data, + ret = consumer_create_socket(&the_kconsumer_data, cmd_ctx->session->kernel_session->consumer); if (ret < 0) { goto error; @@ -1078,6 +1251,11 @@ static int process_client_msg(struct command_ctx *cmd_ctx, int *sock, case LTTNG_DOMAIN_JUL: case LTTNG_DOMAIN_LOG4J: case LTTNG_DOMAIN_PYTHON: + if (!agent_tracing_is_enabled()) { + ret = LTTNG_ERR_AGENT_TRACING_DISABLED; + goto error; + } + /* Fallthrough */ case LTTNG_DOMAIN_UST: { if (!ust_app_supported()) { @@ -1086,8 +1264,9 @@ 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(&ust_consumerd_state) == - CONSUMER_ERROR) { + if (need_consumerd && + uatomic_read(&the_ust_consumerd_state) == + CONSUMER_ERROR) { ret = LTTNG_ERR_NO_USTCONSUMERD; goto error; } @@ -1104,58 +1283,58 @@ static int process_client_msg(struct command_ctx *cmd_ctx, int *sock, /* Start the UST consumer daemons */ /* 64-bit */ - pthread_mutex_lock(&ustconsumer64_data.pid_mutex); - if (config.consumerd64_bin_path.value && - ustconsumer64_data.pid == 0 && + 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) { - pthread_mutex_unlock(&ustconsumer64_data.pid_mutex); - ret = start_consumerd(&ustconsumer64_data); + pthread_mutex_unlock(&the_ustconsumer64_data.pid_mutex); + ret = start_consumerd(&the_ustconsumer64_data); if (ret < 0) { ret = LTTNG_ERR_UST_CONSUMER64_FAIL; - uatomic_set(&ust_consumerd64_fd, -EINVAL); + uatomic_set(&the_ust_consumerd64_fd, -EINVAL); goto error; } - uatomic_set(&ust_consumerd64_fd, ustconsumer64_data.cmd_sock); - uatomic_set(&ust_consumerd_state, CONSUMER_STARTED); + uatomic_set(&the_ust_consumerd64_fd, the_ustconsumer64_data.cmd_sock); + uatomic_set(&the_ust_consumerd_state, CONSUMER_STARTED); } else { - pthread_mutex_unlock(&ustconsumer64_data.pid_mutex); + pthread_mutex_unlock(&the_ustconsumer64_data.pid_mutex); } /* * Setup socket for consumer 64 bit. No need for atomic access * since it was set above and can ONLY be set in this thread. */ - ret = consumer_create_socket(&ustconsumer64_data, + ret = consumer_create_socket(&the_ustconsumer64_data, cmd_ctx->session->ust_session->consumer); if (ret < 0) { goto error; } /* 32-bit */ - pthread_mutex_lock(&ustconsumer32_data.pid_mutex); - if (config.consumerd32_bin_path.value && - ustconsumer32_data.pid == 0 && + 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) { - pthread_mutex_unlock(&ustconsumer32_data.pid_mutex); - ret = start_consumerd(&ustconsumer32_data); + pthread_mutex_unlock(&the_ustconsumer32_data.pid_mutex); + ret = start_consumerd(&the_ustconsumer32_data); if (ret < 0) { ret = LTTNG_ERR_UST_CONSUMER32_FAIL; - uatomic_set(&ust_consumerd32_fd, -EINVAL); + uatomic_set(&the_ust_consumerd32_fd, -EINVAL); goto error; } - uatomic_set(&ust_consumerd32_fd, ustconsumer32_data.cmd_sock); - uatomic_set(&ust_consumerd_state, CONSUMER_STARTED); + uatomic_set(&the_ust_consumerd32_fd, the_ustconsumer32_data.cmd_sock); + uatomic_set(&the_ust_consumerd_state, CONSUMER_STARTED); } else { - pthread_mutex_unlock(&ustconsumer32_data.pid_mutex); + pthread_mutex_unlock(&the_ustconsumer32_data.pid_mutex); } /* * Setup socket for consumer 32 bit. No need for atomic access * since it was set above and can ONLY be set in this thread. */ - ret = consumer_create_socket(&ustconsumer32_data, + ret = consumer_create_socket(&the_ustconsumer32_data, cmd_ctx->session->ust_session->consumer); if (ret < 0) { goto error; @@ -1178,13 +1357,13 @@ skip_domain: case LTTNG_DOMAIN_LOG4J: case LTTNG_DOMAIN_PYTHON: case LTTNG_DOMAIN_UST: - if (uatomic_read(&ust_consumerd_state) != CONSUMER_STARTED) { + if (uatomic_read(&the_ust_consumerd_state) != CONSUMER_STARTED) { ret = LTTNG_ERR_NO_USTCONSUMERD; goto error; } break; case LTTNG_DOMAIN_KERNEL: - if (uatomic_read(&kernel_consumerd_state) != CONSUMER_STARTED) { + if (uatomic_read(&the_kernel_consumerd_state) != CONSUMER_STARTED) { ret = LTTNG_ERR_NO_KERNCONSUMERD; goto error; } @@ -1227,74 +1406,18 @@ skip_domain: switch (cmd_ctx->lsm.cmd_type) { case LTTNG_ADD_CONTEXT: { - /* - * 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 = 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; - - context_name = 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; - } + 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); - 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. - */ - ret = cmd_add_context(cmd_ctx->session, - cmd_ctx->lsm.domain.type, - cmd_ctx->lsm.u.context.channel_name, - ALIGNED_CONST_PTR(cmd_ctx->lsm.u.context.ctx), - 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: @@ -1303,48 +1426,10 @@ error_add_context: cmd_ctx->lsm.u.disable.channel_name); break; } - case LTTNG_DISABLE_EVENT: - { - - /* - * FIXME: handle filter; for now we just receive the filter's - * bytecode along with the filter expression which are sent by - * liblttng-ctl and discard them. - * - * This fixes an issue where the client may block while sending - * the filter payload and encounter an error because the session - * daemon closes the socket without ever handling this data. - */ - size_t count = cmd_ctx->lsm.u.disable.expression_len + - cmd_ctx->lsm.u.disable.bytecode_len; - - if (count) { - char data[LTTNG_FILTER_MAX_LEN]; - - DBG("Discarding disable event command payload of size %zu", count); - while (count) { - ret = lttcomm_recv_unix_sock(*sock, data, - count > sizeof(data) ? sizeof(data) : count); - if (ret < 0) { - goto error; - } - - count -= (size_t) ret; - } - } - ret = cmd_disable_event(cmd_ctx->session, cmd_ctx->lsm.domain.type, - cmd_ctx->lsm.u.disable.channel_name, - ALIGNED_CONST_PTR(cmd_ctx->lsm.u.disable.event)); - break; - } case LTTNG_ENABLE_CHANNEL: { - cmd_ctx->lsm.u.channel.chan.attr.extended.ptr = - (struct lttng_channel_extended *) &cmd_ctx->lsm.u.channel.extended; - ret = cmd_enable_channel(cmd_ctx->session, - ALIGNED_CONST_PTR(cmd_ctx->lsm.domain), - ALIGNED_CONST_PTR(cmd_ctx->lsm.u.channel.chan), - 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: @@ -1546,225 +1631,123 @@ error_add_context: break; } case LTTNG_ENABLE_EVENT: + case LTTNG_DISABLE_EVENT: { - struct lttng_event *ev = NULL; - struct lttng_event_exclusion *exclusion = NULL; - struct lttng_filter_bytecode *bytecode = NULL; - char *filter_expression = NULL; - - /* Handle exclusion events and receive it from the client. */ - if (cmd_ctx->lsm.u.enable.exclusion_count > 0) { - size_t count = cmd_ctx->lsm.u.enable.exclusion_count; - - exclusion = zmalloc(sizeof(struct lttng_event_exclusion) + - (count * LTTNG_SYMBOL_NAME_LEN)); - if (!exclusion) { - ret = LTTNG_ERR_EXCLUSION_NOMEM; - goto error; - } - - DBG("Receiving var len exclusion event list from client ..."); - exclusion->count = count; - ret = lttcomm_recv_unix_sock(*sock, exclusion->names, - count * LTTNG_SYMBOL_NAME_LEN); - if (ret <= 0) { - DBG("Nothing recv() from client var len data... continuing"); - *sock_error = 1; - free(exclusion); - ret = LTTNG_ERR_EXCLUSION_INVAL; - goto error; - } - } - - /* Get filter expression from client. */ - if (cmd_ctx->lsm.u.enable.expression_len > 0) { - size_t expression_len = - cmd_ctx->lsm.u.enable.expression_len; - - if (expression_len > LTTNG_FILTER_MAX_LEN) { - ret = LTTNG_ERR_FILTER_INVAL; - free(exclusion); - goto error; - } + 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); - filter_expression = zmalloc(expression_len); - if (!filter_expression) { - free(exclusion); - ret = LTTNG_ERR_FILTER_NOMEM; - goto error; - } - - /* Receive var. len. data */ - DBG("Receiving var len filter's expression from client ..."); - ret = lttcomm_recv_unix_sock(*sock, filter_expression, - expression_len); - if (ret <= 0) { - DBG("Nothing recv() from client var len data... continuing"); - *sock_error = 1; - free(filter_expression); - free(exclusion); - ret = LTTNG_ERR_FILTER_INVAL; - goto error; - } - } - - /* Handle filter and get bytecode from client. */ - if (cmd_ctx->lsm.u.enable.bytecode_len > 0) { - size_t bytecode_len = cmd_ctx->lsm.u.enable.bytecode_len; - - if (bytecode_len > LTTNG_FILTER_MAX_LEN) { - ret = LTTNG_ERR_FILTER_INVAL; - free(filter_expression); - free(exclusion); - goto error; - } - - bytecode = zmalloc(bytecode_len); - if (!bytecode) { - free(filter_expression); - free(exclusion); - ret = LTTNG_ERR_FILTER_NOMEM; - goto error; - } - - /* Receive var. len. data */ - DBG("Receiving var len filter's bytecode from client ..."); - ret = lttcomm_recv_unix_sock(*sock, bytecode, bytecode_len); - if (ret <= 0) { - DBG("Nothing recv() from client var len data... continuing"); - *sock_error = 1; - free(filter_expression); - free(bytecode); - free(exclusion); - ret = LTTNG_ERR_FILTER_INVAL; - goto error; - } - - if ((bytecode->len + sizeof(*bytecode)) != bytecode_len) { - free(filter_expression); - free(bytecode); - free(exclusion); - ret = LTTNG_ERR_FILTER_INVAL; - goto error; - } - } - - ev = lttng_event_copy(ALIGNED_CONST_PTR(cmd_ctx->lsm.u.enable.event)); - if (!ev) { - DBG("Failed to copy event: %s", - cmd_ctx->lsm.u.enable.event.name); - free(filter_expression); - free(bytecode); - free(exclusion); - ret = LTTNG_ERR_NOMEM; + if (ret_code != LTTNG_OK) { + ret = (int) ret_code; goto error; } - - if (cmd_ctx->lsm.u.enable.userspace_probe_location_len > 0) { - /* Expect a userspace probe description. */ - ret = receive_userspace_probe(cmd_ctx, *sock, sock_error, ev); - if (ret) { - free(filter_expression); - free(bytecode); - free(exclusion); - lttng_event_destroy(ev); - goto error; - } - } - - ret = cmd_enable_event(cmd_ctx->session, - ALIGNED_CONST_PTR(cmd_ctx->lsm.domain), - cmd_ctx->lsm.u.enable.channel_name, - ev, - filter_expression, bytecode, exclusion, - kernel_poll_pipe[1]); - lttng_event_destroy(ev); + /* + * 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); + lttng_event_destroy(event); break; } case LTTNG_LIST_TRACEPOINTS: { - struct lttng_event *events; - ssize_t nb_events; + 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_events = cmd_list_tracepoints(cmd_ctx->lsm.domain.type, &events); + ret_code = cmd_list_tracepoints(cmd_ctx->lsm.domain.type, + &cmd_ctx->reply_payload); session_unlock_list(); - if (nb_events < 0) { - /* Return value is a negative lttng_error_code. */ - ret = -nb_events; + 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, events, - sizeof(struct lttng_event) * nb_events); - free(events); - - 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_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: { - struct lttng_event *events; - ssize_t nb_events; + 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); - nb_events = cmd_list_syscalls(&events); - if (nb_events < 0) { - /* Return value is a negative lttng_error_code. */ - ret = -nb_events; - goto error; + ret = setup_empty_lttng_msg(cmd_ctx); + if (ret) { + ret = LTTNG_ERR_NOMEM; + goto setup_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, events, - sizeof(struct lttng_event) * nb_events); - free(events); + original_payload_size = cmd_ctx->reply_payload.buffer.size; - if (ret < 0) { - goto setup_error; + ret_code = cmd_list_syscalls(&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; + update_lttng_msg(cmd_ctx, command_header_size, payload_size); + ret = LTTNG_OK; break; } @@ -1834,8 +1817,7 @@ error_add_context: case LTTNG_DESTROY_SESSION: { ret = cmd_destroy_session(cmd_ctx->session, - notification_thread_handle, - sock); + the_notification_thread_handle, sock); break; } case LTTNG_LIST_DOMAINS: @@ -1863,34 +1845,39 @@ error_add_context: } case LTTNG_LIST_CHANNELS: { - ssize_t payload_size; - struct lttng_channel *channels = NULL; + 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); - payload_size = cmd_list_channels(cmd_ctx->lsm.domain.type, - cmd_ctx->session, &channels); - if (payload_size < 0) { - /* Return value is a negative lttng_error_code. */ - ret = -payload_size; - goto error; + ret = setup_empty_lttng_msg(cmd_ctx); + if (ret) { + ret = LTTNG_ERR_NOMEM; + goto setup_error; } - ret = setup_lttng_msg_no_cmd_header(cmd_ctx, channels, - payload_size); - free(channels); + original_payload_size = cmd_ctx->reply_payload.buffer.size; - if (ret < 0) { - goto setup_error; + 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; + update_lttng_msg(cmd_ctx, command_header_size, payload_size); + ret = LTTNG_OK; break; } case LTTNG_LIST_EVENTS: { - ssize_t list_ret; - struct lttcomm_event_command_header cmd_header = {}; + 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) { @@ -1900,20 +1887,17 @@ error_add_context: original_payload_size = cmd_ctx->reply_payload.buffer.size; - /* Extended infos are included at the end of the payload. */ - list_ret = cmd_list_events(cmd_ctx->lsm.domain.type, + ret_code = cmd_list_events(cmd_ctx->lsm.domain.type, cmd_ctx->session, - cmd_ctx->lsm.u.list.channel_name, - &cmd_ctx->reply_payload); - if (list_ret < 0) { - /* Return value is a negative lttng_error_code. */ - ret = -list_ret; + 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 - - sizeof(cmd_header) - original_payload_size; - update_lttng_msg(cmd_ctx, sizeof(cmd_header), payload_size); + command_header_size - original_payload_size; + update_lttng_msg(cmd_ctx, command_header_size, payload_size); ret = LTTNG_OK; break; @@ -1961,7 +1945,7 @@ error_add_context: switch (cmd_ctx->lsm.domain.type) { case LTTNG_DOMAIN_KERNEL: - cdata = &kconsumer_data; + cdata = &the_kconsumer_data; break; default: ret = LTTNG_ERR_UND; @@ -2152,7 +2136,9 @@ error_add_context: original_reply_payload_size = cmd_ctx->reply_payload.buffer.size; ret = cmd_register_trigger(&cmd_creds, payload_trigger, - notification_thread_handle, &return_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; @@ -2190,7 +2176,7 @@ error_add_context: } ret = cmd_unregister_trigger(&cmd_creds, payload_trigger, - notification_thread_handle); + the_notification_thread_handle); lttng_trigger_put(payload_trigger); break; } @@ -2263,11 +2249,9 @@ error_add_context: 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, - notification_thread_handle); + ret = cmd_rotation_set_schedule(cmd_ctx->session, set_schedule, + schedule_type, value, + the_notification_thread_handle); if (ret != LTTNG_OK) { goto error; } @@ -2312,8 +2296,8 @@ error_add_context: original_payload_size = cmd_ctx->reply_payload.buffer.size; - ret = cmd_list_triggers(cmd_ctx, - notification_thread_handle, &return_triggers); + ret = cmd_list_triggers(cmd_ctx, the_notification_thread_handle, + &return_triggers); if (ret != LTTNG_OK) { goto error; } @@ -2336,6 +2320,57 @@ error_add_context: ret = LTTNG_OK; break; } + case LTTNG_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; + size_t original_payload_size; + size_t payload_size; + + 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; + + 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); + lttng_error_query_destroy(query); + if (ret != LTTNG_OK) { + goto error; + } + + assert(results); + 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"); + ret = LTTNG_ERR_NOMEM; + goto error; + } + + payload_size = cmd_ctx->reply_payload.buffer.size - + original_payload_size; + + update_lttng_msg(cmd_ctx, 0, payload_size); + + ret = LTTNG_OK; + + break; + } default: ret = LTTNG_ERR_UND; break; @@ -2367,12 +2402,13 @@ 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(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", config.client_unix_sock_path.value); + ERR("Create unix sock failed: %s", + the_config.client_unix_sock_path.value); ret = -1; goto end; } @@ -2386,10 +2422,11 @@ static int create_client_sock(void) } /* File permission MUST be 660 */ - ret = chmod(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", - config.client_unix_sock_path.value); + the_config.client_unix_sock_path.value); PERROR("chmod"); (void) lttcomm_close_unix_sock(client_sock); ret = -1; @@ -2398,7 +2435,6 @@ static int create_client_sock(void) DBG("Created client socket (fd = %i)", client_sock); ret = client_sock; end: - umask(old_umask); return ret; } @@ -2439,7 +2475,7 @@ static void *thread_manage_clients(void *data) rcu_register_thread(); - health_register(health_sessiond, HEALTH_SESSIOND_TYPE_CMD); + health_register(the_health_sessiond, HEALTH_SESSIOND_TYPE_CMD); health_code_update(); @@ -2610,6 +2646,14 @@ static void *thread_manage_clients(void *data) continue; } + 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(cmd_ctx.lsm.cmd_type), + cmd_ctx.lsm.cmd_type, ret); + ret = LTTNG_ERR_UNK; + } + cmd_completion_handler = cmd_pop_completion_handler(); if (cmd_completion_handler) { enum lttng_error_code completion_code; @@ -2669,7 +2713,7 @@ error: error_listen: error_create_poll: - unlink(config.client_unix_sock_path.value); + unlink(the_config.client_unix_sock_path.value); ret = close(client_sock); if (ret) { PERROR("close"); @@ -2680,7 +2724,7 @@ error_create_poll: ERR("Health error occurred in %s", __func__); } - health_unregister(health_sessiond); + health_unregister(the_health_sessiond); DBG("Client thread dying"); lttng_payload_reset(&cmd_ctx.reply_payload);