thread-utils.c \
process-utils.c \
thread.c thread.h \
- health.c
+ health.c \
+ client.c client.h
if HAVE_LIBLTTNG_UST_CTL
lttng_sessiond_SOURCES += trace-ust.c ust-registry.c ust-app.c \
--- /dev/null
+/*
+ * Copyright (C) 2011 - David Goulet <david.goulet@polymtl.ca>
+ * Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
+ * 2013 - Jérémie Galarneau <jeremie.galarneau@efficios.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License, version 2 only,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+#include <stddef.h>
+#include <pthread.h>
+#include <signal.h>
+#include <sys/stat.h>
+#include <common/compat/getenv.h>
+#include <common/unix.h>
+#include <common/utils.h>
+#include <lttng/userspace-probe-internal.h>
+#include <lttng/event-internal.h>
+
+#include "client.h"
+#include "lttng-sessiond.h"
+#include "cmd.h"
+#include "kernel.h"
+#include "save.h"
+#include "health-sessiond.h"
+#include "testpoint.h"
+#include "utils.h"
+
+static bool is_root;
+
+static struct thread_state {
+ pthread_cond_t cond;
+ pthread_mutex_t lock;
+ bool is_running;
+} thread_state = {
+ .cond = PTHREAD_COND_INITIALIZER,
+ .lock = PTHREAD_MUTEX_INITIALIZER,
+ .is_running = false
+};
+
+void set_thread_state_running(void)
+{
+ pthread_mutex_lock(&thread_state.lock);
+ thread_state.is_running = true;
+ pthread_cond_broadcast(&thread_state.cond);
+ pthread_mutex_unlock(&thread_state.lock);
+}
+
+static void wait_thread_state_running(void)
+{
+ pthread_mutex_lock(&thread_state.lock);
+ while (!thread_state.is_running) {
+ pthread_cond_wait(&thread_state.cond,
+ &thread_state.lock);
+ }
+ pthread_mutex_unlock(&thread_state.lock);
+}
+
+/*
+ * Setup the outgoing data buffer for the response (llm) by allocating the
+ * right amount of memory and copying the original information from the lsm
+ * structure.
+ *
+ * Return 0 on success, negative value on error.
+ */
+static int setup_lttng_msg(struct command_ctx *cmd_ctx,
+ const void *payload_buf, size_t payload_len,
+ const void *cmd_header_buf, size_t cmd_header_len)
+{
+ int ret = 0;
+ const size_t header_len = sizeof(struct lttcomm_lttng_msg);
+ const size_t cmd_header_offset = header_len;
+ const size_t payload_offset = cmd_header_offset + cmd_header_len;
+ const size_t total_msg_size = header_len + cmd_header_len + payload_len;
+
+ cmd_ctx->llm = zmalloc(total_msg_size);
+
+ if (cmd_ctx->llm == NULL) {
+ PERROR("zmalloc");
+ ret = -ENOMEM;
+ goto end;
+ }
+
+ /* Copy common data */
+ cmd_ctx->llm->cmd_type = cmd_ctx->lsm->cmd_type;
+ cmd_ctx->llm->pid = cmd_ctx->lsm->domain.attr.pid;
+ cmd_ctx->llm->cmd_header_size = cmd_header_len;
+ cmd_ctx->llm->data_size = payload_len;
+ cmd_ctx->lttng_msg_size = total_msg_size;
+
+ /* Copy command header */
+ if (cmd_header_len) {
+ memcpy(((uint8_t *) cmd_ctx->llm) + cmd_header_offset, cmd_header_buf,
+ cmd_header_len);
+ }
+
+ /* Copy payload */
+ if (payload_len) {
+ memcpy(((uint8_t *) cmd_ctx->llm) + payload_offset, payload_buf,
+ payload_len);
+ }
+
+end:
+ return ret;
+}
+
+/*
+ * Start the thread_manage_consumer. This must be done after a lttng-consumerd
+ * exec or it will fails.
+ */
+static int spawn_consumer_thread(struct consumer_data *consumer_data)
+{
+ int ret, clock_ret;
+ struct timespec timeout;
+
+ /*
+ * Make sure we set the readiness flag to 0 because we are NOT ready.
+ * This access to consumer_thread_is_ready does not need to be
+ * protected by consumer_data.cond_mutex (yet) since the consumer
+ * management thread has not been started at this point.
+ */
+ consumer_data->consumer_thread_is_ready = 0;
+
+ /* Setup pthread condition */
+ ret = pthread_condattr_init(&consumer_data->condattr);
+ if (ret) {
+ errno = ret;
+ PERROR("pthread_condattr_init consumer data");
+ goto error;
+ }
+
+ /*
+ * Set the monotonic clock in order to make sure we DO NOT jump in time
+ * between the clock_gettime() call and the timedwait call. See bug #324
+ * for a more details and how we noticed it.
+ */
+ ret = pthread_condattr_setclock(&consumer_data->condattr, CLOCK_MONOTONIC);
+ if (ret) {
+ errno = ret;
+ PERROR("pthread_condattr_setclock consumer data");
+ goto error;
+ }
+
+ ret = pthread_cond_init(&consumer_data->cond, &consumer_data->condattr);
+ if (ret) {
+ errno = ret;
+ PERROR("pthread_cond_init consumer data");
+ goto error;
+ }
+
+ ret = pthread_create(&consumer_data->thread, default_pthread_attr(),
+ thread_manage_consumer, consumer_data);
+ if (ret) {
+ errno = ret;
+ PERROR("pthread_create consumer");
+ ret = -1;
+ goto error;
+ }
+
+ /* We are about to wait on a pthread condition */
+ pthread_mutex_lock(&consumer_data->cond_mutex);
+
+ /* Get time for sem_timedwait absolute timeout */
+ clock_ret = lttng_clock_gettime(CLOCK_MONOTONIC, &timeout);
+ /*
+ * Set the timeout for the condition timed wait even if the clock gettime
+ * call fails since we might loop on that call and we want to avoid to
+ * increment the timeout too many times.
+ */
+ timeout.tv_sec += DEFAULT_SEM_WAIT_TIMEOUT;
+
+ /*
+ * The following loop COULD be skipped in some conditions so this is why we
+ * set ret to 0 in order to make sure at least one round of the loop is
+ * done.
+ */
+ ret = 0;
+
+ /*
+ * Loop until the condition is reached or when a timeout is reached. Note
+ * that the pthread_cond_timedwait(P) man page specifies that EINTR can NOT
+ * be returned but the pthread_cond(3), from the glibc-doc, says that it is
+ * possible. This loop does not take any chances and works with both of
+ * them.
+ */
+ while (!consumer_data->consumer_thread_is_ready && ret != ETIMEDOUT) {
+ if (clock_ret < 0) {
+ PERROR("clock_gettime spawn consumer");
+ /* Infinite wait for the consumerd thread to be ready */
+ ret = pthread_cond_wait(&consumer_data->cond,
+ &consumer_data->cond_mutex);
+ } else {
+ ret = pthread_cond_timedwait(&consumer_data->cond,
+ &consumer_data->cond_mutex, &timeout);
+ }
+ }
+
+ /* Release the pthread condition */
+ pthread_mutex_unlock(&consumer_data->cond_mutex);
+
+ if (ret != 0) {
+ errno = ret;
+ if (ret == ETIMEDOUT) {
+ int pth_ret;
+
+ /*
+ * Call has timed out so we kill the kconsumerd_thread and return
+ * an error.
+ */
+ ERR("Condition timed out. The consumer thread was never ready."
+ " Killing it");
+ pth_ret = pthread_cancel(consumer_data->thread);
+ if (pth_ret < 0) {
+ PERROR("pthread_cancel consumer thread");
+ }
+ } else {
+ PERROR("pthread_cond_wait failed consumer thread");
+ }
+ /* Caller is expecting a negative value on failure. */
+ ret = -1;
+ goto error;
+ }
+
+ pthread_mutex_lock(&consumer_data->pid_mutex);
+ if (consumer_data->pid == 0) {
+ ERR("Consumerd did not start");
+ pthread_mutex_unlock(&consumer_data->pid_mutex);
+ goto error;
+ }
+ pthread_mutex_unlock(&consumer_data->pid_mutex);
+
+ return 0;
+
+error:
+ return ret;
+}
+
+/*
+ * Fork and exec a consumer daemon (consumerd).
+ *
+ * Return pid if successful else -1.
+ */
+static pid_t spawn_consumerd(struct consumer_data *consumer_data)
+{
+ int ret;
+ pid_t pid;
+ const char *consumer_to_use;
+ const char *verbosity;
+ struct stat st;
+
+ DBG("Spawning consumerd");
+
+ pid = fork();
+ if (pid == 0) {
+ /*
+ * Exec consumerd.
+ */
+ if (config.verbose_consumer) {
+ verbosity = "--verbose";
+ } else if (lttng_opt_quiet) {
+ verbosity = "--quiet";
+ } else {
+ verbosity = "";
+ }
+
+ switch (consumer_data->type) {
+ case LTTNG_CONSUMER_KERNEL:
+ /*
+ * Find out which consumerd to execute. We will first try the
+ * 64-bit path, then the sessiond's installation directory, and
+ * 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(" 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("Found location #1");
+ consumer_to_use = 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) {
+ DBG3("Found location #3");
+ consumer_to_use = 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);
+ break;
+ case LTTNG_CONSUMER64_UST:
+ {
+ if (config.consumerd64_lib_dir.value) {
+ char *tmp;
+ size_t tmplen;
+ char *tmpnew;
+
+ tmp = lttng_secure_getenv("LD_LIBRARY_PATH");
+ if (!tmp) {
+ tmp = "";
+ }
+ tmplen = strlen(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);
+ if (tmp[0] != '\0') {
+ strcat(tmpnew, ":");
+ strcat(tmpnew, tmp);
+ }
+ ret = setenv("LD_LIBRARY_PATH", tmpnew, 1);
+ free(tmpnew);
+ if (ret) {
+ ret = -errno;
+ 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,
+ NULL);
+ break;
+ }
+ case LTTNG_CONSUMER32_UST:
+ {
+ if (config.consumerd32_lib_dir.value) {
+ char *tmp;
+ size_t tmplen;
+ char *tmpnew;
+
+ tmp = lttng_secure_getenv("LD_LIBRARY_PATH");
+ if (!tmp) {
+ tmp = "";
+ }
+ tmplen = strlen(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);
+ if (tmp[0] != '\0') {
+ strcat(tmpnew, ":");
+ strcat(tmpnew, tmp);
+ }
+ ret = setenv("LD_LIBRARY_PATH", tmpnew, 1);
+ free(tmpnew);
+ if (ret) {
+ ret = -errno;
+ 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,
+ NULL);
+ break;
+ }
+ default:
+ ERR("unknown consumer type");
+ errno = 0;
+ }
+ if (errno != 0) {
+ PERROR("Consumer execl()");
+ }
+ /* Reaching this point, we got a failure on our execl(). */
+ exit(EXIT_FAILURE);
+ } else if (pid > 0) {
+ ret = pid;
+ } else {
+ PERROR("start consumer fork");
+ ret = -errno;
+ }
+error:
+ return ret;
+}
+
+/*
+ * Spawn the consumerd daemon and session daemon thread.
+ */
+static int start_consumerd(struct consumer_data *consumer_data)
+{
+ int ret;
+
+ /*
+ * Set the listen() state on the socket since there is a possible race
+ * between the exec() of the consumer daemon and this call if place in the
+ * consumer thread. See bug #366 for more details.
+ */
+ ret = lttcomm_listen_unix_sock(consumer_data->err_sock);
+ if (ret < 0) {
+ goto error;
+ }
+
+ pthread_mutex_lock(&consumer_data->pid_mutex);
+ if (consumer_data->pid != 0) {
+ pthread_mutex_unlock(&consumer_data->pid_mutex);
+ goto end;
+ }
+
+ ret = spawn_consumerd(consumer_data);
+ if (ret < 0) {
+ ERR("Spawning consumerd failed");
+ pthread_mutex_unlock(&consumer_data->pid_mutex);
+ goto error;
+ }
+
+ /* Setting up the consumer_data pid */
+ consumer_data->pid = ret;
+ DBG2("Consumer pid %d", consumer_data->pid);
+ pthread_mutex_unlock(&consumer_data->pid_mutex);
+
+ DBG2("Spawning consumer control thread");
+ ret = spawn_consumer_thread(consumer_data);
+ if (ret < 0) {
+ ERR("Fatal error spawning consumer control thread");
+ goto error;
+ }
+
+end:
+ return 0;
+
+error:
+ /* Cleanup already created sockets on error. */
+ if (consumer_data->err_sock >= 0) {
+ int err;
+
+ err = close(consumer_data->err_sock);
+ if (err < 0) {
+ PERROR("close consumer data error socket");
+ }
+ }
+ return ret;
+}
+
+/*
+ * Copy consumer output from the tracing session to the domain session. The
+ * function also applies the right modification on a per domain basis for the
+ * trace files destination directory.
+ *
+ * Should *NOT* be called with RCU read-side lock held.
+ */
+static int copy_session_consumer(int domain, struct ltt_session *session)
+{
+ int ret;
+ const char *dir_name;
+ struct consumer_output *consumer;
+
+ assert(session);
+ assert(session->consumer);
+
+ switch (domain) {
+ case LTTNG_DOMAIN_KERNEL:
+ DBG3("Copying tracing session consumer output in kernel session");
+ /*
+ * XXX: We should audit the session creation and what this function
+ * does "extra" in order to avoid a destroy since this function is used
+ * in the domain session creation (kernel and ust) only. Same for UST
+ * domain.
+ */
+ if (session->kernel_session->consumer) {
+ consumer_output_put(session->kernel_session->consumer);
+ }
+ session->kernel_session->consumer =
+ consumer_copy_output(session->consumer);
+ /* Ease our life a bit for the next part */
+ consumer = session->kernel_session->consumer;
+ dir_name = DEFAULT_KERNEL_TRACE_DIR;
+ break;
+ case LTTNG_DOMAIN_JUL:
+ case LTTNG_DOMAIN_LOG4J:
+ case LTTNG_DOMAIN_PYTHON:
+ case LTTNG_DOMAIN_UST:
+ DBG3("Copying tracing session consumer output in UST session");
+ if (session->ust_session->consumer) {
+ consumer_output_put(session->ust_session->consumer);
+ }
+ session->ust_session->consumer =
+ consumer_copy_output(session->consumer);
+ /* Ease our life a bit for the next part */
+ consumer = session->ust_session->consumer;
+ dir_name = DEFAULT_UST_TRACE_DIR;
+ break;
+ default:
+ ret = LTTNG_ERR_UNKNOWN_DOMAIN;
+ goto error;
+ }
+
+ /* Append correct directory to subdir */
+ strncat(consumer->subdir, dir_name,
+ sizeof(consumer->subdir) - strlen(consumer->subdir) - 1);
+ DBG3("Copy session consumer subdir %s", consumer->subdir);
+
+ ret = LTTNG_OK;
+
+error:
+ return ret;
+}
+
+/*
+ * Create an UST session and add it to the session ust list.
+ *
+ * Should *NOT* be called with RCU read-side lock held.
+ */
+static int create_ust_session(struct ltt_session *session,
+ struct lttng_domain *domain)
+{
+ int ret;
+ struct ltt_ust_session *lus = NULL;
+
+ assert(session);
+ assert(domain);
+ assert(session->consumer);
+
+ switch (domain->type) {
+ case LTTNG_DOMAIN_JUL:
+ case LTTNG_DOMAIN_LOG4J:
+ case LTTNG_DOMAIN_PYTHON:
+ case LTTNG_DOMAIN_UST:
+ break;
+ default:
+ ERR("Unknown UST domain on create session %d", domain->type);
+ ret = LTTNG_ERR_UNKNOWN_DOMAIN;
+ goto error;
+ }
+
+ DBG("Creating UST session");
+
+ lus = trace_ust_create_session(session->id);
+ if (lus == NULL) {
+ ret = LTTNG_ERR_UST_SESS_FAIL;
+ goto error;
+ }
+
+ lus->uid = session->uid;
+ lus->gid = session->gid;
+ lus->output_traces = session->output_traces;
+ lus->snapshot_mode = session->snapshot_mode;
+ lus->live_timer_interval = session->live_timer;
+ session->ust_session = lus;
+ if (session->shm_path[0]) {
+ strncpy(lus->root_shm_path, session->shm_path,
+ sizeof(lus->root_shm_path));
+ lus->root_shm_path[sizeof(lus->root_shm_path) - 1] = '\0';
+ strncpy(lus->shm_path, session->shm_path,
+ sizeof(lus->shm_path));
+ lus->shm_path[sizeof(lus->shm_path) - 1] = '\0';
+ strncat(lus->shm_path, "/ust",
+ sizeof(lus->shm_path) - strlen(lus->shm_path) - 1);
+ }
+ /* Copy session output to the newly created UST session */
+ ret = copy_session_consumer(domain->type, session);
+ if (ret != LTTNG_OK) {
+ goto error;
+ }
+
+ return LTTNG_OK;
+
+error:
+ free(lus);
+ session->ust_session = NULL;
+ return ret;
+}
+
+/*
+ * Create a kernel tracer session then create the default channel.
+ */
+static int create_kernel_session(struct ltt_session *session)
+{
+ int ret;
+
+ DBG("Creating kernel session");
+
+ ret = kernel_create_session(session, kernel_tracer_fd);
+ if (ret < 0) {
+ ret = LTTNG_ERR_KERN_SESS_FAIL;
+ goto error;
+ }
+
+ /* Code flow safety */
+ assert(session->kernel_session);
+
+ /* Copy session output to the newly created Kernel session */
+ ret = copy_session_consumer(LTTNG_DOMAIN_KERNEL, session);
+ if (ret != LTTNG_OK) {
+ goto error;
+ }
+
+ session->kernel_session->uid = session->uid;
+ session->kernel_session->gid = session->gid;
+ session->kernel_session->output_traces = session->output_traces;
+ session->kernel_session->snapshot_mode = session->snapshot_mode;
+
+ return LTTNG_OK;
+
+error:
+ trace_kernel_destroy_session(session->kernel_session);
+ session->kernel_session = NULL;
+ return ret;
+}
+
+/*
+ * Count number of session permitted by uid/gid.
+ */
+static unsigned int lttng_sessions_count(uid_t uid, gid_t gid)
+{
+ unsigned int i = 0;
+ struct ltt_session *session;
+ const struct ltt_session_list *session_list = session_get_list();
+
+ DBG("Counting number of available session for UID %d GID %d",
+ uid, gid);
+ 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) &&
+ !session->destroyed) {
+ i++;
+ }
+ session_unlock(session);
+ session_put(session);
+ }
+ return i;
+}
+
+static int receive_userspace_probe(struct command_ctx *cmd_ctx, int sock,
+ int *sock_error, struct lttng_event *event)
+{
+ int fd, ret;
+ struct lttng_userspace_probe_location *probe_location;
+ const struct lttng_userspace_probe_location_lookup_method *lookup = NULL;
+ struct lttng_dynamic_buffer probe_location_buffer;
+ struct lttng_buffer_view buffer_view;
+
+ /*
+ * Create a buffer to store the serialized version of the probe
+ * location.
+ */
+ lttng_dynamic_buffer_init(&probe_location_buffer);
+ ret = lttng_dynamic_buffer_set_size(&probe_location_buffer,
+ cmd_ctx->lsm->u.enable.userspace_probe_location_len);
+ if (ret) {
+ ret = LTTNG_ERR_NOMEM;
+ goto error;
+ }
+
+ /*
+ * Receive the probe location.
+ */
+ ret = lttcomm_recv_unix_sock(sock, probe_location_buffer.data,
+ probe_location_buffer.size);
+ if (ret <= 0) {
+ DBG("Nothing recv() from client var len data... continuing");
+ *sock_error = 1;
+ lttng_dynamic_buffer_reset(&probe_location_buffer);
+ ret = LTTNG_ERR_PROBE_LOCATION_INVAL;
+ goto error;
+ }
+
+ buffer_view = lttng_buffer_view_from_dynamic_buffer(
+ &probe_location_buffer, 0, probe_location_buffer.size);
+
+ /*
+ * Extract the probe location from the serialized version.
+ */
+ ret = lttng_userspace_probe_location_create_from_buffer(
+ &buffer_view, &probe_location);
+ if (ret < 0) {
+ WARN("Failed to create a userspace probe location from the received buffer");
+ lttng_dynamic_buffer_reset( &probe_location_buffer);
+ ret = LTTNG_ERR_PROBE_LOCATION_INVAL;
+ goto error;
+ }
+
+ /*
+ * 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;
+ }
+
+ /*
+ * Set the file descriptor received from the client through the unix
+ * socket in the probe location.
+ */
+ lookup = lttng_userspace_probe_location_get_lookup_method(probe_location);
+ if (!lookup) {
+ ret = LTTNG_ERR_PROBE_LOCATION_INVAL;
+ goto error;
+ }
+
+ /*
+ * From the kernel tracer's perspective, all userspace probe event types
+ * are all the same: a file and an offset.
+ */
+ switch (lttng_userspace_probe_location_lookup_method_get_type(lookup)) {
+ case LTTNG_USERSPACE_PROBE_LOCATION_LOOKUP_METHOD_TYPE_FUNCTION_ELF:
+ ret = lttng_userspace_probe_location_function_set_binary_fd(
+ probe_location, fd);
+ break;
+ case LTTNG_USERSPACE_PROBE_LOCATION_LOOKUP_METHOD_TYPE_TRACEPOINT_SDT:
+ ret = lttng_userspace_probe_location_tracepoint_set_binary_fd(
+ probe_location, fd);
+ break;
+ default:
+ ret = LTTNG_ERR_PROBE_LOCATION_INVAL;
+ goto error;
+ }
+
+ if (ret) {
+ ret = LTTNG_ERR_PROBE_LOCATION_INVAL;
+ goto error;
+ }
+
+ /* 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;
+ }
+
+ lttng_dynamic_buffer_reset(&probe_location_buffer);
+error:
+ return ret;
+}
+
+/*
+ * Join consumer thread
+ */
+static int join_consumer_thread(struct consumer_data *consumer_data)
+{
+ void *status;
+
+ /* Consumer pid must be a real one. */
+ if (consumer_data->pid > 0) {
+ int ret;
+ ret = kill(consumer_data->pid, SIGTERM);
+ if (ret) {
+ PERROR("Error killing consumer daemon");
+ return ret;
+ }
+ return pthread_join(consumer_data->thread, &status);
+ } else {
+ return 0;
+ }
+}
+
+/*
+ * Version of setup_lttng_msg() without command header.
+ */
+static int setup_lttng_msg_no_cmd_header(struct command_ctx *cmd_ctx,
+ void *payload_buf, size_t payload_len)
+{
+ return setup_lttng_msg(cmd_ctx, payload_buf, payload_len, NULL, 0);
+}
+
+/*
+ * Free memory of a command context structure.
+ */
+static void clean_command_ctx(struct command_ctx **cmd_ctx)
+{
+ DBG("Clean command context structure");
+ if (*cmd_ctx) {
+ if ((*cmd_ctx)->llm) {
+ free((*cmd_ctx)->llm);
+ }
+ if ((*cmd_ctx)->lsm) {
+ free((*cmd_ctx)->lsm);
+ }
+ free(*cmd_ctx);
+ *cmd_ctx = NULL;
+ }
+}
+
+/*
+ * Check if the current kernel tracer supports the session rotation feature.
+ * Return 1 if it does, 0 otherwise.
+ */
+static int check_rotate_compatible(void)
+{
+ int ret = 1;
+
+ if (kernel_tracer_version.major != 2 || kernel_tracer_version.minor < 11) {
+ DBG("Kernel tracer version is not compatible with the rotation feature");
+ ret = 0;
+ }
+
+ return ret;
+}
+
+/*
+ * Send data on a unix socket using the liblttsessiondcomm API.
+ *
+ * Return lttcomm error code.
+ */
+static int send_unix_sock(int sock, void *buf, size_t len)
+{
+ /* Check valid length */
+ if (len == 0) {
+ return -1;
+ }
+
+ return lttcomm_send_unix_sock(sock, buf, len);
+}
+
+/*
+ * Process the command requested by the lttng client within the command
+ * context structure. This function make sure that the return structure (llm)
+ * is set and ready for transmission before returning.
+ *
+ * Return any error encountered or 0 for success.
+ *
+ * "sock" is only used for special-case var. len data.
+ *
+ * Should *NOT* be called with RCU read-side lock held.
+ */
+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;
+
+ DBG("Processing client command %d", cmd_ctx->lsm->cmd_type);
+
+ assert(!rcu_read_ongoing());
+
+ *sock_error = 0;
+
+ switch (cmd_ctx->lsm->cmd_type) {
+ case LTTNG_CREATE_SESSION:
+ case LTTNG_CREATE_SESSION_SNAPSHOT:
+ case LTTNG_CREATE_SESSION_LIVE:
+ case LTTNG_DESTROY_SESSION:
+ case LTTNG_LIST_SESSIONS:
+ case LTTNG_LIST_DOMAINS:
+ case LTTNG_START_TRACE:
+ case LTTNG_STOP_TRACE:
+ case LTTNG_DATA_PENDING:
+ case LTTNG_SNAPSHOT_ADD_OUTPUT:
+ case LTTNG_SNAPSHOT_DEL_OUTPUT:
+ case LTTNG_SNAPSHOT_LIST_OUTPUT:
+ case LTTNG_SNAPSHOT_RECORD:
+ case LTTNG_SAVE_SESSION:
+ case LTTNG_SET_SESSION_SHM_PATH:
+ case LTTNG_REGENERATE_METADATA:
+ case LTTNG_REGENERATE_STATEDUMP:
+ case LTTNG_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:
+ need_domain = 0;
+ break;
+ default:
+ need_domain = 1;
+ }
+
+ if (config.no_kernel && need_domain
+ && cmd_ctx->lsm->domain.type == LTTNG_DOMAIN_KERNEL) {
+ if (!is_root) {
+ ret = LTTNG_ERR_NEED_ROOT_SESSIOND;
+ } else {
+ ret = LTTNG_ERR_KERN_NA;
+ }
+ goto error;
+ }
+
+ /* 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) {
+ ret = LTTNG_ERR_KERN_CONSUMER_FAIL;
+ pthread_mutex_unlock(&kconsumer_data.pid_mutex);
+ goto error;
+ }
+ pthread_mutex_unlock(&kconsumer_data.pid_mutex);
+ }
+
+ /*
+ * Check for command that don't needs to allocate a returned payload. We do
+ * this here so we don't have to make the call for no payload at each
+ * command.
+ */
+ switch(cmd_ctx->lsm->cmd_type) {
+ case LTTNG_LIST_SESSIONS:
+ case LTTNG_LIST_TRACEPOINTS:
+ case LTTNG_LIST_TRACEPOINT_FIELDS:
+ case LTTNG_LIST_DOMAINS:
+ case LTTNG_LIST_CHANNELS:
+ case LTTNG_LIST_EVENTS:
+ case LTTNG_LIST_SYSCALLS:
+ case LTTNG_LIST_TRACKER_PIDS:
+ case LTTNG_DATA_PENDING:
+ case LTTNG_ROTATE_SESSION:
+ case LTTNG_ROTATION_GET_INFO:
+ case LTTNG_SESSION_LIST_ROTATION_SCHEDULES:
+ break;
+ default:
+ /* Setup lttng message with no payload */
+ ret = setup_lttng_msg_no_cmd_header(cmd_ctx, NULL, 0);
+ if (ret < 0) {
+ /* This label does not try to unlock the session */
+ goto init_setup_error;
+ }
+ }
+
+ /* Commands that DO NOT need a session. */
+ switch (cmd_ctx->lsm->cmd_type) {
+ case LTTNG_CREATE_SESSION:
+ case LTTNG_CREATE_SESSION_SNAPSHOT:
+ case LTTNG_CREATE_SESSION_LIVE:
+ case LTTNG_LIST_SESSIONS:
+ case LTTNG_LIST_TRACEPOINTS:
+ case LTTNG_LIST_SYSCALLS:
+ case LTTNG_LIST_TRACEPOINT_FIELDS:
+ case LTTNG_SAVE_SESSION:
+ case LTTNG_REGISTER_TRIGGER:
+ case LTTNG_UNREGISTER_TRIGGER:
+ need_tracing_session = 0;
+ break;
+ default:
+ DBG("Getting session %s by name", cmd_ctx->lsm->session.name);
+ /*
+ * We keep the session list lock across _all_ commands
+ * for now, because the per-session lock does not
+ * handle teardown properly.
+ */
+ session_lock_list();
+ cmd_ctx->session = session_find_by_name(cmd_ctx->lsm->session.name);
+ if (cmd_ctx->session == NULL) {
+ ret = LTTNG_ERR_SESS_NOT_FOUND;
+ goto error;
+ } else {
+ /* Acquire lock for the session */
+ session_lock(cmd_ctx->session);
+ }
+ break;
+ }
+
+ /*
+ * Commands that need a valid session but should NOT create one if none
+ * exists. Instead of creating one and destroying it when the command is
+ * handled, process that right before so we save some round trip in useless
+ * code path.
+ */
+ switch (cmd_ctx->lsm->cmd_type) {
+ case LTTNG_DISABLE_CHANNEL:
+ case LTTNG_DISABLE_EVENT:
+ switch (cmd_ctx->lsm->domain.type) {
+ case LTTNG_DOMAIN_KERNEL:
+ if (!cmd_ctx->session->kernel_session) {
+ ret = LTTNG_ERR_NO_CHANNEL;
+ goto error;
+ }
+ break;
+ case LTTNG_DOMAIN_JUL:
+ case LTTNG_DOMAIN_LOG4J:
+ case LTTNG_DOMAIN_PYTHON:
+ case LTTNG_DOMAIN_UST:
+ if (!cmd_ctx->session->ust_session) {
+ ret = LTTNG_ERR_NO_CHANNEL;
+ goto error;
+ }
+ break;
+ default:
+ ret = LTTNG_ERR_UNKNOWN_DOMAIN;
+ goto error;
+ }
+ default:
+ break;
+ }
+
+ if (!need_domain) {
+ goto skip_domain;
+ }
+
+ /*
+ * Check domain type for specific "pre-action".
+ */
+ switch (cmd_ctx->lsm->domain.type) {
+ case LTTNG_DOMAIN_KERNEL:
+ if (!is_root) {
+ ret = LTTNG_ERR_NEED_ROOT_SESSIOND;
+ goto error;
+ }
+
+ /* Consumer is in an ERROR state. Report back to client */
+ if (uatomic_read(&kernel_consumerd_state) == CONSUMER_ERROR) {
+ ret = LTTNG_ERR_NO_KERNCONSUMERD;
+ goto error;
+ }
+
+ /* Need a session for kernel command */
+ if (need_tracing_session) {
+ if (cmd_ctx->session->kernel_session == NULL) {
+ ret = create_kernel_session(cmd_ctx->session);
+ if (ret < 0) {
+ ret = LTTNG_ERR_KERN_SESS_FAIL;
+ goto error;
+ }
+ }
+
+ /* Start the kernel consumer daemon */
+ pthread_mutex_lock(&kconsumer_data.pid_mutex);
+ if (kconsumer_data.pid == 0 &&
+ cmd_ctx->lsm->cmd_type != LTTNG_REGISTER_CONSUMER) {
+ pthread_mutex_unlock(&kconsumer_data.pid_mutex);
+ ret = start_consumerd(&kconsumer_data);
+ if (ret < 0) {
+ ret = LTTNG_ERR_KERN_CONSUMER_FAIL;
+ goto error;
+ }
+ uatomic_set(&kernel_consumerd_state, CONSUMER_STARTED);
+ } else {
+ pthread_mutex_unlock(&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,
+ cmd_ctx->session->kernel_session->consumer);
+ if (ret < 0) {
+ goto error;
+ }
+ }
+
+ break;
+ case LTTNG_DOMAIN_JUL:
+ case LTTNG_DOMAIN_LOG4J:
+ case LTTNG_DOMAIN_PYTHON:
+ 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) {
+ ret = LTTNG_ERR_NO_USTCONSUMERD;
+ goto error;
+ }
+
+ if (need_tracing_session) {
+ /* Create UST session if none exist. */
+ if (cmd_ctx->session->ust_session == NULL) {
+ ret = create_ust_session(cmd_ctx->session,
+ &cmd_ctx->lsm->domain);
+ if (ret != LTTNG_OK) {
+ goto error;
+ }
+ }
+
+ /* Start the UST consumer daemons */
+ /* 64-bit */
+ pthread_mutex_lock(&ustconsumer64_data.pid_mutex);
+ if (config.consumerd64_bin_path.value &&
+ ustconsumer64_data.pid == 0 &&
+ cmd_ctx->lsm->cmd_type != LTTNG_REGISTER_CONSUMER) {
+ pthread_mutex_unlock(&ustconsumer64_data.pid_mutex);
+ ret = start_consumerd(&ustconsumer64_data);
+ if (ret < 0) {
+ ret = LTTNG_ERR_UST_CONSUMER64_FAIL;
+ uatomic_set(&ust_consumerd64_fd, -EINVAL);
+ goto error;
+ }
+
+ uatomic_set(&ust_consumerd64_fd, ustconsumer64_data.cmd_sock);
+ uatomic_set(&ust_consumerd_state, CONSUMER_STARTED);
+ } else {
+ pthread_mutex_unlock(&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,
+ 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 &&
+ cmd_ctx->lsm->cmd_type != LTTNG_REGISTER_CONSUMER) {
+ pthread_mutex_unlock(&ustconsumer32_data.pid_mutex);
+ ret = start_consumerd(&ustconsumer32_data);
+ if (ret < 0) {
+ ret = LTTNG_ERR_UST_CONSUMER32_FAIL;
+ uatomic_set(&ust_consumerd32_fd, -EINVAL);
+ goto error;
+ }
+
+ uatomic_set(&ust_consumerd32_fd, ustconsumer32_data.cmd_sock);
+ uatomic_set(&ust_consumerd_state, CONSUMER_STARTED);
+ } else {
+ pthread_mutex_unlock(&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,
+ cmd_ctx->session->ust_session->consumer);
+ if (ret < 0) {
+ goto error;
+ }
+ }
+ break;
+ }
+ default:
+ break;
+ }
+skip_domain:
+
+ /* Validate consumer daemon state when start/stop trace command */
+ if (cmd_ctx->lsm->cmd_type == LTTNG_START_TRACE ||
+ cmd_ctx->lsm->cmd_type == LTTNG_STOP_TRACE) {
+ switch (cmd_ctx->lsm->domain.type) {
+ case LTTNG_DOMAIN_NONE:
+ break;
+ case LTTNG_DOMAIN_JUL:
+ case LTTNG_DOMAIN_LOG4J:
+ case LTTNG_DOMAIN_PYTHON:
+ case LTTNG_DOMAIN_UST:
+ if (uatomic_read(&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) {
+ ret = LTTNG_ERR_NO_KERNCONSUMERD;
+ goto error;
+ }
+ break;
+ default:
+ ret = LTTNG_ERR_UNKNOWN_DOMAIN;
+ goto error;
+ }
+ }
+
+ /*
+ * Check that the UID or GID match 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)) ||
+ cmd_ctx->session->destroyed) {
+ ret = LTTNG_ERR_EPERM;
+ goto error;
+ }
+ }
+
+ /*
+ * Send relayd information to consumer as soon as we have a domain and a
+ * session defined.
+ */
+ if (cmd_ctx->session && need_domain) {
+ /*
+ * Setup relayd if not done yet. If the relayd information was already
+ * sent to the consumer, this call will gracefully return.
+ */
+ ret = cmd_setup_relayd(cmd_ctx->session);
+ if (ret != LTTNG_OK) {
+ goto error;
+ }
+ }
+
+ /* Process by command type */
+ 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;
+ }
+
+ 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,
+ &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) {
+ goto error;
+ }
+ break;
+ }
+ case LTTNG_DISABLE_CHANNEL:
+ {
+ ret = cmd_disable_channel(cmd_ctx->session, cmd_ctx->lsm->domain.type,
+ 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;
+ }
+ }
+ /* FIXME: passing packed structure to non-packed pointer */
+ ret = cmd_disable_event(cmd_ctx->session, cmd_ctx->lsm->domain.type,
+ cmd_ctx->lsm->u.disable.channel_name,
+ &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, &cmd_ctx->lsm->domain,
+ &cmd_ctx->lsm->u.channel.chan,
+ kernel_poll_pipe[1]);
+ break;
+ }
+ case LTTNG_TRACK_PID:
+ {
+ ret = cmd_track_pid(cmd_ctx->session,
+ cmd_ctx->lsm->domain.type,
+ cmd_ctx->lsm->u.pid_tracker.pid);
+ break;
+ }
+ case LTTNG_UNTRACK_PID:
+ {
+ ret = cmd_untrack_pid(cmd_ctx->session,
+ cmd_ctx->lsm->domain.type,
+ cmd_ctx->lsm->u.pid_tracker.pid);
+ break;
+ }
+ case LTTNG_ENABLE_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;
+
+ 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(&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;
+ 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, &cmd_ctx->lsm->domain,
+ cmd_ctx->lsm->u.enable.channel_name,
+ ev,
+ filter_expression, bytecode, exclusion,
+ kernel_poll_pipe[1]);
+ lttng_event_destroy(ev);
+ break;
+ }
+ case LTTNG_LIST_TRACEPOINTS:
+ {
+ struct lttng_event *events;
+ ssize_t nb_events;
+
+ session_lock_list();
+ nb_events = cmd_list_tracepoints(cmd_ctx->lsm->domain.type, &events);
+ session_unlock_list();
+ if (nb_events < 0) {
+ /* Return value is a negative lttng_error_code. */
+ ret = -nb_events;
+ 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;
+ }
+
+ ret = LTTNG_OK;
+ break;
+ }
+ case LTTNG_LIST_TRACEPOINT_FIELDS:
+ {
+ struct lttng_event_field *fields;
+ ssize_t nb_fields;
+
+ session_lock_list();
+ nb_fields = cmd_list_tracepoint_fields(cmd_ctx->lsm->domain.type,
+ &fields);
+ session_unlock_list();
+ if (nb_fields < 0) {
+ /* Return value is a negative lttng_error_code. */
+ ret = -nb_fields;
+ 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;
+ }
+
+ ret = LTTNG_OK;
+ break;
+ }
+ case LTTNG_LIST_SYSCALLS:
+ {
+ struct lttng_event *events;
+ ssize_t nb_events;
+
+ nb_events = cmd_list_syscalls(&events);
+ if (nb_events < 0) {
+ /* Return value is a negative lttng_error_code. */
+ ret = -nb_events;
+ 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;
+ }
+
+ ret = LTTNG_OK;
+ break;
+ }
+ case LTTNG_LIST_TRACKER_PIDS:
+ {
+ int32_t *pids = NULL;
+ ssize_t nr_pids;
+
+ nr_pids = cmd_list_tracker_pids(cmd_ctx->session,
+ cmd_ctx->lsm->domain.type, &pids);
+ if (nr_pids < 0) {
+ /* Return value is a negative lttng_error_code. */
+ ret = -nr_pids;
+ 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, pids,
+ sizeof(int32_t) * nr_pids);
+ free(pids);
+
+ if (ret < 0) {
+ goto setup_error;
+ }
+
+ ret = LTTNG_OK;
+ break;
+ }
+ case LTTNG_SET_CONSUMER_URI:
+ {
+ size_t nb_uri, len;
+ struct lttng_uri *uris;
+
+ nb_uri = cmd_ctx->lsm->u.uri.size;
+ len = nb_uri * sizeof(struct lttng_uri);
+
+ if (nb_uri == 0) {
+ ret = LTTNG_ERR_INVALID;
+ goto error;
+ }
+
+ uris = zmalloc(len);
+ if (uris == NULL) {
+ ret = LTTNG_ERR_FATAL;
+ goto error;
+ }
+
+ /* Receive variable len data */
+ DBG("Receiving %zu URI(s) from client ...", nb_uri);
+ ret = lttcomm_recv_unix_sock(sock, uris, len);
+ if (ret <= 0) {
+ DBG("No URIs received from client... continuing");
+ *sock_error = 1;
+ ret = LTTNG_ERR_SESSION_FAIL;
+ free(uris);
+ goto error;
+ }
+
+ ret = cmd_set_consumer_uri(cmd_ctx->session, nb_uri, uris);
+ free(uris);
+ if (ret != LTTNG_OK) {
+ goto error;
+ }
+
+
+ break;
+ }
+ case LTTNG_START_TRACE:
+ {
+ /*
+ * On the first start, if we have a kernel session and we have
+ * enabled time or size-based rotations, we have to make sure
+ * the kernel tracer supports it.
+ */
+ if (!cmd_ctx->session->has_been_started && \
+ cmd_ctx->session->kernel_session && \
+ (cmd_ctx->session->rotate_timer_period || \
+ cmd_ctx->session->rotate_size) && \
+ !check_rotate_compatible()) {
+ DBG("Kernel tracer version is not compatible with the rotation feature");
+ ret = LTTNG_ERR_ROTATION_WRONG_VERSION;
+ goto error;
+ }
+ ret = cmd_start_trace(cmd_ctx->session);
+ break;
+ }
+ case LTTNG_STOP_TRACE:
+ {
+ ret = cmd_stop_trace(cmd_ctx->session);
+ break;
+ }
+ case LTTNG_CREATE_SESSION:
+ {
+ size_t nb_uri, len;
+ struct lttng_uri *uris = NULL;
+
+ nb_uri = cmd_ctx->lsm->u.uri.size;
+ len = nb_uri * sizeof(struct lttng_uri);
+
+ if (nb_uri > 0) {
+ uris = zmalloc(len);
+ if (uris == NULL) {
+ ret = LTTNG_ERR_FATAL;
+ goto error;
+ }
+
+ /* Receive variable len data */
+ DBG("Waiting for %zu URIs from client ...", nb_uri);
+ ret = lttcomm_recv_unix_sock(sock, uris, len);
+ if (ret <= 0) {
+ DBG("No URIs received from client... continuing");
+ *sock_error = 1;
+ ret = LTTNG_ERR_SESSION_FAIL;
+ free(uris);
+ goto error;
+ }
+
+ if (nb_uri == 1 && uris[0].dtype != LTTNG_DST_PATH) {
+ DBG("Creating session with ONE network URI is a bad call");
+ ret = LTTNG_ERR_SESSION_FAIL;
+ free(uris);
+ goto error;
+ }
+ }
+
+ ret = cmd_create_session_uri(cmd_ctx->lsm->session.name, uris, nb_uri,
+ &cmd_ctx->creds, 0);
+
+ free(uris);
+
+ break;
+ }
+ case LTTNG_DESTROY_SESSION:
+ {
+ ret = cmd_destroy_session(cmd_ctx->session,
+ notification_thread_handle);
+ break;
+ }
+ case LTTNG_LIST_DOMAINS:
+ {
+ ssize_t nb_dom;
+ struct lttng_domain *domains = NULL;
+
+ nb_dom = cmd_list_domains(cmd_ctx->session, &domains);
+ if (nb_dom < 0) {
+ /* Return value is a negative lttng_error_code. */
+ ret = -nb_dom;
+ goto error;
+ }
+
+ ret = setup_lttng_msg_no_cmd_header(cmd_ctx, domains,
+ nb_dom * sizeof(struct lttng_domain));
+ free(domains);
+
+ if (ret < 0) {
+ goto setup_error;
+ }
+
+ ret = LTTNG_OK;
+ break;
+ }
+ case LTTNG_LIST_CHANNELS:
+ {
+ ssize_t payload_size;
+ struct lttng_channel *channels = NULL;
+
+ 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_lttng_msg_no_cmd_header(cmd_ctx, channels,
+ payload_size);
+ free(channels);
+
+ if (ret < 0) {
+ goto setup_error;
+ }
+
+ ret = LTTNG_OK;
+ break;
+ }
+ case LTTNG_LIST_EVENTS:
+ {
+ ssize_t nb_event;
+ struct lttng_event *events = NULL;
+ struct lttcomm_event_command_header cmd_header;
+ size_t total_size;
+
+ memset(&cmd_header, 0, sizeof(cmd_header));
+ /* Extended infos are included at the end of events */
+ nb_event = cmd_list_events(cmd_ctx->lsm->domain.type,
+ cmd_ctx->session, cmd_ctx->lsm->u.list.channel_name,
+ &events, &total_size);
+
+ if (nb_event < 0) {
+ /* Return value is a negative lttng_error_code. */
+ ret = -nb_event;
+ goto error;
+ }
+
+ cmd_header.nb_events = nb_event;
+ ret = setup_lttng_msg(cmd_ctx, events, total_size,
+ &cmd_header, sizeof(cmd_header));
+ free(events);
+
+ if (ret < 0) {
+ goto setup_error;
+ }
+
+ ret = LTTNG_OK;
+ break;
+ }
+ case LTTNG_LIST_SESSIONS:
+ {
+ unsigned int nr_sessions;
+ void *sessions_payload;
+ size_t payload_len;
+
+ session_lock_list();
+ nr_sessions = lttng_sessions_count(
+ LTTNG_SOCK_GET_UID_CRED(&cmd_ctx->creds),
+ LTTNG_SOCK_GET_GID_CRED(&cmd_ctx->creds));
+ payload_len = sizeof(struct lttng_session) * nr_sessions;
+ sessions_payload = zmalloc(payload_len);
+
+ if (!sessions_payload) {
+ session_unlock_list();
+ ret = -ENOMEM;
+ goto setup_error;
+ }
+
+ cmd_list_lttng_sessions(sessions_payload,
+ LTTNG_SOCK_GET_UID_CRED(&cmd_ctx->creds),
+ LTTNG_SOCK_GET_GID_CRED(&cmd_ctx->creds));
+ session_unlock_list();
+
+ ret = setup_lttng_msg_no_cmd_header(cmd_ctx, sessions_payload,
+ payload_len);
+ free(sessions_payload);
+
+ if (ret < 0) {
+ goto setup_error;
+ }
+
+ ret = LTTNG_OK;
+ break;
+ }
+ case LTTNG_REGISTER_CONSUMER:
+ {
+ struct consumer_data *cdata;
+
+ switch (cmd_ctx->lsm->domain.type) {
+ case LTTNG_DOMAIN_KERNEL:
+ cdata = &kconsumer_data;
+ break;
+ default:
+ ret = LTTNG_ERR_UND;
+ goto error;
+ }
+
+ ret = cmd_register_consumer(cmd_ctx->session, cmd_ctx->lsm->domain.type,
+ cmd_ctx->lsm->u.reg.path, cdata);
+ break;
+ }
+ case LTTNG_DATA_PENDING:
+ {
+ int pending_ret;
+ uint8_t pending_ret_byte;
+
+ pending_ret = cmd_data_pending(cmd_ctx->session);
+
+ /*
+ * FIXME
+ *
+ * This function may returns 0 or 1 to indicate whether or not
+ * there is data pending. In case of error, it should return an
+ * LTTNG_ERR code. However, some code paths may still return
+ * a nondescript error code, which we handle by returning an
+ * "unknown" error.
+ */
+ if (pending_ret == 0 || pending_ret == 1) {
+ /*
+ * ret will be set to LTTNG_OK at the end of
+ * this function.
+ */
+ } else if (pending_ret < 0) {
+ ret = LTTNG_ERR_UNK;
+ goto setup_error;
+ } else {
+ ret = pending_ret;
+ goto setup_error;
+ }
+
+ pending_ret_byte = (uint8_t) pending_ret;
+
+ /* 1 byte to return whether or not data is pending */
+ ret = setup_lttng_msg_no_cmd_header(cmd_ctx,
+ &pending_ret_byte, 1);
+
+ if (ret < 0) {
+ goto setup_error;
+ }
+
+ ret = LTTNG_OK;
+ break;
+ }
+ case LTTNG_SNAPSHOT_ADD_OUTPUT:
+ {
+ struct lttcomm_lttng_output_id reply;
+
+ ret = cmd_snapshot_add_output(cmd_ctx->session,
+ &cmd_ctx->lsm->u.snapshot_output.output, &reply.id);
+ if (ret != LTTNG_OK) {
+ goto error;
+ }
+
+ ret = setup_lttng_msg_no_cmd_header(cmd_ctx, &reply,
+ sizeof(reply));
+ if (ret < 0) {
+ goto setup_error;
+ }
+
+ /* Copy output list into message payload */
+ ret = LTTNG_OK;
+ break;
+ }
+ case LTTNG_SNAPSHOT_DEL_OUTPUT:
+ {
+ ret = cmd_snapshot_del_output(cmd_ctx->session,
+ &cmd_ctx->lsm->u.snapshot_output.output);
+ break;
+ }
+ case LTTNG_SNAPSHOT_LIST_OUTPUT:
+ {
+ ssize_t nb_output;
+ struct lttng_snapshot_output *outputs = NULL;
+
+ nb_output = cmd_snapshot_list_outputs(cmd_ctx->session, &outputs);
+ if (nb_output < 0) {
+ ret = -nb_output;
+ goto error;
+ }
+
+ assert((nb_output > 0 && outputs) || nb_output == 0);
+ ret = setup_lttng_msg_no_cmd_header(cmd_ctx, outputs,
+ nb_output * sizeof(struct lttng_snapshot_output));
+ free(outputs);
+
+ if (ret < 0) {
+ goto setup_error;
+ }
+
+ ret = LTTNG_OK;
+ break;
+ }
+ case LTTNG_SNAPSHOT_RECORD:
+ {
+ ret = cmd_snapshot_record(cmd_ctx->session,
+ &cmd_ctx->lsm->u.snapshot_record.output,
+ cmd_ctx->lsm->u.snapshot_record.wait);
+ break;
+ }
+ case LTTNG_CREATE_SESSION_SNAPSHOT:
+ {
+ size_t nb_uri, len;
+ struct lttng_uri *uris = NULL;
+
+ nb_uri = cmd_ctx->lsm->u.uri.size;
+ len = nb_uri * sizeof(struct lttng_uri);
+
+ if (nb_uri > 0) {
+ uris = zmalloc(len);
+ if (uris == NULL) {
+ ret = LTTNG_ERR_FATAL;
+ goto error;
+ }
+
+ /* Receive variable len data */
+ DBG("Waiting for %zu URIs from client ...", nb_uri);
+ ret = lttcomm_recv_unix_sock(sock, uris, len);
+ if (ret <= 0) {
+ DBG("No URIs received from client... continuing");
+ *sock_error = 1;
+ ret = LTTNG_ERR_SESSION_FAIL;
+ free(uris);
+ goto error;
+ }
+
+ if (nb_uri == 1 && uris[0].dtype != LTTNG_DST_PATH) {
+ DBG("Creating session with ONE network URI is a bad call");
+ ret = LTTNG_ERR_SESSION_FAIL;
+ free(uris);
+ goto error;
+ }
+ }
+
+ ret = cmd_create_session_snapshot(cmd_ctx->lsm->session.name, uris,
+ nb_uri, &cmd_ctx->creds);
+ free(uris);
+ break;
+ }
+ case LTTNG_CREATE_SESSION_LIVE:
+ {
+ size_t nb_uri, len;
+ struct lttng_uri *uris = NULL;
+
+ nb_uri = cmd_ctx->lsm->u.uri.size;
+ len = nb_uri * sizeof(struct lttng_uri);
+
+ if (nb_uri > 0) {
+ uris = zmalloc(len);
+ if (uris == NULL) {
+ ret = LTTNG_ERR_FATAL;
+ goto error;
+ }
+
+ /* Receive variable len data */
+ DBG("Waiting for %zu URIs from client ...", nb_uri);
+ ret = lttcomm_recv_unix_sock(sock, uris, len);
+ if (ret <= 0) {
+ DBG("No URIs received from client... continuing");
+ *sock_error = 1;
+ ret = LTTNG_ERR_SESSION_FAIL;
+ free(uris);
+ goto error;
+ }
+
+ if (nb_uri == 1 && uris[0].dtype != LTTNG_DST_PATH) {
+ DBG("Creating session with ONE network URI is a bad call");
+ ret = LTTNG_ERR_SESSION_FAIL;
+ free(uris);
+ goto error;
+ }
+ }
+
+ ret = cmd_create_session_uri(cmd_ctx->lsm->session.name, uris,
+ nb_uri, &cmd_ctx->creds, cmd_ctx->lsm->u.session_live.timer_interval);
+ free(uris);
+ break;
+ }
+ case LTTNG_SAVE_SESSION:
+ {
+ ret = cmd_save_sessions(&cmd_ctx->lsm->u.save_session.attr,
+ &cmd_ctx->creds);
+ break;
+ }
+ case LTTNG_SET_SESSION_SHM_PATH:
+ {
+ ret = cmd_set_session_shm_path(cmd_ctx->session,
+ cmd_ctx->lsm->u.set_shm_path.shm_path);
+ break;
+ }
+ case LTTNG_REGENERATE_METADATA:
+ {
+ ret = cmd_regenerate_metadata(cmd_ctx->session);
+ break;
+ }
+ case LTTNG_REGENERATE_STATEDUMP:
+ {
+ ret = cmd_regenerate_statedump(cmd_ctx->session);
+ break;
+ }
+ case LTTNG_REGISTER_TRIGGER:
+ {
+ ret = cmd_register_trigger(cmd_ctx, sock,
+ notification_thread_handle);
+ break;
+ }
+ case LTTNG_UNREGISTER_TRIGGER:
+ {
+ ret = cmd_unregister_trigger(cmd_ctx, sock,
+ notification_thread_handle);
+ break;
+ }
+ case LTTNG_ROTATE_SESSION:
+ {
+ struct lttng_rotate_session_return rotate_return;
+
+ DBG("Client rotate session \"%s\"", cmd_ctx->session->name);
+
+ memset(&rotate_return, 0, sizeof(rotate_return));
+ if (cmd_ctx->session->kernel_session && !check_rotate_compatible()) {
+ DBG("Kernel tracer version is not compatible with the rotation feature");
+ ret = LTTNG_ERR_ROTATION_WRONG_VERSION;
+ goto error;
+ }
+
+ ret = cmd_rotate_session(cmd_ctx->session, &rotate_return);
+ if (ret < 0) {
+ ret = -ret;
+ goto error;
+ }
+
+ ret = setup_lttng_msg_no_cmd_header(cmd_ctx, &rotate_return,
+ sizeof(rotate_return));
+ if (ret < 0) {
+ ret = -ret;
+ goto error;
+ }
+
+ ret = LTTNG_OK;
+ break;
+ }
+ case LTTNG_ROTATION_GET_INFO:
+ {
+ struct lttng_rotation_get_info_return get_info_return;
+
+ memset(&get_info_return, 0, sizeof(get_info_return));
+ ret = cmd_rotate_get_info(cmd_ctx->session, &get_info_return,
+ cmd_ctx->lsm->u.get_rotation_info.rotation_id);
+ if (ret < 0) {
+ ret = -ret;
+ goto error;
+ }
+
+ ret = setup_lttng_msg_no_cmd_header(cmd_ctx, &get_info_return,
+ sizeof(get_info_return));
+ if (ret < 0) {
+ ret = -ret;
+ goto error;
+ }
+
+ ret = LTTNG_OK;
+ break;
+ }
+ case LTTNG_ROTATION_SET_SCHEDULE:
+ {
+ bool set_schedule;
+ enum lttng_rotation_schedule_type schedule_type;
+ uint64_t value;
+
+ if (cmd_ctx->session->kernel_session && !check_rotate_compatible()) {
+ DBG("Kernel tracer version does not support session rotations");
+ ret = LTTNG_ERR_ROTATION_WRONG_VERSION;
+ goto error;
+ }
+
+ set_schedule = cmd_ctx->lsm->u.rotation_set_schedule.set == 1;
+ schedule_type = (enum lttng_rotation_schedule_type) cmd_ctx->lsm->u.rotation_set_schedule.type;
+ 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);
+ if (ret != LTTNG_OK) {
+ goto error;
+ }
+
+ break;
+ }
+ case LTTNG_SESSION_LIST_ROTATION_SCHEDULES:
+ {
+ struct lttng_session_list_schedules_return schedules = {
+ .periodic.set = !!cmd_ctx->session->rotate_timer_period,
+ .periodic.value = cmd_ctx->session->rotate_timer_period,
+ .size.set = !!cmd_ctx->session->rotate_size,
+ .size.value = cmd_ctx->session->rotate_size,
+ };
+
+ ret = setup_lttng_msg_no_cmd_header(cmd_ctx, &schedules,
+ sizeof(schedules));
+ if (ret < 0) {
+ ret = -ret;
+ goto error;
+ }
+
+ ret = LTTNG_OK;
+ break;
+ }
+ default:
+ ret = LTTNG_ERR_UND;
+ break;
+ }
+
+error:
+ if (cmd_ctx->llm == NULL) {
+ DBG("Missing llm structure. Allocating one.");
+ if (setup_lttng_msg_no_cmd_header(cmd_ctx, NULL, 0) < 0) {
+ goto setup_error;
+ }
+ }
+ /* Set return code */
+ cmd_ctx->llm->ret_code = ret;
+setup_error:
+ if (cmd_ctx->session) {
+ session_unlock(cmd_ctx->session);
+ session_put(cmd_ctx->session);
+ }
+ if (need_tracing_session) {
+ session_unlock_list();
+ }
+init_setup_error:
+ assert(!rcu_read_ongoing());
+ return ret;
+}
+
+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);
+ if (client_sock < 0) {
+ ERR("Create unix sock failed: %s", config.client_unix_sock_path.value);
+ ret = -1;
+ goto end;
+ }
+
+ /* Set the cloexec flag */
+ ret = utils_set_fd_cloexec(client_sock);
+ if (ret < 0) {
+ ERR("Unable to set CLOEXEC flag to the client Unix socket (fd: %d). "
+ "Continuing but note that the consumer daemon will have a "
+ "reference to this socket on exec()", client_sock);
+ }
+
+ /* File permission MUST be 660 */
+ ret = chmod(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);
+ PERROR("chmod");
+ goto end;
+ }
+ DBG("Created client socket (fd = %i)", client_sock);
+ ret = client_sock;
+end:
+ umask(old_umask);
+ return ret;
+}
+
+static void cleanup_client_thread(void *data)
+{
+ struct lttng_pipe *quit_pipe = data;
+
+ lttng_pipe_destroy(quit_pipe);
+}
+
+/*
+ * This thread manage all clients request using the unix client socket for
+ * communication.
+ */
+static void *thread_manage_clients(void *data)
+{
+ int sock = -1, ret, i, pollfd, err = -1;
+ int sock_error;
+ uint32_t revents, nb_fd;
+ struct command_ctx *cmd_ctx = NULL;
+ struct lttng_poll_event events;
+ int client_sock = -1;
+ struct lttng_pipe *quit_pipe = data;
+ const int thread_quit_pipe_fd = lttng_pipe_get_readfd(quit_pipe);
+
+ DBG("[thread] Manage client started");
+
+ is_root = (getuid() == 0);
+
+ client_sock = create_client_sock();
+ if (client_sock < 0) {
+ goto error_listen;
+ }
+
+ rcu_register_thread();
+
+ health_register(health_sessiond, HEALTH_SESSIOND_TYPE_CMD);
+
+ health_code_update();
+
+ ret = lttcomm_listen_unix_sock(client_sock);
+ if (ret < 0) {
+ goto error_listen;
+ }
+
+ /*
+ * Pass 2 as size here for the thread quit pipe and client_sock. Nothing
+ * more will be added to this poll set.
+ */
+ ret = lttng_poll_create(&events, 2, LTTNG_CLOEXEC);
+ if (ret < 0) {
+ goto error_create_poll;
+ }
+
+ /* Add the application registration socket */
+ ret = lttng_poll_add(&events, client_sock, LPOLLIN | LPOLLPRI);
+ if (ret < 0) {
+ goto error;
+ }
+
+ /* Add thread quit pipe */
+ ret = lttng_poll_add(&events, thread_quit_pipe_fd, LPOLLIN | LPOLLERR);
+ if (ret < 0) {
+ goto error;
+ }
+
+ /* This testpoint is after we signal readiness to the parent. */
+ if (testpoint(sessiond_thread_manage_clients)) {
+ goto error;
+ }
+
+ if (testpoint(sessiond_thread_manage_clients_before_loop)) {
+ goto error;
+ }
+
+ health_code_update();
+
+ /* Set state as running. */
+ set_thread_state_running();
+
+ while (1) {
+ const struct cmd_completion_handler *cmd_completion_handler;
+
+ DBG("Accepting client command ...");
+
+ /* Inifinite blocking call, waiting for transmission */
+ restart:
+ health_poll_entry();
+ ret = lttng_poll_wait(&events, -1);
+ health_poll_exit();
+ if (ret < 0) {
+ /*
+ * Restart interrupted system call.
+ */
+ if (errno == EINTR) {
+ goto restart;
+ }
+ goto error;
+ }
+
+ nb_fd = ret;
+
+ for (i = 0; i < nb_fd; i++) {
+ revents = LTTNG_POLL_GETEV(&events, i);
+ pollfd = LTTNG_POLL_GETFD(&events, i);
+
+ health_code_update();
+
+ if (!revents) {
+ /* No activity for this FD (poll implementation). */
+ continue;
+ }
+
+ if (pollfd == thread_quit_pipe_fd) {
+ err = 0;
+ goto exit;
+ } else {
+ /* Event on the registration socket */
+ if (revents & LPOLLIN) {
+ continue;
+ } else if (revents & (LPOLLERR | LPOLLHUP | LPOLLRDHUP)) {
+ ERR("Client socket poll error");
+ goto error;
+ } else {
+ ERR("Unexpected poll events %u for sock %d", revents, pollfd);
+ goto error;
+ }
+ }
+ }
+
+ DBG("Wait for client response");
+
+ health_code_update();
+
+ sock = lttcomm_accept_unix_sock(client_sock);
+ if (sock < 0) {
+ goto error;
+ }
+
+ /*
+ * Set the CLOEXEC flag. Return code is useless because either way, the
+ * show must go on.
+ */
+ (void) utils_set_fd_cloexec(sock);
+
+ /* Set socket option for credentials retrieval */
+ ret = lttcomm_setsockopt_creds_unix_sock(sock);
+ if (ret < 0) {
+ goto error;
+ }
+
+ /* Allocate context command to process the client request */
+ cmd_ctx = zmalloc(sizeof(struct command_ctx));
+ if (cmd_ctx == NULL) {
+ PERROR("zmalloc cmd_ctx");
+ goto error;
+ }
+
+ /* Allocate data buffer for reception */
+ cmd_ctx->lsm = zmalloc(sizeof(struct lttcomm_session_msg));
+ if (cmd_ctx->lsm == NULL) {
+ PERROR("zmalloc cmd_ctx->lsm");
+ goto error;
+ }
+
+ cmd_ctx->llm = NULL;
+ cmd_ctx->session = NULL;
+
+ health_code_update();
+
+ /*
+ * Data is received from the lttng client. The struct
+ * lttcomm_session_msg (lsm) contains the command and data request of
+ * the client.
+ */
+ DBG("Receiving data from client ...");
+ ret = lttcomm_recv_creds_unix_sock(sock, cmd_ctx->lsm,
+ sizeof(struct lttcomm_session_msg), &cmd_ctx->creds);
+ if (ret <= 0) {
+ DBG("Nothing recv() from client... continuing");
+ ret = close(sock);
+ if (ret) {
+ PERROR("close");
+ }
+ sock = -1;
+ clean_command_ctx(&cmd_ctx);
+ continue;
+ }
+
+ health_code_update();
+
+ // TODO: Validate cmd_ctx including sanity check for
+ // security purpose.
+
+ rcu_thread_online();
+ /*
+ * This function dispatch the work to the kernel or userspace tracer
+ * libs and fill the lttcomm_lttng_msg data structure of all the needed
+ * informations for the client. The command context struct contains
+ * everything this function may needs.
+ */
+ ret = process_client_msg(cmd_ctx, sock, &sock_error);
+ rcu_thread_offline();
+ if (ret < 0) {
+ ret = close(sock);
+ if (ret) {
+ PERROR("close");
+ }
+ sock = -1;
+ /*
+ * TODO: Inform client somehow of the fatal error. At
+ * this point, ret < 0 means that a zmalloc failed
+ * (ENOMEM). Error detected but still accept
+ * command, unless a socket error has been
+ * detected.
+ */
+ clean_command_ctx(&cmd_ctx);
+ continue;
+ }
+
+ cmd_completion_handler = cmd_pop_completion_handler();
+ if (cmd_completion_handler) {
+ enum lttng_error_code completion_code;
+
+ completion_code = cmd_completion_handler->run(
+ cmd_completion_handler->data);
+ if (completion_code != LTTNG_OK) {
+ clean_command_ctx(&cmd_ctx);
+ continue;
+ }
+ }
+
+ health_code_update();
+
+ DBG("Sending response (size: %d, retcode: %s (%d))",
+ cmd_ctx->lttng_msg_size,
+ lttng_strerror(-cmd_ctx->llm->ret_code),
+ cmd_ctx->llm->ret_code);
+ ret = send_unix_sock(sock, cmd_ctx->llm, cmd_ctx->lttng_msg_size);
+ if (ret < 0) {
+ ERR("Failed to send data back to client");
+ }
+
+ /* End of transmission */
+ ret = close(sock);
+ if (ret) {
+ PERROR("close");
+ }
+ sock = -1;
+
+ clean_command_ctx(&cmd_ctx);
+
+ health_code_update();
+ }
+
+exit:
+error:
+ if (sock >= 0) {
+ ret = close(sock);
+ if (ret) {
+ PERROR("close");
+ }
+ }
+
+ lttng_poll_clean(&events);
+ clean_command_ctx(&cmd_ctx);
+
+error_listen:
+error_create_poll:
+ unlink(config.client_unix_sock_path.value);
+ if (client_sock >= 0) {
+ ret = close(client_sock);
+ if (ret) {
+ PERROR("close");
+ }
+ }
+
+ if (err) {
+ health_error();
+ ERR("Health error occurred in %s", __func__);
+ }
+
+ health_unregister(health_sessiond);
+
+ DBG("Client thread dying");
+
+ rcu_unregister_thread();
+
+ /*
+ * Since we are creating the consumer threads, we own them, so we need
+ * to join them before our thread exits.
+ */
+ ret = join_consumer_thread(&kconsumer_data);
+ if (ret) {
+ errno = ret;
+ PERROR("join_consumer");
+ }
+
+ ret = join_consumer_thread(&ustconsumer32_data);
+ if (ret) {
+ errno = ret;
+ PERROR("join_consumer ust32");
+ }
+
+ ret = join_consumer_thread(&ustconsumer64_data);
+ if (ret) {
+ errno = ret;
+ PERROR("join_consumer ust64");
+ }
+ return NULL;
+}
+
+static
+bool shutdown_client_thread(void *thread_data)
+{
+ struct lttng_pipe *client_quit_pipe = thread_data;
+ const int write_fd = lttng_pipe_get_writefd(client_quit_pipe);
+
+ return notify_thread_pipe(write_fd) == 1;
+}
+
+struct lttng_thread *launch_client_thread(void)
+{
+ struct lttng_pipe *client_quit_pipe;
+ struct lttng_thread *thread;
+
+ client_quit_pipe = lttng_pipe_open(FD_CLOEXEC);
+ if (!client_quit_pipe) {
+ goto error;
+ }
+
+ thread = lttng_thread_create("Client management",
+ thread_manage_clients,
+ shutdown_client_thread,
+ cleanup_client_thread,
+ client_quit_pipe);
+ if (!thread) {
+ goto error;
+ }
+
+ /*
+ * This thread is part of the threads that need to be fully
+ * initialized before the session daemon is marked as "ready".
+ */
+ wait_thread_state_running();
+
+ return thread;
+error:
+ cleanup_client_thread(client_quit_pipe);
+ return NULL;
+}
--- /dev/null
+/*
+ * Copyright (C) 2011 - David Goulet <david.goulet@polymtl.ca>
+ * Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
+ * 2013 - Jérémie Galarneau <jeremie.galarneau@efficios.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License, version 2 only,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+#ifndef CLIENT_SESSIOND_H
+#define CLIENT_SESSIOND_H
+
+#include "thread.h"
+
+struct lttng_thread *launch_client_thread(void);
+
+#endif /* CLIENT_SESSIOND_H */
struct lttng_ht *agent_apps_ht_by_sock = NULL;
int kernel_tracer_fd = -1;
+struct lttng_kernel_tracer_version kernel_tracer_version;
+struct lttng_kernel_tracer_abi_version kernel_tracer_abi_version;
int apps_cmd_notify_pipe[2] = { -1, -1 };
int kernel_poll_pipe[2] = { -1, -1 };
pid_t child_ppid;
struct sessiond_config config;
+
+struct consumer_data kconsumer_data = {
+ .type = LTTNG_CONSUMER_KERNEL,
+ .err_sock = -1,
+ .cmd_sock = -1,
+ .channel_monitor_pipe = -1,
+ .pid_mutex = PTHREAD_MUTEX_INITIALIZER,
+ .lock = PTHREAD_MUTEX_INITIALIZER,
+ .cond = PTHREAD_COND_INITIALIZER,
+ .cond_mutex = PTHREAD_MUTEX_INITIALIZER,
+};
+
+struct consumer_data ustconsumer64_data = {
+ .type = LTTNG_CONSUMER64_UST,
+ .err_sock = -1,
+ .cmd_sock = -1,
+ .channel_monitor_pipe = -1,
+ .pid_mutex = PTHREAD_MUTEX_INITIALIZER,
+ .lock = PTHREAD_MUTEX_INITIALIZER,
+ .cond = PTHREAD_COND_INITIALIZER,
+ .cond_mutex = PTHREAD_MUTEX_INITIALIZER,
+};
+
+struct consumer_data ustconsumer32_data = {
+ .type = LTTNG_CONSUMER32_UST,
+ .err_sock = -1,
+ .cmd_sock = -1,
+ .channel_monitor_pipe = -1,
+ .pid_mutex = PTHREAD_MUTEX_INITIALIZER,
+ .lock = PTHREAD_MUTEX_INITIALIZER,
+ .cond = PTHREAD_COND_INITIALIZER,
+ .cond_mutex = PTHREAD_MUTEX_INITIALIZER,
+};
+
+enum consumerd_state ust_consumerd_state;
+enum consumerd_state kernel_consumerd_state;
if (!data) {
return;
}
-
- if (data->sem_initialized) {
- int ret;
-
- ret = sem_destroy(&data->message_thread_ready);
- if (ret) {
- PERROR("sem_destroy message_thread_ready");
- }
- }
}
/*
*/
int load_session_init_data(struct load_session_thread_data **data)
{
- int ret;
struct load_session_thread_data *_data = NULL;
assert(data);
PERROR("zmalloc load session info");
goto error;
}
- ret = sem_init(&_data->message_thread_ready, 0, 0);
- if (ret) {
- PERROR("sem_init message_thread_ready");
- goto error;
- }
- _data->sem_initialized = 1;
*data = _data;
return 0;
DBG("[load-session-thread] Load session");
- ret = sem_wait(&info->message_thread_ready);
- if (ret) {
- PERROR("sem_wait message_thread_ready");
- goto end;
- }
-
/* Override existing session and autoload also. */
ret = config_load_session(info->path, NULL, 1, 1, NULL);
if (ret) {
ERR("Session load failed: %s", error_get_str(ret));
}
-end:
sessiond_signal_parents();
return NULL;
}
/* Data passed to the thread. */
struct load_session_thread_data {
- /* Flag if the sem_init() has been done successfully on the sem. */
- unsigned int sem_initialized:1;
-
- /*
- * The load session thread waits on that semaphore which the client thread
- * will do a sem_post() to unblock it.
- */
- sem_t message_thread_ready;
-
/* Path where the sessions are located. */
const char *path;
};
#include "notification-thread.h"
#include "sessiond-config.h"
+/*
+ * Consumer daemon state which is changed when spawning it, killing it or in
+ * case of a fatal error.
+ */
+enum consumerd_state {
+ CONSUMER_STARTED = 1,
+ CONSUMER_STOPPED = 2,
+ CONSUMER_ERROR = 3,
+};
+
+/*
+ * This consumer daemon state is used to validate if a client command will be
+ * able to reach the consumer. If not, the client is informed. For instance,
+ * doing a "lttng start" when the consumer state is set to ERROR will return an
+ * error to the client.
+ *
+ * The following example shows a possible race condition of this scheme:
+ *
+ * consumer thread error happens
+ * client cmd arrives
+ * client cmd checks state -> still OK
+ * consumer thread exit, sets error
+ * client cmd try to talk to consumer
+ * ...
+ *
+ * However, since the consumer is a different daemon, we have no way of making
+ * sure the command will reach it safely even with this state flag. This is why
+ * we consider that up to the state validation during command processing, the
+ * command is safe. After that, we can not guarantee the correctness of the
+ * client request vis-a-vis the consumer.
+ */
+extern enum consumerd_state ust_consumerd_state;
+extern enum consumerd_state kernel_consumerd_state;
+
extern const char default_home_dir[],
default_tracing_group[],
default_ust_sock_dir[],
/* Set in main.c at boot time of the daemon */
extern int kernel_tracer_fd;
+extern struct lttng_kernel_tracer_version kernel_tracer_version;
+extern struct lttng_kernel_tracer_abi_version kernel_tracer_abi_version;
/* Notification thread handle. */
extern struct notification_thread_handle *notification_thread_handle;
/* Internal parent PID use with daemonize. */
extern pid_t child_ppid;
+/* Consumer daemon specific control data. */
+extern struct consumer_data ustconsumer32_data;
+extern struct consumer_data ustconsumer64_data;
+extern struct consumer_data kconsumer_data;
+
int sessiond_init_thread_quit_pipe(void);
int sessiond_check_thread_quit_pipe(int fd, uint32_t events);
int sessiond_wait_for_quit_pipe(unsigned int timeout_us);
void sessiond_set_client_thread_state(bool running);
void sessiond_wait_client_thread_stopped(void);
+void *thread_manage_consumer(void *data);
+
#endif /* _LTT_SESSIOND_H */
#include <common/daemonize.h>
#include <common/config/session-config.h>
#include <common/dynamic-buffer.h>
-#include <lttng/userspace-probe-internal.h>
#include <lttng/event-internal.h>
#include "lttng-sessiond.h"
#include "sessiond-config.h"
#include "timer.h"
#include "thread.h"
+#include "client.h"
static const char *help_msg =
#ifdef LTTNG_EMBED_HELP
/* Set to 1 when a SIGUSR1 signal is received. */
static int recv_child_signal;
-static struct lttng_kernel_tracer_version kernel_tracer_version;
-static struct lttng_kernel_tracer_abi_version kernel_tracer_abi_version;
-
-/*
- * Consumer daemon specific control data. Every value not initialized here is
- * set to 0 by the static definition.
- */
-static struct consumer_data kconsumer_data = {
- .type = LTTNG_CONSUMER_KERNEL,
- .err_sock = -1,
- .cmd_sock = -1,
- .channel_monitor_pipe = -1,
- .pid_mutex = PTHREAD_MUTEX_INITIALIZER,
- .lock = PTHREAD_MUTEX_INITIALIZER,
- .cond = PTHREAD_COND_INITIALIZER,
- .cond_mutex = PTHREAD_MUTEX_INITIALIZER,
-};
-static struct consumer_data ustconsumer64_data = {
- .type = LTTNG_CONSUMER64_UST,
- .err_sock = -1,
- .cmd_sock = -1,
- .channel_monitor_pipe = -1,
- .pid_mutex = PTHREAD_MUTEX_INITIALIZER,
- .lock = PTHREAD_MUTEX_INITIALIZER,
- .cond = PTHREAD_COND_INITIALIZER,
- .cond_mutex = PTHREAD_MUTEX_INITIALIZER,
-};
-static struct consumer_data ustconsumer32_data = {
- .type = LTTNG_CONSUMER32_UST,
- .err_sock = -1,
- .cmd_sock = -1,
- .channel_monitor_pipe = -1,
- .pid_mutex = PTHREAD_MUTEX_INITIALIZER,
- .lock = PTHREAD_MUTEX_INITIALIZER,
- .cond = PTHREAD_COND_INITIALIZER,
- .cond_mutex = PTHREAD_MUTEX_INITIALIZER,
-};
-
/* Command line options */
static const struct option long_options[] = {
{ "client-sock", required_argument, 0, 'c' },
/* Shared between threads */
static int dispatch_thread_exit;
-/* Sockets and FDs */
-static int client_sock = -1;
static int apps_sock = -1;
/*
static pthread_t apps_thread;
static pthread_t apps_notify_thread;
static pthread_t reg_apps_thread;
-static pthread_t client_thread;
static pthread_t kernel_thread;
static pthread_t dispatch_thread;
static pthread_t agent_reg_thread;
static const char *module_proc_lttng = "/proc/lttng";
-/*
- * Consumer daemon state which is changed when spawning it, killing it or in
- * case of a fatal error.
- */
-enum consumerd_state {
- CONSUMER_STARTED = 1,
- CONSUMER_STOPPED = 2,
- CONSUMER_ERROR = 3,
-};
-
-/*
- * This consumer daemon state is used to validate if a client command will be
- * able to reach the consumer. If not, the client is informed. For instance,
- * doing a "lttng start" when the consumer state is set to ERROR will return an
- * error to the client.
- *
- * The following example shows a possible race condition of this scheme:
- *
- * consumer thread error happens
- * client cmd arrives
- * client cmd checks state -> still OK
- * consumer thread exit, sets error
- * client cmd try to talk to consumer
- * ...
- *
- * However, since the consumer is a different daemon, we have no way of making
- * sure the command will reach it safely even with this state flag. This is why
- * we consider that up to the state validation during command processing, the
- * command is safe. After that, we can not guarantee the correctness of the
- * client request vis-a-vis the consumer.
- */
-static enum consumerd_state ust_consumerd_state;
-static enum consumerd_state kernel_consumerd_state;
-
/* Load session thread information to operate. */
static struct load_session_thread_data *load_info;
run_as_destroy_worker();
}
-/*
- * Send data on a unix socket using the liblttsessiondcomm API.
- *
- * Return lttcomm error code.
- */
-static int send_unix_sock(int sock, void *buf, size_t len)
-{
- /* Check valid length */
- if (len == 0) {
- return -1;
- }
-
- return lttcomm_send_unix_sock(sock, buf, len);
-}
-
-/*
- * Free memory of a command context structure.
- */
-static void clean_command_ctx(struct command_ctx **cmd_ctx)
-{
- DBG("Clean command context structure");
- if (*cmd_ctx) {
- if ((*cmd_ctx)->llm) {
- free((*cmd_ctx)->llm);
- }
- if ((*cmd_ctx)->lsm) {
- free((*cmd_ctx)->lsm);
- }
- free(*cmd_ctx);
- *cmd_ctx = NULL;
- }
-}
-
/*
* Notify UST applications using the shm mmap futex.
*/
return -1;
}
-/*
- * Setup the outgoing data buffer for the response (llm) by allocating the
- * right amount of memory and copying the original information from the lsm
- * structure.
- *
- * Return 0 on success, negative value on error.
- */
-static int setup_lttng_msg(struct command_ctx *cmd_ctx,
- const void *payload_buf, size_t payload_len,
- const void *cmd_header_buf, size_t cmd_header_len)
-{
- int ret = 0;
- const size_t header_len = sizeof(struct lttcomm_lttng_msg);
- const size_t cmd_header_offset = header_len;
- const size_t payload_offset = cmd_header_offset + cmd_header_len;
- const size_t total_msg_size = header_len + cmd_header_len + payload_len;
-
- cmd_ctx->llm = zmalloc(total_msg_size);
-
- if (cmd_ctx->llm == NULL) {
- PERROR("zmalloc");
- ret = -ENOMEM;
- goto end;
- }
-
- /* Copy common data */
- cmd_ctx->llm->cmd_type = cmd_ctx->lsm->cmd_type;
- cmd_ctx->llm->pid = cmd_ctx->lsm->domain.attr.pid;
- cmd_ctx->llm->cmd_header_size = cmd_header_len;
- cmd_ctx->llm->data_size = payload_len;
- cmd_ctx->lttng_msg_size = total_msg_size;
-
- /* Copy command header */
- if (cmd_header_len) {
- memcpy(((uint8_t *) cmd_ctx->llm) + cmd_header_offset, cmd_header_buf,
- cmd_header_len);
- }
-
- /* Copy payload */
- if (payload_len) {
- memcpy(((uint8_t *) cmd_ctx->llm) + payload_offset, payload_buf,
- payload_len);
- }
-
-end:
- return ret;
-}
-
-/*
- * Version of setup_lttng_msg() without command header.
- */
-static int setup_lttng_msg_no_cmd_header(struct command_ctx *cmd_ctx,
- void *payload_buf, size_t payload_len)
-{
- return setup_lttng_msg(cmd_ctx, payload_buf, payload_len, NULL, 0);
-}
/*
* Update the kernel poll set of all channel fd available over all tracing
* session. Add the wakeup pipe at the end of the set.
/*
* This thread manage the consumer error sent back to the session daemon.
*/
-static void *thread_manage_consumer(void *data)
+void *thread_manage_consumer(void *data)
{
int sock = -1, i, ret, pollfd, err = -1, should_quit = 0;
uint32_t revents, nb_fd;
return NULL;
}
-/*
- * Start the thread_manage_consumer. This must be done after a lttng-consumerd
- * exec or it will fails.
- */
-static int spawn_consumer_thread(struct consumer_data *consumer_data)
-{
- int ret, clock_ret;
- struct timespec timeout;
-
- /*
- * Make sure we set the readiness flag to 0 because we are NOT ready.
- * This access to consumer_thread_is_ready does not need to be
- * protected by consumer_data.cond_mutex (yet) since the consumer
- * management thread has not been started at this point.
- */
- consumer_data->consumer_thread_is_ready = 0;
-
- /* Setup pthread condition */
- ret = pthread_condattr_init(&consumer_data->condattr);
- if (ret) {
- errno = ret;
- PERROR("pthread_condattr_init consumer data");
- goto error;
- }
-
- /*
- * Set the monotonic clock in order to make sure we DO NOT jump in time
- * between the clock_gettime() call and the timedwait call. See bug #324
- * for a more details and how we noticed it.
- */
- ret = pthread_condattr_setclock(&consumer_data->condattr, CLOCK_MONOTONIC);
- if (ret) {
- errno = ret;
- PERROR("pthread_condattr_setclock consumer data");
- goto error;
- }
-
- ret = pthread_cond_init(&consumer_data->cond, &consumer_data->condattr);
- if (ret) {
- errno = ret;
- PERROR("pthread_cond_init consumer data");
- goto error;
- }
-
- ret = pthread_create(&consumer_data->thread, default_pthread_attr(),
- thread_manage_consumer, consumer_data);
- if (ret) {
- errno = ret;
- PERROR("pthread_create consumer");
- ret = -1;
- goto error;
- }
-
- /* We are about to wait on a pthread condition */
- pthread_mutex_lock(&consumer_data->cond_mutex);
-
- /* Get time for sem_timedwait absolute timeout */
- clock_ret = lttng_clock_gettime(CLOCK_MONOTONIC, &timeout);
- /*
- * Set the timeout for the condition timed wait even if the clock gettime
- * call fails since we might loop on that call and we want to avoid to
- * increment the timeout too many times.
- */
- timeout.tv_sec += DEFAULT_SEM_WAIT_TIMEOUT;
-
- /*
- * The following loop COULD be skipped in some conditions so this is why we
- * set ret to 0 in order to make sure at least one round of the loop is
- * done.
- */
- ret = 0;
-
- /*
- * Loop until the condition is reached or when a timeout is reached. Note
- * that the pthread_cond_timedwait(P) man page specifies that EINTR can NOT
- * be returned but the pthread_cond(3), from the glibc-doc, says that it is
- * possible. This loop does not take any chances and works with both of
- * them.
- */
- while (!consumer_data->consumer_thread_is_ready && ret != ETIMEDOUT) {
- if (clock_ret < 0) {
- PERROR("clock_gettime spawn consumer");
- /* Infinite wait for the consumerd thread to be ready */
- ret = pthread_cond_wait(&consumer_data->cond,
- &consumer_data->cond_mutex);
- } else {
- ret = pthread_cond_timedwait(&consumer_data->cond,
- &consumer_data->cond_mutex, &timeout);
- }
- }
-
- /* Release the pthread condition */
- pthread_mutex_unlock(&consumer_data->cond_mutex);
-
- if (ret != 0) {
- errno = ret;
- if (ret == ETIMEDOUT) {
- int pth_ret;
-
- /*
- * Call has timed out so we kill the kconsumerd_thread and return
- * an error.
- */
- ERR("Condition timed out. The consumer thread was never ready."
- " Killing it");
- pth_ret = pthread_cancel(consumer_data->thread);
- if (pth_ret < 0) {
- PERROR("pthread_cancel consumer thread");
- }
- } else {
- PERROR("pthread_cond_wait failed consumer thread");
- }
- /* Caller is expecting a negative value on failure. */
- ret = -1;
- goto error;
- }
-
- pthread_mutex_lock(&consumer_data->pid_mutex);
- if (consumer_data->pid == 0) {
- ERR("Consumerd did not start");
- pthread_mutex_unlock(&consumer_data->pid_mutex);
- goto error;
- }
- pthread_mutex_unlock(&consumer_data->pid_mutex);
-
- return 0;
-
-error:
- return ret;
-}
-
-/*
- * Join consumer thread
- */
-static int join_consumer_thread(struct consumer_data *consumer_data)
-{
- void *status;
-
- /* Consumer pid must be a real one. */
- if (consumer_data->pid > 0) {
- int ret;
- ret = kill(consumer_data->pid, SIGTERM);
- if (ret) {
- PERROR("Error killing consumer daemon");
- return ret;
- }
- return pthread_join(consumer_data->thread, &status);
- } else {
- return 0;
- }
-}
-
-/*
- * Fork and exec a consumer daemon (consumerd).
- *
- * Return pid if successful else -1.
- */
-static pid_t spawn_consumerd(struct consumer_data *consumer_data)
-{
- int ret;
- pid_t pid;
- const char *consumer_to_use;
- const char *verbosity;
- struct stat st;
-
- DBG("Spawning consumerd");
-
- pid = fork();
- if (pid == 0) {
- /*
- * Exec consumerd.
- */
- if (config.verbose_consumer) {
- verbosity = "--verbose";
- } else if (lttng_opt_quiet) {
- verbosity = "--quiet";
- } else {
- verbosity = "";
- }
-
- switch (consumer_data->type) {
- case LTTNG_CONSUMER_KERNEL:
- /*
- * Find out which consumerd to execute. We will first try the
- * 64-bit path, then the sessiond's installation directory, and
- * 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(" 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("Found location #1");
- consumer_to_use = 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) {
- DBG3("Found location #3");
- consumer_to_use = 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);
- break;
- case LTTNG_CONSUMER64_UST:
- {
- if (config.consumerd64_lib_dir.value) {
- char *tmp;
- size_t tmplen;
- char *tmpnew;
-
- tmp = lttng_secure_getenv("LD_LIBRARY_PATH");
- if (!tmp) {
- tmp = "";
- }
- tmplen = strlen(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);
- if (tmp[0] != '\0') {
- strcat(tmpnew, ":");
- strcat(tmpnew, tmp);
- }
- ret = setenv("LD_LIBRARY_PATH", tmpnew, 1);
- free(tmpnew);
- if (ret) {
- ret = -errno;
- 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,
- NULL);
- break;
- }
- case LTTNG_CONSUMER32_UST:
- {
- if (config.consumerd32_lib_dir.value) {
- char *tmp;
- size_t tmplen;
- char *tmpnew;
-
- tmp = lttng_secure_getenv("LD_LIBRARY_PATH");
- if (!tmp) {
- tmp = "";
- }
- tmplen = strlen(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);
- if (tmp[0] != '\0') {
- strcat(tmpnew, ":");
- strcat(tmpnew, tmp);
- }
- ret = setenv("LD_LIBRARY_PATH", tmpnew, 1);
- free(tmpnew);
- if (ret) {
- ret = -errno;
- 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,
- NULL);
- break;
- }
- default:
- ERR("unknown consumer type");
- errno = 0;
- }
- if (errno != 0) {
- PERROR("Consumer execl()");
- }
- /* Reaching this point, we got a failure on our execl(). */
- exit(EXIT_FAILURE);
- } else if (pid > 0) {
- ret = pid;
- } else {
- PERROR("start consumer fork");
- ret = -errno;
- }
-error:
- return ret;
-}
-
-/*
- * Spawn the consumerd daemon and session daemon thread.
- */
-static int start_consumerd(struct consumer_data *consumer_data)
-{
- int ret;
-
- /*
- * Set the listen() state on the socket since there is a possible race
- * between the exec() of the consumer daemon and this call if place in the
- * consumer thread. See bug #366 for more details.
- */
- ret = lttcomm_listen_unix_sock(consumer_data->err_sock);
- if (ret < 0) {
- goto error;
- }
-
- pthread_mutex_lock(&consumer_data->pid_mutex);
- if (consumer_data->pid != 0) {
- pthread_mutex_unlock(&consumer_data->pid_mutex);
- goto end;
- }
-
- ret = spawn_consumerd(consumer_data);
- if (ret < 0) {
- ERR("Spawning consumerd failed");
- pthread_mutex_unlock(&consumer_data->pid_mutex);
- goto error;
- }
-
- /* Setting up the consumer_data pid */
- consumer_data->pid = ret;
- DBG2("Consumer pid %d", consumer_data->pid);
- pthread_mutex_unlock(&consumer_data->pid_mutex);
-
- DBG2("Spawning consumer control thread");
- ret = spawn_consumer_thread(consumer_data);
- if (ret < 0) {
- ERR("Fatal error spawning consumer control thread");
- goto error;
- }
-
-end:
- return 0;
-
-error:
- /* Cleanup already created sockets on error. */
- if (consumer_data->err_sock >= 0) {
- int err;
-
- err = close(consumer_data->err_sock);
- if (err < 0) {
- PERROR("close consumer data error socket");
- }
- }
- return ret;
-}
-
/*
* Setup necessary data for kernel tracer action.
*/
}
}
-
-/*
- * Copy consumer output from the tracing session to the domain session. The
- * function also applies the right modification on a per domain basis for the
- * trace files destination directory.
- *
- * Should *NOT* be called with RCU read-side lock held.
- */
-static int copy_session_consumer(int domain, struct ltt_session *session)
+static int string_match(const char *str1, const char *str2)
{
- int ret;
- const char *dir_name;
- struct consumer_output *consumer;
-
- assert(session);
- assert(session->consumer);
-
- switch (domain) {
- case LTTNG_DOMAIN_KERNEL:
- DBG3("Copying tracing session consumer output in kernel session");
- /*
- * XXX: We should audit the session creation and what this function
- * does "extra" in order to avoid a destroy since this function is used
- * in the domain session creation (kernel and ust) only. Same for UST
- * domain.
- */
- if (session->kernel_session->consumer) {
- consumer_output_put(session->kernel_session->consumer);
- }
- session->kernel_session->consumer =
- consumer_copy_output(session->consumer);
- /* Ease our life a bit for the next part */
- consumer = session->kernel_session->consumer;
- dir_name = DEFAULT_KERNEL_TRACE_DIR;
- break;
- case LTTNG_DOMAIN_JUL:
- case LTTNG_DOMAIN_LOG4J:
- case LTTNG_DOMAIN_PYTHON:
- case LTTNG_DOMAIN_UST:
- DBG3("Copying tracing session consumer output in UST session");
- if (session->ust_session->consumer) {
- consumer_output_put(session->ust_session->consumer);
- }
- session->ust_session->consumer =
- consumer_copy_output(session->consumer);
- /* Ease our life a bit for the next part */
- consumer = session->ust_session->consumer;
- dir_name = DEFAULT_UST_TRACE_DIR;
- break;
- default:
- ret = LTTNG_ERR_UNKNOWN_DOMAIN;
- goto error;
- }
-
- /* Append correct directory to subdir */
- strncat(consumer->subdir, dir_name,
- sizeof(consumer->subdir) - strlen(consumer->subdir) - 1);
- DBG3("Copy session consumer subdir %s", consumer->subdir);
-
- ret = LTTNG_OK;
-
-error:
- return ret;
+ return (str1 && str2) && !strcmp(str1, str2);
}
/*
- * Create an UST session and add it to the session ust list.
+ * Take an option from the getopt output and set it in the right variable to be
+ * used later.
*
- * Should *NOT* be called with RCU read-side lock held.
+ * Return 0 on success else a negative value.
*/
-static int create_ust_session(struct ltt_session *session,
- struct lttng_domain *domain)
+static int set_option(int opt, const char *arg, const char *optname)
{
- int ret;
- struct ltt_ust_session *lus = NULL;
-
- assert(session);
- assert(domain);
- assert(session->consumer);
-
- switch (domain->type) {
- case LTTNG_DOMAIN_JUL:
- case LTTNG_DOMAIN_LOG4J:
- case LTTNG_DOMAIN_PYTHON:
- case LTTNG_DOMAIN_UST:
- break;
- default:
- ERR("Unknown UST domain on create session %d", domain->type);
- ret = LTTNG_ERR_UNKNOWN_DOMAIN;
- goto error;
- }
-
- DBG("Creating UST session");
-
- lus = trace_ust_create_session(session->id);
- if (lus == NULL) {
- ret = LTTNG_ERR_UST_SESS_FAIL;
- goto error;
- }
-
- lus->uid = session->uid;
- lus->gid = session->gid;
- lus->output_traces = session->output_traces;
- lus->snapshot_mode = session->snapshot_mode;
- lus->live_timer_interval = session->live_timer;
- session->ust_session = lus;
- if (session->shm_path[0]) {
- strncpy(lus->root_shm_path, session->shm_path,
- sizeof(lus->root_shm_path));
- lus->root_shm_path[sizeof(lus->root_shm_path) - 1] = '\0';
- strncpy(lus->shm_path, session->shm_path,
- sizeof(lus->shm_path));
- lus->shm_path[sizeof(lus->shm_path) - 1] = '\0';
- strncat(lus->shm_path, "/ust",
- sizeof(lus->shm_path) - strlen(lus->shm_path) - 1);
- }
- /* Copy session output to the newly created UST session */
- ret = copy_session_consumer(domain->type, session);
- if (ret != LTTNG_OK) {
- goto error;
- }
-
- return LTTNG_OK;
-
-error:
- free(lus);
- session->ust_session = NULL;
- return ret;
-}
-
-/*
- * Create a kernel tracer session then create the default channel.
- */
-static int create_kernel_session(struct ltt_session *session)
-{
- int ret;
-
- DBG("Creating kernel session");
-
- ret = kernel_create_session(session, kernel_tracer_fd);
- if (ret < 0) {
- ret = LTTNG_ERR_KERN_SESS_FAIL;
- goto error;
- }
-
- /* Code flow safety */
- assert(session->kernel_session);
-
- /* Copy session output to the newly created Kernel session */
- ret = copy_session_consumer(LTTNG_DOMAIN_KERNEL, session);
- if (ret != LTTNG_OK) {
- goto error;
- }
-
- session->kernel_session->uid = session->uid;
- session->kernel_session->gid = session->gid;
- session->kernel_session->output_traces = session->output_traces;
- session->kernel_session->snapshot_mode = session->snapshot_mode;
-
- return LTTNG_OK;
-
-error:
- trace_kernel_destroy_session(session->kernel_session);
- session->kernel_session = NULL;
- return ret;
-}
-
-/*
- * Count number of session permitted by uid/gid.
- */
-static unsigned int lttng_sessions_count(uid_t uid, gid_t gid)
-{
- unsigned int i = 0;
- struct ltt_session *session;
- const struct ltt_session_list *session_list = session_get_list();
-
- DBG("Counting number of available session for UID %d GID %d",
- uid, gid);
- 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) &&
- !session->destroyed) {
- i++;
- }
- session_unlock(session);
- session_put(session);
- }
- return i;
-}
-
-static int receive_userspace_probe(struct command_ctx *cmd_ctx, int sock,
- int *sock_error, struct lttng_event *event)
-{
- int fd, ret;
- struct lttng_userspace_probe_location *probe_location;
- const struct lttng_userspace_probe_location_lookup_method *lookup = NULL;
- struct lttng_dynamic_buffer probe_location_buffer;
- struct lttng_buffer_view buffer_view;
-
- /*
- * Create a buffer to store the serialized version of the probe
- * location.
- */
- lttng_dynamic_buffer_init(&probe_location_buffer);
- ret = lttng_dynamic_buffer_set_size(&probe_location_buffer,
- cmd_ctx->lsm->u.enable.userspace_probe_location_len);
- if (ret) {
- ret = LTTNG_ERR_NOMEM;
- goto error;
- }
-
- /*
- * Receive the probe location.
- */
- ret = lttcomm_recv_unix_sock(sock, probe_location_buffer.data,
- probe_location_buffer.size);
- if (ret <= 0) {
- DBG("Nothing recv() from client var len data... continuing");
- *sock_error = 1;
- lttng_dynamic_buffer_reset(&probe_location_buffer);
- ret = LTTNG_ERR_PROBE_LOCATION_INVAL;
- goto error;
- }
-
- buffer_view = lttng_buffer_view_from_dynamic_buffer(
- &probe_location_buffer, 0, probe_location_buffer.size);
-
- /*
- * Extract the probe location from the serialized version.
- */
- ret = lttng_userspace_probe_location_create_from_buffer(
- &buffer_view, &probe_location);
- if (ret < 0) {
- WARN("Failed to create a userspace probe location from the received buffer");
- lttng_dynamic_buffer_reset( &probe_location_buffer);
- ret = LTTNG_ERR_PROBE_LOCATION_INVAL;
- goto error;
- }
-
- /*
- * 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;
- }
-
- /*
- * Set the file descriptor received from the client through the unix
- * socket in the probe location.
- */
- lookup = lttng_userspace_probe_location_get_lookup_method(probe_location);
- if (!lookup) {
- ret = LTTNG_ERR_PROBE_LOCATION_INVAL;
- goto error;
- }
-
- /*
- * From the kernel tracer's perspective, all userspace probe event types
- * are all the same: a file and an offset.
- */
- switch (lttng_userspace_probe_location_lookup_method_get_type(lookup)) {
- case LTTNG_USERSPACE_PROBE_LOCATION_LOOKUP_METHOD_TYPE_FUNCTION_ELF:
- ret = lttng_userspace_probe_location_function_set_binary_fd(
- probe_location, fd);
- break;
- case LTTNG_USERSPACE_PROBE_LOCATION_LOOKUP_METHOD_TYPE_TRACEPOINT_SDT:
- ret = lttng_userspace_probe_location_tracepoint_set_binary_fd(
- probe_location, fd);
- break;
- default:
- ret = LTTNG_ERR_PROBE_LOCATION_INVAL;
- goto error;
- }
-
- if (ret) {
- ret = LTTNG_ERR_PROBE_LOCATION_INVAL;
- goto error;
- }
-
- /* 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;
- }
-
- lttng_dynamic_buffer_reset(&probe_location_buffer);
-error:
- return ret;
-}
-
-/*
- * Check if the current kernel tracer supports the session rotation feature.
- * Return 1 if it does, 0 otherwise.
- */
-static int check_rotate_compatible(void)
-{
- int ret = 1;
-
- if (kernel_tracer_version.major != 2 || kernel_tracer_version.minor < 11) {
- DBG("Kernel tracer version is not compatible with the rotation feature");
- ret = 0;
- }
-
- return ret;
-}
-
-/*
- * Process the command requested by the lttng client within the command
- * context structure. This function make sure that the return structure (llm)
- * is set and ready for transmission before returning.
- *
- * Return any error encountered or 0 for success.
- *
- * "sock" is only used for special-case var. len data.
- *
- * Should *NOT* be called with RCU read-side lock held.
- */
-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;
-
- DBG("Processing client command %d", cmd_ctx->lsm->cmd_type);
-
- assert(!rcu_read_ongoing());
-
- *sock_error = 0;
-
- switch (cmd_ctx->lsm->cmd_type) {
- case LTTNG_CREATE_SESSION:
- case LTTNG_CREATE_SESSION_SNAPSHOT:
- case LTTNG_CREATE_SESSION_LIVE:
- case LTTNG_DESTROY_SESSION:
- case LTTNG_LIST_SESSIONS:
- case LTTNG_LIST_DOMAINS:
- case LTTNG_START_TRACE:
- case LTTNG_STOP_TRACE:
- case LTTNG_DATA_PENDING:
- case LTTNG_SNAPSHOT_ADD_OUTPUT:
- case LTTNG_SNAPSHOT_DEL_OUTPUT:
- case LTTNG_SNAPSHOT_LIST_OUTPUT:
- case LTTNG_SNAPSHOT_RECORD:
- case LTTNG_SAVE_SESSION:
- case LTTNG_SET_SESSION_SHM_PATH:
- case LTTNG_REGENERATE_METADATA:
- case LTTNG_REGENERATE_STATEDUMP:
- case LTTNG_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:
- need_domain = 0;
- break;
- default:
- need_domain = 1;
- }
-
- if (config.no_kernel && need_domain
- && cmd_ctx->lsm->domain.type == LTTNG_DOMAIN_KERNEL) {
- if (!is_root) {
- ret = LTTNG_ERR_NEED_ROOT_SESSIOND;
- } else {
- ret = LTTNG_ERR_KERN_NA;
- }
- goto error;
- }
-
- /* 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) {
- ret = LTTNG_ERR_KERN_CONSUMER_FAIL;
- pthread_mutex_unlock(&kconsumer_data.pid_mutex);
- goto error;
- }
- pthread_mutex_unlock(&kconsumer_data.pid_mutex);
- }
-
- /*
- * Check for command that don't needs to allocate a returned payload. We do
- * this here so we don't have to make the call for no payload at each
- * command.
- */
- switch(cmd_ctx->lsm->cmd_type) {
- case LTTNG_LIST_SESSIONS:
- case LTTNG_LIST_TRACEPOINTS:
- case LTTNG_LIST_TRACEPOINT_FIELDS:
- case LTTNG_LIST_DOMAINS:
- case LTTNG_LIST_CHANNELS:
- case LTTNG_LIST_EVENTS:
- case LTTNG_LIST_SYSCALLS:
- case LTTNG_LIST_TRACKER_PIDS:
- case LTTNG_DATA_PENDING:
- case LTTNG_ROTATE_SESSION:
- case LTTNG_ROTATION_GET_INFO:
- case LTTNG_SESSION_LIST_ROTATION_SCHEDULES:
- break;
- default:
- /* Setup lttng message with no payload */
- ret = setup_lttng_msg_no_cmd_header(cmd_ctx, NULL, 0);
- if (ret < 0) {
- /* This label does not try to unlock the session */
- goto init_setup_error;
- }
- }
-
- /* Commands that DO NOT need a session. */
- switch (cmd_ctx->lsm->cmd_type) {
- case LTTNG_CREATE_SESSION:
- case LTTNG_CREATE_SESSION_SNAPSHOT:
- case LTTNG_CREATE_SESSION_LIVE:
- case LTTNG_LIST_SESSIONS:
- case LTTNG_LIST_TRACEPOINTS:
- case LTTNG_LIST_SYSCALLS:
- case LTTNG_LIST_TRACEPOINT_FIELDS:
- case LTTNG_SAVE_SESSION:
- case LTTNG_REGISTER_TRIGGER:
- case LTTNG_UNREGISTER_TRIGGER:
- need_tracing_session = 0;
- break;
- default:
- DBG("Getting session %s by name", cmd_ctx->lsm->session.name);
- /*
- * We keep the session list lock across _all_ commands
- * for now, because the per-session lock does not
- * handle teardown properly.
- */
- session_lock_list();
- cmd_ctx->session = session_find_by_name(cmd_ctx->lsm->session.name);
- if (cmd_ctx->session == NULL) {
- ret = LTTNG_ERR_SESS_NOT_FOUND;
- goto error;
- } else {
- /* Acquire lock for the session */
- session_lock(cmd_ctx->session);
- }
- break;
- }
-
- /*
- * Commands that need a valid session but should NOT create one if none
- * exists. Instead of creating one and destroying it when the command is
- * handled, process that right before so we save some round trip in useless
- * code path.
- */
- switch (cmd_ctx->lsm->cmd_type) {
- case LTTNG_DISABLE_CHANNEL:
- case LTTNG_DISABLE_EVENT:
- switch (cmd_ctx->lsm->domain.type) {
- case LTTNG_DOMAIN_KERNEL:
- if (!cmd_ctx->session->kernel_session) {
- ret = LTTNG_ERR_NO_CHANNEL;
- goto error;
- }
- break;
- case LTTNG_DOMAIN_JUL:
- case LTTNG_DOMAIN_LOG4J:
- case LTTNG_DOMAIN_PYTHON:
- case LTTNG_DOMAIN_UST:
- if (!cmd_ctx->session->ust_session) {
- ret = LTTNG_ERR_NO_CHANNEL;
- goto error;
- }
- break;
- default:
- ret = LTTNG_ERR_UNKNOWN_DOMAIN;
- goto error;
- }
- default:
- break;
- }
-
- if (!need_domain) {
- goto skip_domain;
- }
-
- /*
- * Check domain type for specific "pre-action".
- */
- switch (cmd_ctx->lsm->domain.type) {
- case LTTNG_DOMAIN_KERNEL:
- if (!is_root) {
- ret = LTTNG_ERR_NEED_ROOT_SESSIOND;
- goto error;
- }
-
- /* Kernel tracer check */
- if (kernel_tracer_fd == -1) {
- /* Basically, load kernel tracer modules */
- ret = init_kernel_tracer();
- if (ret != 0) {
- goto error;
- }
- }
-
- /* Consumer is in an ERROR state. Report back to client */
- if (uatomic_read(&kernel_consumerd_state) == CONSUMER_ERROR) {
- ret = LTTNG_ERR_NO_KERNCONSUMERD;
- goto error;
- }
-
- /* Need a session for kernel command */
- if (need_tracing_session) {
- if (cmd_ctx->session->kernel_session == NULL) {
- ret = create_kernel_session(cmd_ctx->session);
- if (ret < 0) {
- ret = LTTNG_ERR_KERN_SESS_FAIL;
- goto error;
- }
- }
-
- /* Start the kernel consumer daemon */
- pthread_mutex_lock(&kconsumer_data.pid_mutex);
- if (kconsumer_data.pid == 0 &&
- cmd_ctx->lsm->cmd_type != LTTNG_REGISTER_CONSUMER) {
- pthread_mutex_unlock(&kconsumer_data.pid_mutex);
- ret = start_consumerd(&kconsumer_data);
- if (ret < 0) {
- ret = LTTNG_ERR_KERN_CONSUMER_FAIL;
- goto error;
- }
- uatomic_set(&kernel_consumerd_state, CONSUMER_STARTED);
- } else {
- pthread_mutex_unlock(&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,
- cmd_ctx->session->kernel_session->consumer);
- if (ret < 0) {
- goto error;
- }
- }
-
- break;
- case LTTNG_DOMAIN_JUL:
- case LTTNG_DOMAIN_LOG4J:
- case LTTNG_DOMAIN_PYTHON:
- 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) {
- ret = LTTNG_ERR_NO_USTCONSUMERD;
- goto error;
- }
-
- if (need_tracing_session) {
- /* Create UST session if none exist. */
- if (cmd_ctx->session->ust_session == NULL) {
- ret = create_ust_session(cmd_ctx->session,
- &cmd_ctx->lsm->domain);
- if (ret != LTTNG_OK) {
- goto error;
- }
- }
-
- /* Start the UST consumer daemons */
- /* 64-bit */
- pthread_mutex_lock(&ustconsumer64_data.pid_mutex);
- if (config.consumerd64_bin_path.value &&
- ustconsumer64_data.pid == 0 &&
- cmd_ctx->lsm->cmd_type != LTTNG_REGISTER_CONSUMER) {
- pthread_mutex_unlock(&ustconsumer64_data.pid_mutex);
- ret = start_consumerd(&ustconsumer64_data);
- if (ret < 0) {
- ret = LTTNG_ERR_UST_CONSUMER64_FAIL;
- uatomic_set(&ust_consumerd64_fd, -EINVAL);
- goto error;
- }
-
- uatomic_set(&ust_consumerd64_fd, ustconsumer64_data.cmd_sock);
- uatomic_set(&ust_consumerd_state, CONSUMER_STARTED);
- } else {
- pthread_mutex_unlock(&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,
- 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 &&
- cmd_ctx->lsm->cmd_type != LTTNG_REGISTER_CONSUMER) {
- pthread_mutex_unlock(&ustconsumer32_data.pid_mutex);
- ret = start_consumerd(&ustconsumer32_data);
- if (ret < 0) {
- ret = LTTNG_ERR_UST_CONSUMER32_FAIL;
- uatomic_set(&ust_consumerd32_fd, -EINVAL);
- goto error;
- }
-
- uatomic_set(&ust_consumerd32_fd, ustconsumer32_data.cmd_sock);
- uatomic_set(&ust_consumerd_state, CONSUMER_STARTED);
- } else {
- pthread_mutex_unlock(&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,
- cmd_ctx->session->ust_session->consumer);
- if (ret < 0) {
- goto error;
- }
- }
- break;
- }
- default:
- break;
- }
-skip_domain:
-
- /* Validate consumer daemon state when start/stop trace command */
- if (cmd_ctx->lsm->cmd_type == LTTNG_START_TRACE ||
- cmd_ctx->lsm->cmd_type == LTTNG_STOP_TRACE) {
- switch (cmd_ctx->lsm->domain.type) {
- case LTTNG_DOMAIN_NONE:
- break;
- case LTTNG_DOMAIN_JUL:
- case LTTNG_DOMAIN_LOG4J:
- case LTTNG_DOMAIN_PYTHON:
- case LTTNG_DOMAIN_UST:
- if (uatomic_read(&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) {
- ret = LTTNG_ERR_NO_KERNCONSUMERD;
- goto error;
- }
- break;
- default:
- ret = LTTNG_ERR_UNKNOWN_DOMAIN;
- goto error;
- }
- }
-
- /*
- * Check that the UID or GID match 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)) ||
- cmd_ctx->session->destroyed) {
- ret = LTTNG_ERR_EPERM;
- goto error;
- }
- }
-
- /*
- * Send relayd information to consumer as soon as we have a domain and a
- * session defined.
- */
- if (cmd_ctx->session && need_domain) {
- /*
- * Setup relayd if not done yet. If the relayd information was already
- * sent to the consumer, this call will gracefully return.
- */
- ret = cmd_setup_relayd(cmd_ctx->session);
- if (ret != LTTNG_OK) {
- goto error;
- }
- }
-
- /* Process by command type */
- 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;
- }
-
- 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,
- &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) {
- goto error;
- }
- break;
- }
- case LTTNG_DISABLE_CHANNEL:
- {
- ret = cmd_disable_channel(cmd_ctx->session, cmd_ctx->lsm->domain.type,
- 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;
- }
- }
- /* FIXME: passing packed structure to non-packed pointer */
- ret = cmd_disable_event(cmd_ctx->session, cmd_ctx->lsm->domain.type,
- cmd_ctx->lsm->u.disable.channel_name,
- &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, &cmd_ctx->lsm->domain,
- &cmd_ctx->lsm->u.channel.chan,
- kernel_poll_pipe[1]);
- break;
- }
- case LTTNG_TRACK_PID:
- {
- ret = cmd_track_pid(cmd_ctx->session,
- cmd_ctx->lsm->domain.type,
- cmd_ctx->lsm->u.pid_tracker.pid);
- break;
- }
- case LTTNG_UNTRACK_PID:
- {
- ret = cmd_untrack_pid(cmd_ctx->session,
- cmd_ctx->lsm->domain.type,
- cmd_ctx->lsm->u.pid_tracker.pid);
- break;
- }
- case LTTNG_ENABLE_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;
-
- 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(&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;
- 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, &cmd_ctx->lsm->domain,
- cmd_ctx->lsm->u.enable.channel_name,
- ev,
- filter_expression, bytecode, exclusion,
- kernel_poll_pipe[1]);
- lttng_event_destroy(ev);
- break;
- }
- case LTTNG_LIST_TRACEPOINTS:
- {
- struct lttng_event *events;
- ssize_t nb_events;
-
- session_lock_list();
- nb_events = cmd_list_tracepoints(cmd_ctx->lsm->domain.type, &events);
- session_unlock_list();
- if (nb_events < 0) {
- /* Return value is a negative lttng_error_code. */
- ret = -nb_events;
- 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;
- }
-
- ret = LTTNG_OK;
- break;
- }
- case LTTNG_LIST_TRACEPOINT_FIELDS:
- {
- struct lttng_event_field *fields;
- ssize_t nb_fields;
-
- session_lock_list();
- nb_fields = cmd_list_tracepoint_fields(cmd_ctx->lsm->domain.type,
- &fields);
- session_unlock_list();
- if (nb_fields < 0) {
- /* Return value is a negative lttng_error_code. */
- ret = -nb_fields;
- 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;
- }
-
- ret = LTTNG_OK;
- break;
- }
- case LTTNG_LIST_SYSCALLS:
- {
- struct lttng_event *events;
- ssize_t nb_events;
-
- nb_events = cmd_list_syscalls(&events);
- if (nb_events < 0) {
- /* Return value is a negative lttng_error_code. */
- ret = -nb_events;
- 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;
- }
-
- ret = LTTNG_OK;
- break;
- }
- case LTTNG_LIST_TRACKER_PIDS:
- {
- int32_t *pids = NULL;
- ssize_t nr_pids;
-
- nr_pids = cmd_list_tracker_pids(cmd_ctx->session,
- cmd_ctx->lsm->domain.type, &pids);
- if (nr_pids < 0) {
- /* Return value is a negative lttng_error_code. */
- ret = -nr_pids;
- 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, pids,
- sizeof(int32_t) * nr_pids);
- free(pids);
-
- if (ret < 0) {
- goto setup_error;
- }
-
- ret = LTTNG_OK;
- break;
- }
- case LTTNG_SET_CONSUMER_URI:
- {
- size_t nb_uri, len;
- struct lttng_uri *uris;
-
- nb_uri = cmd_ctx->lsm->u.uri.size;
- len = nb_uri * sizeof(struct lttng_uri);
-
- if (nb_uri == 0) {
- ret = LTTNG_ERR_INVALID;
- goto error;
- }
-
- uris = zmalloc(len);
- if (uris == NULL) {
- ret = LTTNG_ERR_FATAL;
- goto error;
- }
-
- /* Receive variable len data */
- DBG("Receiving %zu URI(s) from client ...", nb_uri);
- ret = lttcomm_recv_unix_sock(sock, uris, len);
- if (ret <= 0) {
- DBG("No URIs received from client... continuing");
- *sock_error = 1;
- ret = LTTNG_ERR_SESSION_FAIL;
- free(uris);
- goto error;
- }
-
- ret = cmd_set_consumer_uri(cmd_ctx->session, nb_uri, uris);
- free(uris);
- if (ret != LTTNG_OK) {
- goto error;
- }
-
-
- break;
- }
- case LTTNG_START_TRACE:
- {
- /*
- * On the first start, if we have a kernel session and we have
- * enabled time or size-based rotations, we have to make sure
- * the kernel tracer supports it.
- */
- if (!cmd_ctx->session->has_been_started && \
- cmd_ctx->session->kernel_session && \
- (cmd_ctx->session->rotate_timer_period || \
- cmd_ctx->session->rotate_size) && \
- !check_rotate_compatible()) {
- DBG("Kernel tracer version is not compatible with the rotation feature");
- ret = LTTNG_ERR_ROTATION_WRONG_VERSION;
- goto error;
- }
- ret = cmd_start_trace(cmd_ctx->session);
- break;
- }
- case LTTNG_STOP_TRACE:
- {
- ret = cmd_stop_trace(cmd_ctx->session);
- break;
- }
- case LTTNG_CREATE_SESSION:
- {
- size_t nb_uri, len;
- struct lttng_uri *uris = NULL;
-
- nb_uri = cmd_ctx->lsm->u.uri.size;
- len = nb_uri * sizeof(struct lttng_uri);
-
- if (nb_uri > 0) {
- uris = zmalloc(len);
- if (uris == NULL) {
- ret = LTTNG_ERR_FATAL;
- goto error;
- }
-
- /* Receive variable len data */
- DBG("Waiting for %zu URIs from client ...", nb_uri);
- ret = lttcomm_recv_unix_sock(sock, uris, len);
- if (ret <= 0) {
- DBG("No URIs received from client... continuing");
- *sock_error = 1;
- ret = LTTNG_ERR_SESSION_FAIL;
- free(uris);
- goto error;
- }
-
- if (nb_uri == 1 && uris[0].dtype != LTTNG_DST_PATH) {
- DBG("Creating session with ONE network URI is a bad call");
- ret = LTTNG_ERR_SESSION_FAIL;
- free(uris);
- goto error;
- }
- }
-
- ret = cmd_create_session_uri(cmd_ctx->lsm->session.name, uris, nb_uri,
- &cmd_ctx->creds, 0);
-
- free(uris);
-
- break;
- }
- case LTTNG_DESTROY_SESSION:
- {
- ret = cmd_destroy_session(cmd_ctx->session,
- notification_thread_handle);
- break;
- }
- case LTTNG_LIST_DOMAINS:
- {
- ssize_t nb_dom;
- struct lttng_domain *domains = NULL;
-
- nb_dom = cmd_list_domains(cmd_ctx->session, &domains);
- if (nb_dom < 0) {
- /* Return value is a negative lttng_error_code. */
- ret = -nb_dom;
- goto error;
- }
-
- ret = setup_lttng_msg_no_cmd_header(cmd_ctx, domains,
- nb_dom * sizeof(struct lttng_domain));
- free(domains);
-
- if (ret < 0) {
- goto setup_error;
- }
-
- ret = LTTNG_OK;
- break;
- }
- case LTTNG_LIST_CHANNELS:
- {
- ssize_t payload_size;
- struct lttng_channel *channels = NULL;
-
- 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_lttng_msg_no_cmd_header(cmd_ctx, channels,
- payload_size);
- free(channels);
-
- if (ret < 0) {
- goto setup_error;
- }
-
- ret = LTTNG_OK;
- break;
- }
- case LTTNG_LIST_EVENTS:
- {
- ssize_t nb_event;
- struct lttng_event *events = NULL;
- struct lttcomm_event_command_header cmd_header;
- size_t total_size;
-
- memset(&cmd_header, 0, sizeof(cmd_header));
- /* Extended infos are included at the end of events */
- nb_event = cmd_list_events(cmd_ctx->lsm->domain.type,
- cmd_ctx->session, cmd_ctx->lsm->u.list.channel_name,
- &events, &total_size);
-
- if (nb_event < 0) {
- /* Return value is a negative lttng_error_code. */
- ret = -nb_event;
- goto error;
- }
-
- cmd_header.nb_events = nb_event;
- ret = setup_lttng_msg(cmd_ctx, events, total_size,
- &cmd_header, sizeof(cmd_header));
- free(events);
-
- if (ret < 0) {
- goto setup_error;
- }
-
- ret = LTTNG_OK;
- break;
- }
- case LTTNG_LIST_SESSIONS:
- {
- unsigned int nr_sessions;
- void *sessions_payload;
- size_t payload_len;
-
- session_lock_list();
- nr_sessions = lttng_sessions_count(
- LTTNG_SOCK_GET_UID_CRED(&cmd_ctx->creds),
- LTTNG_SOCK_GET_GID_CRED(&cmd_ctx->creds));
- payload_len = sizeof(struct lttng_session) * nr_sessions;
- sessions_payload = zmalloc(payload_len);
-
- if (!sessions_payload) {
- session_unlock_list();
- ret = -ENOMEM;
- goto setup_error;
- }
-
- cmd_list_lttng_sessions(sessions_payload,
- LTTNG_SOCK_GET_UID_CRED(&cmd_ctx->creds),
- LTTNG_SOCK_GET_GID_CRED(&cmd_ctx->creds));
- session_unlock_list();
-
- ret = setup_lttng_msg_no_cmd_header(cmd_ctx, sessions_payload,
- payload_len);
- free(sessions_payload);
-
- if (ret < 0) {
- goto setup_error;
- }
-
- ret = LTTNG_OK;
- break;
- }
- case LTTNG_REGISTER_CONSUMER:
- {
- struct consumer_data *cdata;
-
- switch (cmd_ctx->lsm->domain.type) {
- case LTTNG_DOMAIN_KERNEL:
- cdata = &kconsumer_data;
- break;
- default:
- ret = LTTNG_ERR_UND;
- goto error;
- }
-
- ret = cmd_register_consumer(cmd_ctx->session, cmd_ctx->lsm->domain.type,
- cmd_ctx->lsm->u.reg.path, cdata);
- break;
- }
- case LTTNG_DATA_PENDING:
- {
- int pending_ret;
- uint8_t pending_ret_byte;
-
- pending_ret = cmd_data_pending(cmd_ctx->session);
-
- /*
- * FIXME
- *
- * This function may returns 0 or 1 to indicate whether or not
- * there is data pending. In case of error, it should return an
- * LTTNG_ERR code. However, some code paths may still return
- * a nondescript error code, which we handle by returning an
- * "unknown" error.
- */
- if (pending_ret == 0 || pending_ret == 1) {
- /*
- * ret will be set to LTTNG_OK at the end of
- * this function.
- */
- } else if (pending_ret < 0) {
- ret = LTTNG_ERR_UNK;
- goto setup_error;
- } else {
- ret = pending_ret;
- goto setup_error;
- }
-
- pending_ret_byte = (uint8_t) pending_ret;
-
- /* 1 byte to return whether or not data is pending */
- ret = setup_lttng_msg_no_cmd_header(cmd_ctx,
- &pending_ret_byte, 1);
-
- if (ret < 0) {
- goto setup_error;
- }
-
- ret = LTTNG_OK;
- break;
- }
- case LTTNG_SNAPSHOT_ADD_OUTPUT:
- {
- struct lttcomm_lttng_output_id reply;
-
- ret = cmd_snapshot_add_output(cmd_ctx->session,
- &cmd_ctx->lsm->u.snapshot_output.output, &reply.id);
- if (ret != LTTNG_OK) {
- goto error;
- }
-
- ret = setup_lttng_msg_no_cmd_header(cmd_ctx, &reply,
- sizeof(reply));
- if (ret < 0) {
- goto setup_error;
- }
-
- /* Copy output list into message payload */
- ret = LTTNG_OK;
- break;
- }
- case LTTNG_SNAPSHOT_DEL_OUTPUT:
- {
- ret = cmd_snapshot_del_output(cmd_ctx->session,
- &cmd_ctx->lsm->u.snapshot_output.output);
- break;
- }
- case LTTNG_SNAPSHOT_LIST_OUTPUT:
- {
- ssize_t nb_output;
- struct lttng_snapshot_output *outputs = NULL;
-
- nb_output = cmd_snapshot_list_outputs(cmd_ctx->session, &outputs);
- if (nb_output < 0) {
- ret = -nb_output;
- goto error;
- }
-
- assert((nb_output > 0 && outputs) || nb_output == 0);
- ret = setup_lttng_msg_no_cmd_header(cmd_ctx, outputs,
- nb_output * sizeof(struct lttng_snapshot_output));
- free(outputs);
-
- if (ret < 0) {
- goto setup_error;
- }
-
- ret = LTTNG_OK;
- break;
- }
- case LTTNG_SNAPSHOT_RECORD:
- {
- ret = cmd_snapshot_record(cmd_ctx->session,
- &cmd_ctx->lsm->u.snapshot_record.output,
- cmd_ctx->lsm->u.snapshot_record.wait);
- break;
- }
- case LTTNG_CREATE_SESSION_SNAPSHOT:
- {
- size_t nb_uri, len;
- struct lttng_uri *uris = NULL;
-
- nb_uri = cmd_ctx->lsm->u.uri.size;
- len = nb_uri * sizeof(struct lttng_uri);
-
- if (nb_uri > 0) {
- uris = zmalloc(len);
- if (uris == NULL) {
- ret = LTTNG_ERR_FATAL;
- goto error;
- }
-
- /* Receive variable len data */
- DBG("Waiting for %zu URIs from client ...", nb_uri);
- ret = lttcomm_recv_unix_sock(sock, uris, len);
- if (ret <= 0) {
- DBG("No URIs received from client... continuing");
- *sock_error = 1;
- ret = LTTNG_ERR_SESSION_FAIL;
- free(uris);
- goto error;
- }
-
- if (nb_uri == 1 && uris[0].dtype != LTTNG_DST_PATH) {
- DBG("Creating session with ONE network URI is a bad call");
- ret = LTTNG_ERR_SESSION_FAIL;
- free(uris);
- goto error;
- }
- }
-
- ret = cmd_create_session_snapshot(cmd_ctx->lsm->session.name, uris,
- nb_uri, &cmd_ctx->creds);
- free(uris);
- break;
- }
- case LTTNG_CREATE_SESSION_LIVE:
- {
- size_t nb_uri, len;
- struct lttng_uri *uris = NULL;
-
- nb_uri = cmd_ctx->lsm->u.uri.size;
- len = nb_uri * sizeof(struct lttng_uri);
-
- if (nb_uri > 0) {
- uris = zmalloc(len);
- if (uris == NULL) {
- ret = LTTNG_ERR_FATAL;
- goto error;
- }
-
- /* Receive variable len data */
- DBG("Waiting for %zu URIs from client ...", nb_uri);
- ret = lttcomm_recv_unix_sock(sock, uris, len);
- if (ret <= 0) {
- DBG("No URIs received from client... continuing");
- *sock_error = 1;
- ret = LTTNG_ERR_SESSION_FAIL;
- free(uris);
- goto error;
- }
-
- if (nb_uri == 1 && uris[0].dtype != LTTNG_DST_PATH) {
- DBG("Creating session with ONE network URI is a bad call");
- ret = LTTNG_ERR_SESSION_FAIL;
- free(uris);
- goto error;
- }
- }
-
- ret = cmd_create_session_uri(cmd_ctx->lsm->session.name, uris,
- nb_uri, &cmd_ctx->creds, cmd_ctx->lsm->u.session_live.timer_interval);
- free(uris);
- break;
- }
- case LTTNG_SAVE_SESSION:
- {
- ret = cmd_save_sessions(&cmd_ctx->lsm->u.save_session.attr,
- &cmd_ctx->creds);
- break;
- }
- case LTTNG_SET_SESSION_SHM_PATH:
- {
- ret = cmd_set_session_shm_path(cmd_ctx->session,
- cmd_ctx->lsm->u.set_shm_path.shm_path);
- break;
- }
- case LTTNG_REGENERATE_METADATA:
- {
- ret = cmd_regenerate_metadata(cmd_ctx->session);
- break;
- }
- case LTTNG_REGENERATE_STATEDUMP:
- {
- ret = cmd_regenerate_statedump(cmd_ctx->session);
- break;
- }
- case LTTNG_REGISTER_TRIGGER:
- {
- ret = cmd_register_trigger(cmd_ctx, sock,
- notification_thread_handle);
- break;
- }
- case LTTNG_UNREGISTER_TRIGGER:
- {
- ret = cmd_unregister_trigger(cmd_ctx, sock,
- notification_thread_handle);
- break;
- }
- case LTTNG_ROTATE_SESSION:
- {
- struct lttng_rotate_session_return rotate_return;
-
- DBG("Client rotate session \"%s\"", cmd_ctx->session->name);
-
- memset(&rotate_return, 0, sizeof(rotate_return));
- if (cmd_ctx->session->kernel_session && !check_rotate_compatible()) {
- DBG("Kernel tracer version is not compatible with the rotation feature");
- ret = LTTNG_ERR_ROTATION_WRONG_VERSION;
- goto error;
- }
-
- ret = cmd_rotate_session(cmd_ctx->session, &rotate_return);
- if (ret < 0) {
- ret = -ret;
- goto error;
- }
-
- ret = setup_lttng_msg_no_cmd_header(cmd_ctx, &rotate_return,
- sizeof(rotate_return));
- if (ret < 0) {
- ret = -ret;
- goto error;
- }
-
- ret = LTTNG_OK;
- break;
- }
- case LTTNG_ROTATION_GET_INFO:
- {
- struct lttng_rotation_get_info_return get_info_return;
-
- memset(&get_info_return, 0, sizeof(get_info_return));
- ret = cmd_rotate_get_info(cmd_ctx->session, &get_info_return,
- cmd_ctx->lsm->u.get_rotation_info.rotation_id);
- if (ret < 0) {
- ret = -ret;
- goto error;
- }
-
- ret = setup_lttng_msg_no_cmd_header(cmd_ctx, &get_info_return,
- sizeof(get_info_return));
- if (ret < 0) {
- ret = -ret;
- goto error;
- }
-
- ret = LTTNG_OK;
- break;
- }
- case LTTNG_ROTATION_SET_SCHEDULE:
- {
- bool set_schedule;
- enum lttng_rotation_schedule_type schedule_type;
- uint64_t value;
-
- if (cmd_ctx->session->kernel_session && !check_rotate_compatible()) {
- DBG("Kernel tracer version does not support session rotations");
- ret = LTTNG_ERR_ROTATION_WRONG_VERSION;
- goto error;
- }
-
- set_schedule = cmd_ctx->lsm->u.rotation_set_schedule.set == 1;
- schedule_type = (enum lttng_rotation_schedule_type) cmd_ctx->lsm->u.rotation_set_schedule.type;
- 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);
- if (ret != LTTNG_OK) {
- goto error;
- }
-
- break;
- }
- case LTTNG_SESSION_LIST_ROTATION_SCHEDULES:
- {
- struct lttng_session_list_schedules_return schedules = {
- .periodic.set = !!cmd_ctx->session->rotate_timer_period,
- .periodic.value = cmd_ctx->session->rotate_timer_period,
- .size.set = !!cmd_ctx->session->rotate_size,
- .size.value = cmd_ctx->session->rotate_size,
- };
-
- ret = setup_lttng_msg_no_cmd_header(cmd_ctx, &schedules,
- sizeof(schedules));
- if (ret < 0) {
- ret = -ret;
- goto error;
- }
-
- ret = LTTNG_OK;
- break;
- }
- default:
- ret = LTTNG_ERR_UND;
- break;
- }
-
-error:
- if (cmd_ctx->llm == NULL) {
- DBG("Missing llm structure. Allocating one.");
- if (setup_lttng_msg_no_cmd_header(cmd_ctx, NULL, 0) < 0) {
- goto setup_error;
- }
- }
- /* Set return code */
- cmd_ctx->llm->ret_code = ret;
-setup_error:
- if (cmd_ctx->session) {
- session_unlock(cmd_ctx->session);
- session_put(cmd_ctx->session);
- }
- if (need_tracing_session) {
- session_unlock_list();
- }
-init_setup_error:
- assert(!rcu_read_ongoing());
- return ret;
-}
-
-/*
- * This thread manage all clients request using the unix client socket for
- * communication.
- */
-static void *thread_manage_clients(void *data)
-{
- int sock = -1, ret, i, pollfd, err = -1;
- int sock_error;
- uint32_t revents, nb_fd;
- struct command_ctx *cmd_ctx = NULL;
- struct lttng_poll_event events;
-
- DBG("[thread] Manage client started");
-
- rcu_register_thread();
-
- health_register(health_sessiond, HEALTH_SESSIOND_TYPE_CMD);
-
- health_code_update();
-
- ret = lttcomm_listen_unix_sock(client_sock);
- if (ret < 0) {
- goto error_listen;
- }
-
- /*
- * Pass 2 as size here for the thread quit pipe and client_sock. Nothing
- * more will be added to this poll set.
- */
- ret = sessiond_set_thread_pollset(&events, 2);
- if (ret < 0) {
- goto error_create_poll;
- }
-
- /* Add the application registration socket */
- ret = lttng_poll_add(&events, client_sock, LPOLLIN | LPOLLPRI);
- if (ret < 0) {
- goto error;
- }
-
- ret = sem_post(&load_info->message_thread_ready);
- if (ret) {
- PERROR("sem_post message_thread_ready");
- goto error;
- }
-
- /*
- * Wait until all support threads are initialized before accepting
- * commands.
- */
- while (uatomic_read(<tng_sessiond_ready) != 0) {
- /*
- * If a support thread failed to launch, it may signal that
- * we must exit and the sessiond would never be marked as
- * "ready".
- *
- * The timeout is set to 1ms, which serves as a way to
- * pace down this check.
- */
- ret = sessiond_wait_for_quit_pipe(1000);
- if (ret > 0) {
- goto exit;
- }
- }
- /*
- * This barrier is paired with the one in sessiond_notify_ready() to
- * ensure that loads accessing data initialized by the other threads,
- * on which this thread was waiting, are not performed before this point.
- *
- * Note that this could be a 'read' memory barrier, but a full barrier
- * is used in case the code changes. The performance implications of
- * this choice are minimal since this is a slow path.
- */
- cmm_smp_mb();
-
- /* This testpoint is after we signal readiness to the parent. */
- if (testpoint(sessiond_thread_manage_clients)) {
- goto error;
- }
-
- if (testpoint(sessiond_thread_manage_clients_before_loop)) {
- goto error;
- }
-
- health_code_update();
-
- /* Set state as running. */
- sessiond_set_client_thread_state(true);
-
- while (1) {
- const struct cmd_completion_handler *cmd_completion_handler;
-
- DBG("Accepting client command ...");
-
- /* Inifinite blocking call, waiting for transmission */
- restart:
- health_poll_entry();
- ret = lttng_poll_wait(&events, -1);
- health_poll_exit();
- if (ret < 0) {
- /*
- * Restart interrupted system call.
- */
- if (errno == EINTR) {
- goto restart;
- }
- goto error;
- }
-
- nb_fd = ret;
-
- for (i = 0; i < nb_fd; i++) {
- /* Fetch once the poll data */
- revents = LTTNG_POLL_GETEV(&events, i);
- pollfd = LTTNG_POLL_GETFD(&events, i);
-
- health_code_update();
-
- if (!revents) {
- /* No activity for this FD (poll implementation). */
- continue;
- }
-
- /* Thread quit pipe has been closed. Killing thread. */
- ret = sessiond_check_thread_quit_pipe(pollfd, revents);
- if (ret) {
- err = 0;
- goto exit;
- }
-
- /* Event on the registration socket */
- if (pollfd == client_sock) {
- if (revents & LPOLLIN) {
- continue;
- } else if (revents & (LPOLLERR | LPOLLHUP | LPOLLRDHUP)) {
- ERR("Client socket poll error");
- goto error;
- } else {
- ERR("Unexpected poll events %u for sock %d", revents, pollfd);
- goto error;
- }
- }
- }
-
- DBG("Wait for client response");
-
- health_code_update();
-
- sock = lttcomm_accept_unix_sock(client_sock);
- if (sock < 0) {
- goto error;
- }
-
- /*
- * Set the CLOEXEC flag. Return code is useless because either way, the
- * show must go on.
- */
- (void) utils_set_fd_cloexec(sock);
-
- /* Set socket option for credentials retrieval */
- ret = lttcomm_setsockopt_creds_unix_sock(sock);
- if (ret < 0) {
- goto error;
- }
-
- /* Allocate context command to process the client request */
- cmd_ctx = zmalloc(sizeof(struct command_ctx));
- if (cmd_ctx == NULL) {
- PERROR("zmalloc cmd_ctx");
- goto error;
- }
-
- /* Allocate data buffer for reception */
- cmd_ctx->lsm = zmalloc(sizeof(struct lttcomm_session_msg));
- if (cmd_ctx->lsm == NULL) {
- PERROR("zmalloc cmd_ctx->lsm");
- goto error;
- }
-
- cmd_ctx->llm = NULL;
- cmd_ctx->session = NULL;
-
- health_code_update();
-
- /*
- * Data is received from the lttng client. The struct
- * lttcomm_session_msg (lsm) contains the command and data request of
- * the client.
- */
- DBG("Receiving data from client ...");
- ret = lttcomm_recv_creds_unix_sock(sock, cmd_ctx->lsm,
- sizeof(struct lttcomm_session_msg), &cmd_ctx->creds);
- if (ret <= 0) {
- DBG("Nothing recv() from client... continuing");
- ret = close(sock);
- if (ret) {
- PERROR("close");
- }
- sock = -1;
- clean_command_ctx(&cmd_ctx);
- continue;
- }
-
- health_code_update();
-
- // TODO: Validate cmd_ctx including sanity check for
- // security purpose.
-
- rcu_thread_online();
- /*
- * This function dispatch the work to the kernel or userspace tracer
- * libs and fill the lttcomm_lttng_msg data structure of all the needed
- * informations for the client. The command context struct contains
- * everything this function may needs.
- */
- ret = process_client_msg(cmd_ctx, sock, &sock_error);
- rcu_thread_offline();
- if (ret < 0) {
- ret = close(sock);
- if (ret) {
- PERROR("close");
- }
- sock = -1;
- /*
- * TODO: Inform client somehow of the fatal error. At
- * this point, ret < 0 means that a zmalloc failed
- * (ENOMEM). Error detected but still accept
- * command, unless a socket error has been
- * detected.
- */
- clean_command_ctx(&cmd_ctx);
- continue;
- }
-
- cmd_completion_handler = cmd_pop_completion_handler();
- if (cmd_completion_handler) {
- enum lttng_error_code completion_code;
-
- completion_code = cmd_completion_handler->run(
- cmd_completion_handler->data);
- if (completion_code != LTTNG_OK) {
- clean_command_ctx(&cmd_ctx);
- continue;
- }
- }
-
- health_code_update();
-
- DBG("Sending response (size: %d, retcode: %s (%d))",
- cmd_ctx->lttng_msg_size,
- lttng_strerror(-cmd_ctx->llm->ret_code),
- cmd_ctx->llm->ret_code);
- ret = send_unix_sock(sock, cmd_ctx->llm, cmd_ctx->lttng_msg_size);
- if (ret < 0) {
- ERR("Failed to send data back to client");
- }
-
- /* End of transmission */
- ret = close(sock);
- if (ret) {
- PERROR("close");
- }
- sock = -1;
-
- clean_command_ctx(&cmd_ctx);
-
- health_code_update();
- }
-
-exit:
-error:
- if (sock >= 0) {
- ret = close(sock);
- if (ret) {
- PERROR("close");
- }
- }
-
- lttng_poll_clean(&events);
- clean_command_ctx(&cmd_ctx);
-
-error_listen:
-error_create_poll:
- unlink(config.client_unix_sock_path.value);
- if (client_sock >= 0) {
- ret = close(client_sock);
- if (ret) {
- PERROR("close");
- }
- }
-
- if (err) {
- health_error();
- ERR("Health error occurred in %s", __func__);
- }
-
- health_unregister(health_sessiond);
-
- DBG("Client thread dying");
-
- rcu_unregister_thread();
-
- /*
- * Since we are creating the consumer threads, we own them, so we need
- * to join them before our thread exits.
- */
- ret = join_consumer_thread(&kconsumer_data);
- if (ret) {
- errno = ret;
- PERROR("join_consumer");
- }
-
- ret = join_consumer_thread(&ustconsumer32_data);
- if (ret) {
- errno = ret;
- PERROR("join_consumer ust32");
- }
-
- ret = join_consumer_thread(&ustconsumer64_data);
- if (ret) {
- errno = ret;
- PERROR("join_consumer ust64");
- }
-
- /* Set state as non-running. */
- sessiond_set_client_thread_state(false);
- return NULL;
-}
-
-static int string_match(const char *str1, const char *str2)
-{
- return (str1 && str2) && !strcmp(str1, str2);
-}
-
-/*
- * Take an option from the getopt output and set it in the right variable to be
- * used later.
- *
- * Return 0 on success else a negative value.
- */
-static int set_option(int opt, const char *arg, const char *optname)
-{
- int ret = 0;
+ int ret = 0;
if (string_match(optname, "client-sock") || opt == 'c') {
if (!arg || *arg == '\0') {
}
/*
- * Creates the two needed socket by the daemon.
- * apps_sock - The communication socket for all UST apps.
- * client_sock - The communication of the cli tool (lttng).
+ * Creates the application socket.
*/
static int init_daemon_socket(void)
{
old_umask = umask(0);
- /* Create client tool unix socket */
- client_sock = lttcomm_create_unix_sock(config.client_unix_sock_path.value);
- if (client_sock < 0) {
- ERR("Create unix sock failed: %s", config.client_unix_sock_path.value);
- ret = -1;
- goto end;
- }
-
- /* Set the cloexec flag */
- ret = utils_set_fd_cloexec(client_sock);
- if (ret < 0) {
- ERR("Unable to set CLOEXEC flag to the client Unix socket (fd: %d). "
- "Continuing but note that the consumer daemon will have a "
- "reference to this socket on exec()", client_sock);
- }
-
- /* File permission MUST be 660 */
- ret = chmod(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);
- PERROR("chmod");
- goto end;
- }
-
/* Create the application unix socket */
apps_sock = lttcomm_create_unix_sock(config.apps_unix_sock_path.value);
if (apps_sock < 0) {
goto end;
}
- DBG3("Session daemon client socket %d and application socket %d created",
- client_sock, apps_sock);
+ DBG3("Session daemon application socket %d created",
+ apps_sock);
end:
umask(old_umask);
return;
}
- /*
- * Ensure that the client thread is no longer accepting new commands,
- * which could cause new sessions to be created.
- */
- sessiond_wait_client_thread_stopped();
-
session_lock_list();
/* Initiate the destruction of all sessions. */
cds_list_for_each_entry_safe(session, tmp,
struct rotation_thread_handle *rotation_thread_handle = NULL;
/* Queue of rotation jobs populated by the sessiond-timer. */
struct rotation_thread_timer_queue *rotation_timer_queue = NULL;
+ struct lttng_thread *client_thread = NULL;
init_kernel_workarounds();
}
/* Create thread to manage the client socket */
- ret = pthread_create(&client_thread, default_pthread_attr(),
- thread_manage_clients, (void *) NULL);
- if (ret) {
- errno = ret;
- PERROR("pthread_create clients");
+ client_thread = launch_client_thread();
+ if (!client_thread) {
retval = -1;
- stop_threads();
goto exit_client;
}
/* Initiate teardown once activity occurs on the quit pipe. */
sessiond_wait_for_quit_pipe(-1U);
+
+ /*
+ * Ensure that the client thread is no longer accepting new commands,
+ * which could cause new sessions to be created.
+ */
+ if (!lttng_thread_shutdown(client_thread)) {
+ ERR("Failed to shutdown the client thread, continuing teardown");
+ lttng_thread_put(client_thread);
+ client_thread = NULL;
+ }
+
destroy_all_sessions_and_wait();
exit_load_session:
retval = -1;
}
exit_dispatch:
-
- ret = pthread_join(client_thread, &status);
- if (ret) {
- errno = ret;
- PERROR("pthread_join");
- retval = -1;
- }
-
exit_client:
exit_rotation:
exit_notification:
lttng_thread_list_shutdown_orphans();
exit_health:
exit_init_data:
+ if (client_thread) {
+ lttng_thread_put(client_thread);
+ }
+
/*
* Wait for all pending call_rcu work to complete before tearing
* down data structures. call_rcu worker may be trying to
*/
static int thread_quit_pipe[2] = { -1, -1 };
-/*
- * Allows threads to query the state of the client thread.
- */
-static struct client_thread_state {
- pthread_cond_t cond;
- pthread_mutex_t lock;
- bool is_running;
-} client_thread_state = {
- .cond = PTHREAD_COND_INITIALIZER,
- .lock = PTHREAD_MUTEX_INITIALIZER,
- .is_running = false
-};
-
/*
* Init thread quit pipe.
*
utils_close_pipe(thread_quit_pipe);
}
-void sessiond_set_client_thread_state(bool running)
-{
- pthread_mutex_lock(&client_thread_state.lock);
- client_thread_state.is_running = running;
- pthread_cond_broadcast(&client_thread_state.cond);
- pthread_mutex_unlock(&client_thread_state.lock);
-}
-
-void sessiond_wait_client_thread_stopped(void)
-{
- pthread_mutex_lock(&client_thread_state.lock);
- while (client_thread_state.is_running) {
- pthread_cond_wait(&client_thread_state.cond,
- &client_thread_state.lock);
- }
- pthread_mutex_unlock(&client_thread_state.lock);
-}
-
static
int __sessiond_set_thread_pollset(struct lttng_poll_event *events, size_t size,
int *a_pipe)
projects / lttng-tools.git / commitdiff
