#include <common/utils.h>
#include <common/daemonize.h>
#include <common/config/session-config.h>
+#include <common/dynamic-buffer.h>
+#include <lttng/userspace-probe-internal.h>
#include "lttng-sessiond.h"
#include "buffer-registry.h"
#include "notification-thread.h"
#include "notification-thread-commands.h"
#include "rotation-thread.h"
-#include "syscall.h"
+#include "lttng-syscall.h"
#include "agent.h"
#include "ht-cleanup.h"
#include "sessiond-config.h"
struct lttng_ht *agent_apps_ht_by_sock = NULL;
/*
- * Whether sessiond is ready for commands/notification channel/health check
+ * The initialization of the session daemon is done in multiple phases.
+ *
+ * While all threads are launched near-simultaneously, only some of them
+ * are needed to ensure the session daemon can start to respond to client
* requests.
- * NR_LTTNG_SESSIOND_READY must match the number of calls to
- * sessiond_notify_ready().
+ *
+ * There are two important guarantees that we wish to offer with respect
+ * to the initialisation of the session daemon:
+ * - When the daemonize/background launcher process exits, the sessiond
+ * is fully able to respond to client requests,
+ * - Auto-loaded sessions are visible to clients.
+ *
+ * In order to achieve this, a number of support threads have to be launched
+ * to allow the "client" thread to function properly. Moreover, since the
+ * "load session" thread needs the client thread, we must provide a way
+ * for the "load session" thread to know that the "client" thread is up
+ * and running.
+ *
+ * Hence, the support threads decrement the lttng_sessiond_ready counter
+ * while the "client" threads waits for it to reach 0. Once the "client" thread
+ * unblocks, it posts the message_thread_ready semaphore which allows the
+ * "load session" thread to progress.
+ *
+ * This implies that the "load session" thread is the last to be initialized
+ * and will explicitly call sessiond_signal_parents(), which signals the parents
+ * that the session daemon is fully initialized.
+ *
+ * The four (4) support threads are:
+ * - agent_thread
+ * - notification_thread
+ * - rotation_thread
+ * - health_thread
*/
-#define NR_LTTNG_SESSIOND_READY 5
-int lttng_sessiond_ready = NR_LTTNG_SESSIOND_READY;
+#define NR_LTTNG_SESSIOND_SUPPORT_THREADS 4
+int lttng_sessiond_ready = NR_LTTNG_SESSIOND_SUPPORT_THREADS;
int sessiond_check_thread_quit_pipe(int fd, uint32_t events)
{
/* Notify parents that we are ready for cmd and health check */
LTTNG_HIDDEN
-void sessiond_notify_ready(void)
+void sessiond_signal_parents(void)
{
- if (uatomic_sub_return(<tng_sessiond_ready, 1) == 0) {
- /*
- * Notify parent pid that we are ready to accept command
- * for client side. This ppid is the one from the
- * external process that spawned us.
- */
- if (config.sig_parent) {
- kill(ppid, SIGUSR1);
- }
+ /*
+ * Notify parent pid that we are ready to accept command
+ * for client side. This ppid is the one from the
+ * external process that spawned us.
+ */
+ if (config.sig_parent) {
+ kill(ppid, SIGUSR1);
+ }
- /*
- * Notify the parent of the fork() process that we are
- * ready.
- */
- if (config.daemonize || config.background) {
- kill(child_ppid, SIGUSR1);
- }
+ /*
+ * Notify the parent of the fork() process that we are
+ * ready.
+ */
+ if (config.daemonize || config.background) {
+ kill(child_ppid, SIGUSR1);
}
}
+LTTNG_HIDDEN
+void sessiond_notify_ready(void)
+{
+ /*
+ * This memory barrier is paired with the one performed by
+ * the client thread after it has seen that 'lttng_sessiond_ready' is 0.
+ *
+ * The purpose of these memory barriers is to ensure that all
+ * initialization operations of the various threads that call this
+ * function to signal that they are ready are commited/published
+ * before the client thread can see the 'lttng_sessiond_ready' counter
+ * reach 0.
+ *
+ * Note that this could be a 'write' memory barrier, but a full barrier
+ * is used in case the code using this utility changes. The performance
+ * implications of this choice are minimal since this is a slow path.
+ */
+ cmm_smp_mb();
+ uatomic_sub(<tng_sessiond_ready, 1);
+}
+
static
int __sessiond_set_thread_pollset(struct lttng_poll_event *events, size_t size,
int *a_pipe)
*/
utils_close_pipe(thread_quit_pipe);
- /*
- * If config.pid_file_path.value is undefined, the default file will be
- * wiped when removing the rundir.
- */
- if (config.pid_file_path.value) {
- ret = remove(config.pid_file_path.value);
- if (ret < 0) {
- PERROR("remove pidfile %s", config.pid_file_path.value);
- }
+ ret = remove(config.pid_file_path.value);
+ if (ret < 0) {
+ PERROR("remove pidfile %s", config.pid_file_path.value);
}
DBG("Removing sessiond and consumerd content of directory %s",
free(load_info);
}
- /*
- * Cleanup lock file by deleting it and finaly closing it which will
- * release the file system lock.
- */
- if (lockfile_fd >= 0) {
- ret = remove(config.lock_file_path.value);
- if (ret < 0) {
- PERROR("remove lock file");
- }
- ret = close(lockfile_fd);
- if (ret < 0) {
- PERROR("close lock file");
- }
- }
-
/*
* We do NOT rmdir rundir because there are other processes
* using it, for instance lttng-relayd, which can start in
*
* Useful for CPU hotplug feature.
*/
-static int update_kernel_stream(struct consumer_data *consumer_data, int fd)
+static int update_kernel_stream(int fd)
{
int ret = 0;
struct ltt_session *session;
cds_lfht_for_each_entry(ksess->consumer->socks->ht,
&iter.iter, socket, node.node) {
pthread_mutex_lock(socket->lock);
- ret = kernel_consumer_send_channel_stream(socket,
+ ret = kernel_consumer_send_channel_streams(socket,
channel, ksess,
session->output_traces ? 1 : 0);
pthread_mutex_unlock(socket->lock);
* New CPU detected by the kernel. Adding kernel stream to
* kernel session and updating the kernel consumer
*/
- ret = update_kernel_stream(&kconsumer_data, pollfd);
+ ret = update_kernel_stream(pollfd);
if (ret < 0) {
continue;
}
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.
case LTTNG_ROTATION_GET_INFO:
case LTTNG_SESSION_GET_CURRENT_OUTPUT:
case LTTNG_ROTATION_SET_SCHEDULE:
- case LTTNG_ROTATION_SCHEDULE_GET_TIMER_PERIOD:
- case LTTNG_ROTATION_SCHEDULE_GET_SIZE:
+ case LTTNG_SESSION_LIST_ROTATION_SCHEDULES:
need_domain = 0;
break;
default:
case LTTNG_DATA_PENDING:
case LTTNG_ROTATE_SESSION:
case LTTNG_ROTATION_GET_INFO:
- case LTTNG_ROTATION_SCHEDULE_GET_TIMER_PERIOD:
- case LTTNG_ROTATION_SCHEDULE_GET_SIZE:
+ case LTTNG_SESSION_LIST_ROTATION_SCHEDULES:
break;
default:
/* Setup lttng message with no payload */
}
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;
ret = lttcomm_recv_unix_sock(sock, filter_expression,
expression_len);
if (ret <= 0) {
- DBG("Nothing recv() from client car len data... continuing");
+ DBG("Nothing recv() from client var len data... continuing");
*sock_error = 1;
free(filter_expression);
free(exclusion);
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 car len data... continuing");
+ DBG("Nothing recv() from client var len data... continuing");
*sock_error = 1;
free(filter_expression);
free(bytecode);
}
}
+ 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);
+ 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) {
+ lttng_event_destroy(ev);
+ goto error;
+ }
+ }
+
ret = cmd_enable_event(cmd_ctx->session, &cmd_ctx->lsm->domain,
cmd_ctx->lsm->u.enable.channel_name,
- &cmd_ctx->lsm->u.enable.event,
+ ev,
filter_expression, bytecode, exclusion,
kernel_poll_pipe[1]);
+ lttng_event_destroy(ev);
break;
}
case LTTNG_LIST_TRACEPOINTS:
}
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,
- cmd_ctx->lsm->u.rotate_setup.timer_us,
- cmd_ctx->lsm->u.rotate_setup.size,
+ set_schedule,
+ schedule_type,
+ value,
notification_thread_handle);
- if (ret < 0) {
- ret = -ret;
- goto error;
- }
-
- ret = LTTNG_OK;
- break;
- }
- case LTTNG_ROTATION_SCHEDULE_GET_TIMER_PERIOD:
- {
- struct lttng_rotation_schedule_get_timer_period *get_timer;
-
- get_timer = zmalloc(sizeof(struct lttng_rotation_schedule_get_timer_period));
- if (!get_timer) {
- ret = ENOMEM;
- goto error;
- }
- get_timer->rotate_timer = cmd_ctx->session->rotate_timer_period;
-
- ret = setup_lttng_msg_no_cmd_header(cmd_ctx, get_timer,
- sizeof(struct lttng_rotation_schedule_get_timer_period));
- free(get_timer);
- if (ret < 0) {
- ret = -ret;
+ if (ret != LTTNG_OK) {
goto error;
}
- ret = LTTNG_OK;
break;
}
- case LTTNG_ROTATION_SCHEDULE_GET_SIZE:
+ case LTTNG_SESSION_LIST_ROTATION_SCHEDULES:
{
- struct lttng_rotation_schedule_get_size *get_size;
-
- get_size = zmalloc(sizeof(struct lttng_rotation_schedule_get_size));
- if (!get_size) {
- ret = ENOMEM;
- goto error;
- }
- get_size->rotate_size = cmd_ctx->session->rotate_size;
-
- ret = setup_lttng_msg_no_cmd_header(cmd_ctx, get_size,
- sizeof(struct lttng_rotation_schedule_get_size));
- free(get_size);
+ 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;
goto error;
}
- sessiond_notify_ready();
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) {
+ fd_set read_fds;
+ struct timeval timeout;
+
+ FD_ZERO(&read_fds);
+ FD_SET(thread_quit_pipe[0], &read_fds);
+ memset(&timeout, 0, sizeof(timeout));
+ timeout.tv_usec = 1000;
+
+ /*
+ * 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 = select(thread_quit_pipe[0] + 1, &read_fds, NULL, NULL,
+ &timeout);
+ if (ret > 0 || (ret < 0 && errno != EINTR)) {
+ 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;
health_code_update();
while (1) {
+ const struct cmd_completion_handler *cmd_completion_handler;
+
DBG("Accepting client command ...");
/* Inifinite blocking call, waiting for transmission */
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))",
} else if (string_match(optname, "no-kernel")) {
config.no_kernel = true;
} else if (string_match(optname, "quiet") || opt == 'q') {
- lttng_opt_quiet = true;
+ config.quiet = true;
} else if (string_match(optname, "verbose") || opt == 'v') {
/* Verbose level can increase using multiple -v */
if (arg) {
ERR("Port overflow in --agent-tcp-port parameter: %s", arg);
return -1;
}
- config.agent_tcp_port = (uint32_t) v;
- DBG3("Agent TCP port set to non default: %u", config.agent_tcp_port);
+ config.agent_tcp_port.begin = config.agent_tcp_port.end = (int) v;
+ DBG3("Agent TCP port set to non default: %i", (int) v);
}
} else if (string_match(optname, "load") || opt == 'l') {
if (!arg || *arg == '\0') {
return ret;
}
+/*
+ * Create lockfile using the rundir and return its fd.
+ */
+static int create_lockfile(void)
+{
+ return utils_create_lock_file(config.lock_file_path.value);
+}
+
/*
* Check if the global socket is available, and if a daemon is answering at the
* other side. If yes, error is returned.
+ *
+ * Also attempts to create and hold the lock file.
*/
static int check_existing_daemon(void)
{
+ int ret = 0;
+
/* Is there anybody out there ? */
if (lttng_session_daemon_alive()) {
- return -EEXIST;
+ ret = -EEXIST;
+ goto end;
}
- return 0;
+ lockfile_fd = create_lockfile();
+ if (lockfile_fd < 0) {
+ ret = -EEXIST;
+ goto end;
+ }
+end:
+ return ret;
+}
+
+static void sessiond_cleanup_lock_file(void)
+{
+ int ret;
+
+ /*
+ * Cleanup lock file by deleting it and finaly closing it which will
+ * release the file system lock.
+ */
+ if (lockfile_fd >= 0) {
+ ret = remove(config.lock_file_path.value);
+ if (ret < 0) {
+ PERROR("remove lock file");
+ }
+ ret = close(lockfile_fd);
+ if (ret < 0) {
+ PERROR("close lock file");
+ }
+ }
}
/*
return utils_create_pid_file(getpid(), config.pid_file_path.value);
}
-/*
- * Create lockfile using the rundir and return its fd.
- */
-static int create_lockfile(void)
-{
- return utils_create_lock_file(config.lock_file_path.value);
-}
-
-/*
- * Write agent TCP port using the rundir.
- */
-static int write_agent_port(void)
-{
- return utils_create_pid_file(config.agent_tcp_port,
- config.agent_port_file_path.value);
-}
-
static int set_clock_plugin_env(void)
{
int ret = 0;
struct lttng_pipe *ust32_channel_monitor_pipe = NULL,
*ust64_channel_monitor_pipe = NULL,
*kernel_channel_monitor_pipe = NULL;
- bool notification_thread_running = false;
- bool rotation_thread_running = false;
- bool timer_thread_running = false;
+ bool notification_thread_launched = false;
+ bool rotation_thread_launched = false;
+ bool timer_thread_launched = false;
struct lttng_pipe *ust32_channel_rotate_pipe = NULL,
*ust64_channel_rotate_pipe = NULL,
*kernel_channel_rotate_pipe = NULL;
goto exit_set_signal_handler;
}
+ /*
+ * Init config from environment variables.
+ * Command line option override env configuration per-doc. Do env first.
+ */
+ sessiond_config_apply_env_config(&config);
+
/*
* Parse arguments and load the daemon configuration file.
*
goto exit_options;
}
- /* Init config from environment variables. */
- sessiond_config_apply_env_config(&config);
-
/*
* Resolve all paths received as arguments, configuration option, or
* through environment variable as absolute paths. This is necessary
sessiond_config_log(&config);
+ if (create_lttng_rundir()) {
+ retval = -1;
+ goto exit_options;
+ }
+
+ /* Abort launch if a session daemon is already running. */
+ if (check_existing_daemon()) {
+ ERR("A session daemon is already running.");
+ retval = -1;
+ goto exit_options;
+ }
+
/* Daemonize */
if (config.daemonize || config.background) {
int i;
/*
* We are in the child. Make sure all other file descriptors are
* closed, in case we are called with more opened file
- * descriptors than the standard ones.
+ * descriptors than the standard ones and the lock file.
*/
for (i = 3; i < sysconf(_SC_OPEN_MAX); i++) {
+ if (i == lockfile_fd) {
+ continue;
+ }
(void) close(i);
}
}
/* Check if daemon is UID = 0 */
is_root = !getuid();
-
- if (create_lttng_rundir()) {
- retval = -1;
- goto exit_init_data;
- }
-
if (is_root) {
/* Create global run dir with root access */
}
}
- lockfile_fd = create_lockfile();
- if (lockfile_fd < 0) {
- retval = -1;
- goto exit_init_data;
- }
-
/* Set consumer initial state */
kernel_consumerd_state = CONSUMER_STOPPED;
ust_consumerd_state = CONSUMER_STOPPED;
goto exit_init_data;
}
- /*
- * See if daemon already exist.
- */
- if (check_existing_daemon()) {
- ERR("Already running daemon.\n");
- /*
- * We do not goto exit because we must not cleanup()
- * because a daemon is already running.
- */
- retval = -1;
- goto exit_init_data;
- }
-
/*
* Init UST app hash table. Alloc hash table before this point since
* cleanup() can get called after that point.
retval = -1;
goto exit_init_data;
}
- ret = write_agent_port();
- if (ret) {
- ERR("Error in write_agent_port");
- retval = -1;
- goto exit_init_data;
- }
/* Initialize communication library */
lttcomm_init();
stop_threads();
goto exit_notification;
}
- notification_thread_running = true;
+ notification_thread_launched = true;
/* Create timer thread. */
ret = pthread_create(&timer_thread, default_pthread_attr(),
stop_threads();
goto exit_notification;
}
- timer_thread_running = true;
+ timer_thread_launched = true;
/* rotation_thread_data acquires the pipes' read side. */
rotation_thread_handle = rotation_thread_handle_create(
stop_threads();
goto exit_rotation;
}
- rotation_thread_running = true;
+ rotation_thread_launched = true;
/* Create thread to manage the client socket */
ret = pthread_create(&client_thread, default_pthread_attr(),
* of the active session and channels at the moment of the teardown.
*/
if (notification_thread_handle) {
- if (notification_thread_running) {
+ if (notification_thread_launched) {
notification_thread_command_quit(
notification_thread_handle);
ret = pthread_join(notification_thread, &status);
}
if (rotation_thread_handle) {
- if (rotation_thread_running) {
+ if (rotation_thread_launched) {
ret = pthread_join(rotation_thread, &status);
if (ret) {
errno = ret;
rotation_thread_handle_destroy(rotation_thread_handle);
}
- if (timer_thread_running) {
+ if (timer_thread_launched) {
kill(getpid(), LTTNG_SESSIOND_SIG_EXIT);
ret = pthread_join(timer_thread, &status);
if (ret) {
exit_create_run_as_worker_cleanup:
exit_options:
+ sessiond_cleanup_lock_file();
sessiond_cleanup_options();
exit_set_signal_handler:
projects / lttng-tools.git / blobdiff