X-Git-Url: https://git.liburcu.org/?a=blobdiff_plain;f=src%2Fbin%2Flttng-sessiond%2Fclient.c;h=e7e66a6e7af06e7dd6dd641ff64ebe4b0e79343f;hb=997edb99904a51565b70fe77e56e9bba06136ac1;hp=84a177b9cc814ee868168a40719ed2a02a6763f3;hpb=700741dccd632e2520da055406582f39ab403795;p=lttng-tools.git diff --git a/src/bin/lttng-sessiond/client.c b/src/bin/lttng-sessiond/client.c index 84a177b9c..e7e66a6e7 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,18 +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; @@ -92,7 +94,11 @@ static int setup_lttng_msg(struct command_ctx *cmd_ctx, .data_size = payload_len, }; - lttng_dynamic_buffer_set_size(&cmd_ctx->reply_payload.buffer, 0); + ret = lttng_dynamic_buffer_set_size(&cmd_ctx->reply_payload.buffer, 0); + if (ret) { + goto end; + } + lttng_dynamic_pointer_array_clear(&cmd_ctx->reply_payload._fd_handles); cmd_ctx->lttng_msg_size = total_msg_size; @@ -133,7 +139,10 @@ static int setup_empty_lttng_msg(struct command_ctx *cmd_ctx) int ret; const struct lttcomm_lttng_msg llm = {}; - lttng_dynamic_buffer_set_size(&cmd_ctx->reply_payload.buffer, 0); + ret = lttng_dynamic_buffer_set_size(&cmd_ctx->reply_payload.buffer, 0); + if (ret) { + goto end; + } /* Append place-holder reply header. */ ret = lttng_dynamic_buffer_append( @@ -199,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"; @@ -215,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; @@ -252,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); @@ -270,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; @@ -289,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); @@ -307,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; } @@ -572,15 +593,14 @@ static unsigned int lttng_sessions_count(uid_t uid, gid_t gid) struct ltt_session *session; const struct ltt_session_list *session_list = session_get_list(); - DBG("Counting number of available session for UID %d GID %d", - uid, gid); + DBG("Counting number of available session for UID %d", uid); 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, gid) && + if (session_access_ok(session, uid) && !session->destroyed) { i++; } @@ -590,101 +610,282 @@ 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); - - ret = lttng_dynamic_buffer_set_size(&probe_location_payload.buffer, - cmd_ctx->lsm.u.enable.userspace_probe_location_len); + 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; + + 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; + ret_code = LTTNG_ERR_NOMEM; + goto end; } - /* - * 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_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; } - /* - * 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_error = 1; - 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, &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; + } } - handle = fd_handle_create(fd); - if (!handle) { - ret = LTTNG_ERR_NOMEM; - goto error; + /* Deserialize trigger. */ + { + struct lttng_payload_view view = + lttng_payload_view_from_payload( + &trigger_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; + lttng_trigger_put(trigger); + goto end; + } } - /* Transferred to the handle. */ - fd = -1; + *_trigger = trigger; + ret_code = LTTNG_OK; - ret = lttng_payload_push_fd_handle(&probe_location_payload, handle); +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; + + 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) { - ERR("Failed to add userspace probe file descriptor to payload"); - ret = LTTNG_ERR_NOMEM; - goto error; + ret_code = LTTNG_ERR_NOMEM; + goto end; } - fd_handle_put(handle); - handle = NULL; + 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; + } + /* 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; + } + } + + /* Deserialize error query. */ { - struct lttng_payload_view view = lttng_payload_view_from_payload( - &probe_location_payload, 0, -1); + 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; + } + } + + *_query = query; + ret_code = LTTNG_OK; - /* Extract the probe location from the serialized version. */ - ret = lttng_userspace_probe_location_create_from_payload( - &view, &probe_location); +end: + lttng_payload_reset(&query_payload); + return ret_code; +} + +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 ret; + size_t event_len; + ssize_t sock_recv_len; + enum lttng_error_code ret_code; + struct lttng_payload event_payload; + + 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(); } - if (ret < 0) { - WARN("Failed to create a userspace probe location from the received buffer"); - ret = LTTNG_ERR_PROBE_LOCATION_INVAL; - goto error; + + 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, 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; + } + + /* 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)) { + 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 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; + goto end; + } + } + + /* Deserialize event. */ + { + 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"); + 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); + ret_code = LTTNG_OK; + +end: + lttng_payload_reset(&event_payload); + 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; + + lttng_payload_init(&event_context_payload); + + ret = lttng_dynamic_buffer_set_size(&event_context_payload.buffer, + event_context_len); if (ret) { - ret = LTTNG_ERR_PROBE_LOCATION_INVAL; - goto error; + ret_code = LTTNG_ERR_NOMEM; + goto end; } -error: - if (fd >= 0) { - if (close(fd)) { - PERROR("Failed to close userspace probe location binary fd"); + 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. */ + { + struct lttng_payload_view event_context_view = + lttng_payload_view_from_payload( + &event_context_payload, 0, -1); + + 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"); + ret_code = LTTNG_ERR_INVALID_PROTOCOL; + goto end; } } - fd_handle_put(handle); - lttng_payload_reset(&probe_location_payload); - return ret; + ret_code = LTTNG_OK; + +end: + lttng_payload_reset(&event_context_payload); + return ret_code; } /* @@ -704,7 +905,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; } @@ -762,10 +964,13 @@ static int process_client_msg(struct command_ctx *cmd_ctx, int *sock, int *sock_error) { int ret = LTTNG_OK; - int need_tracing_session = 1; - int need_domain; + bool need_tracing_session = true; + bool need_domain; + bool need_consumerd; - DBG("Processing client command %d", cmd_ctx->lsm.cmd_type); + DBG("Processing client command '%s\' (%d)", + lttcomm_sessiond_command_str(cmd_ctx->lsm.cmd_type), + cmd_ctx->lsm.cmd_type); assert(!rcu_read_ongoing()); @@ -787,21 +992,33 @@ static int process_client_msg(struct command_ctx *cmd_ctx, int *sock, case LTTNG_SET_SESSION_SHM_PATH: case LTTNG_REGENERATE_METADATA: case LTTNG_REGENERATE_STATEDUMP: - case LTTNG_REGISTER_TRIGGER: - case LTTNG_UNREGISTER_TRIGGER: case LTTNG_ROTATE_SESSION: case LTTNG_ROTATION_GET_INFO: case LTTNG_ROTATION_SET_SCHEDULE: case LTTNG_SESSION_LIST_ROTATION_SCHEDULES: case LTTNG_CLEAR_SESSION: - need_domain = 0; + case LTTNG_LIST_TRIGGERS: + case LTTNG_EXECUTE_ERROR_QUERY: + need_domain = false; + break; + default: + need_domain = true; + } + + /* Needs a functioning consumerd? */ + switch (cmd_ctx->lsm.cmd_type) { + case LTTNG_REGISTER_TRIGGER: + case LTTNG_UNREGISTER_TRIGGER: + case LTTNG_EXECUTE_ERROR_QUERY: + need_consumerd = false; break; default: - need_domain = 1; + need_consumerd = true; + 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 { @@ -812,13 +1029,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); } /* @@ -840,6 +1057,9 @@ static int process_client_msg(struct command_ctx *cmd_ctx, int *sock, 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: break; default: /* Setup lttng message with no payload */ @@ -860,7 +1080,9 @@ static int process_client_msg(struct command_ctx *cmd_ctx, int *sock, case LTTNG_SAVE_SESSION: case LTTNG_REGISTER_TRIGGER: case LTTNG_UNREGISTER_TRIGGER: - need_tracing_session = 0; + case LTTNG_LIST_TRIGGERS: + case LTTNG_EXECUTE_ERROR_QUERY: + need_tracing_session = false; break; default: DBG("Getting session %s by name", cmd_ctx->lsm.session.name); @@ -938,7 +1160,8 @@ static int process_client_msg(struct command_ctx *cmd_ctx, int *sock, } /* Consumer is in an ERROR state. Report back to client */ - if (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; } @@ -954,25 +1177,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; @@ -983,14 +1206,22 @@ 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()) { ret = LTTNG_ERR_NO_UST; goto error; } + /* Consumer is in an ERROR state. Report back to client */ - if (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; } @@ -1007,58 +1238,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; @@ -1081,13 +1312,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; } @@ -1099,13 +1330,12 @@ skip_domain: } /* - * Check that the UID or GID match that of the tracing session. + * Check that the UID matches that of the tracing session. * The root user can interact with all sessions. */ if (need_tracing_session) { if (!session_access_ok(cmd_ctx->session, - LTTNG_SOCK_GET_UID_CRED(&cmd_ctx->creds), - LTTNG_SOCK_GET_GID_CRED(&cmd_ctx->creds)) || + LTTNG_SOCK_GET_UID_CRED(&cmd_ctx->creds)) || cmd_ctx->session->destroyed) { ret = LTTNG_ERR_EPERM; goto error; @@ -1131,74 +1361,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; - } + struct lttng_event_context *event_context; + const enum lttng_error_code ret_code = + receive_lttng_event_context( + cmd_ctx, *sock, sock_error, &event_context); - 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; - } - - 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: @@ -1207,48 +1381,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: @@ -1276,9 +1412,17 @@ error_add_context: .value_type; struct process_attr_value *value; enum lttng_error_code ret_code; + long login_name_max; + + login_name_max = sysconf(_SC_LOGIN_NAME_MAX); + if (login_name_max < 0) { + PERROR("Failed to get _SC_LOGIN_NAME_MAX system configuration"); + ret = LTTNG_ERR_INVALID; + goto error; + } /* Receive remaining variable length payload if applicable. */ - if (name_len > LOGIN_NAME_MAX) { + if (name_len > login_name_max) { /* * POSIX mandates user and group names that are at least * 8 characters long. Note that although shadow-utils @@ -1286,9 +1430,9 @@ error_add_context: * limit (from bits/utmp.h, UT_NAMESIZE), * 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 = %d", + 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); + name_len, login_name_max); ret = LTTNG_ERR_INVALID; goto error; } @@ -1320,6 +1464,11 @@ error_add_context: 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; + } + /* * Validate the value type and domains are legal for the process * attribute tracker that is specified and convert the value to @@ -1437,225 +1586,125 @@ 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; - } - - 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; + 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); - 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; + ERR("original payload size = %i", (int) original_payload_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; + ERR("payload size = %i", (int) 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; } @@ -1725,8 +1774,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: @@ -1754,34 +1802,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) { @@ -1791,20 +1844,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; @@ -1852,7 +1902,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; @@ -2019,14 +2069,72 @@ error_add_context: } case LTTNG_REGISTER_TRIGGER: { - ret = cmd_register_trigger(cmd_ctx, *sock, - notification_thread_handle); + struct lttng_trigger *payload_trigger; + struct lttng_trigger *return_trigger; + size_t original_reply_payload_size; + size_t reply_payload_size; + const struct lttng_credentials cmd_creds = { + .uid = LTTNG_OPTIONAL_INIT_VALUE(cmd_ctx->creds.uid), + .gid = LTTNG_OPTIONAL_INIT_VALUE(cmd_ctx->creds.gid), + }; + + ret = setup_empty_lttng_msg(cmd_ctx); + if (ret) { + ret = LTTNG_ERR_NOMEM; + goto setup_error; + } + + 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); + if (ret != LTTNG_OK) { + lttng_trigger_put(payload_trigger); + goto error; + } + + ret = lttng_trigger_serialize(return_trigger, &cmd_ctx->reply_payload); + lttng_trigger_put(payload_trigger); + lttng_trigger_put(return_trigger); + if (ret) { + ERR("Failed to serialize trigger in reply to \"register trigger\" command"); + ret = LTTNG_ERR_NOMEM; + goto error; + } + + 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: { - ret = cmd_unregister_trigger(cmd_ctx, *sock, - notification_thread_handle); + struct lttng_trigger *payload_trigger; + const struct lttng_credentials cmd_creds = { + .uid = LTTNG_OPTIONAL_INIT_VALUE(cmd_ctx->creds.uid), + .gid = LTTNG_OPTIONAL_INIT_VALUE(cmd_ctx->creds.gid), + }; + + 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); + lttng_trigger_put(payload_trigger); break; } case LTTNG_ROTATE_SESSION: @@ -2098,11 +2206,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; } @@ -2133,6 +2239,95 @@ error_add_context: ret = cmd_clear_session(cmd_ctx->session, sock); break; } + case LTTNG_LIST_TRIGGERS: + { + struct lttng_triggers *return_triggers = 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 = cmd_list_triggers(cmd_ctx, the_notification_thread_handle, + &return_triggers); + if (ret != LTTNG_OK) { + goto error; + } + + assert(return_triggers); + 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"); + 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; + } + 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; @@ -2167,9 +2362,11 @@ static int create_client_sock(void) 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; } @@ -2183,10 +2380,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; @@ -2236,7 +2434,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(); @@ -2407,6 +2605,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; @@ -2428,8 +2634,7 @@ static void *thread_manage_clients(void *data) struct lttcomm_lttng_msg *llm = (typeof( llm)) cmd_ctx.reply_payload.buffer.data; - assert(cmd_ctx.reply_payload.buffer.size >= - sizeof(llm)); + assert(cmd_ctx.reply_payload.buffer.size >= sizeof(*llm)); assert(cmd_ctx.lttng_msg_size == cmd_ctx.reply_payload.buffer.size); llm->fd_count = lttng_payload_view_get_fd_handle_count(&view); @@ -2467,7 +2672,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"); @@ -2478,7 +2683,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);