X-Git-Url: https://git.lttng.org/?p=lttng-tools.git;a=blobdiff_plain;f=src%2Fbin%2Flttng-sessiond%2Fclient.c;h=d83bee8e66441c8f6b9ddb08f8821ef83a468191;hp=3ccc29efceaf335a71ce0bc3c5d705aaefd90619;hb=bae46a81520110e52c5af423ce712b9099fe23dd;hpb=9124c6304bba12b0d4424b4071a25a34445ff4da diff --git a/src/bin/lttng-sessiond/client.c b/src/bin/lttng-sessiond/client.c index 3ccc29efc..d83bee8e6 100644 --- a/src/bin/lttng-sessiond/client.c +++ b/src/bin/lttng-sessiond/client.c @@ -43,6 +43,7 @@ #include "utils.h" #include "manage-consumer.h" #include "clear.h" +#include "agent-thread.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; } @@ -694,6 +707,79 @@ error: return ret; } +static enum lttng_error_code receive_lttng_trigger(struct command_ctx *cmd_ctx, + int sock, + int *sock_error, + struct lttng_trigger **_trigger) +{ + int ret; + size_t trigger_len; + ssize_t sock_recv_len; + enum lttng_error_code ret_code; + struct lttng_payload trigger_payload; + struct lttng_trigger *trigger = NULL; + + 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_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_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, &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; + } + } + + /* 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; + } + } + + *_trigger = trigger; + ret_code = LTTNG_OK; + +end: + lttng_payload_reset(&trigger_payload); + return ret_code; +} + /* * Version of setup_lttng_msg() without command header. */ @@ -711,7 +797,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; } @@ -773,7 +860,9 @@ static int process_client_msg(struct command_ctx *cmd_ctx, int *sock, 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()); @@ -818,8 +907,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 { @@ -830,13 +919,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); } /* @@ -959,8 +1048,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; } @@ -976,25 +1065,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; @@ -1005,6 +1094,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()) { @@ -1013,8 +1107,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; } @@ -1031,58 +1126,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; @@ -1105,13 +1200,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; } @@ -1212,7 +1307,7 @@ skip_domain: 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]); + the_kernel_poll_pipe[1]); cmd_ctx->lsm.u.context.ctx.u.app_ctx.provider_name = NULL; cmd_ctx->lsm.u.context.ctx.u.app_ctx.ctx_name = NULL; @@ -1271,7 +1366,7 @@ error_add_context: 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]); + the_kernel_poll_pipe[1]); break; } case LTTNG_PROCESS_ATTR_TRACKER_ADD_INCLUDE_VALUE: @@ -1476,7 +1571,7 @@ error_add_context: { struct lttng_event *ev = NULL; struct lttng_event_exclusion *exclusion = NULL; - struct lttng_filter_bytecode *bytecode = NULL; + struct lttng_bytecode *bytecode = NULL; char *filter_expression = NULL; /* Handle exclusion events and receive it from the client. */ @@ -1605,7 +1700,7 @@ error_add_context: cmd_ctx->lsm.u.enable.channel_name, ev, filter_expression, bytecode, exclusion, - kernel_poll_pipe[1]); + the_kernel_poll_pipe[1]); lttng_event_destroy(ev); break; } @@ -1761,8 +1856,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: @@ -1888,7 +1982,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; @@ -2055,9 +2149,14 @@ error_add_context: } case LTTNG_REGISTER_TRIGGER: { + struct lttng_trigger *payload_trigger; struct lttng_trigger *return_trigger; - size_t original_payload_size; - size_t payload_size; + 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) { @@ -2065,37 +2164,56 @@ error_add_context: goto setup_error; } - original_payload_size = cmd_ctx->reply_payload.buffer.size; + 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_ctx, *sock, - notification_thread_handle, &return_trigger); + ret = cmd_register_trigger(&cmd_creds, payload_trigger, + 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; - lttng_trigger_destroy(return_trigger); goto error; } - lttng_trigger_destroy(return_trigger); - return_trigger = NULL; + reply_payload_size = cmd_ctx->reply_payload.buffer.size - + original_reply_payload_size; - payload_size = cmd_ctx->reply_payload.buffer.size - - original_payload_size; - - update_lttng_msg(cmd_ctx, 0, 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: @@ -2167,11 +2285,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; } @@ -2216,8 +2332,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; } @@ -2274,9 +2390,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; } @@ -2290,10 +2408,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; @@ -2343,7 +2462,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(); @@ -2514,6 +2633,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; @@ -2535,8 +2662,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); @@ -2574,7 +2700,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"); @@ -2585,7 +2711,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);