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)
+{
+ /*
+ * The _return variant is used since the implied memory barriers are
+ * required.
+ */
+ (void) uatomic_sub_return(<tng_sessiond_ready, 1);
+}
+
static
int __sessiond_set_thread_pollset(struct lttng_poll_event *events, size_t size,
int *a_pipe)
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);
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;
+ }
+ cmm_smp_rmb();
+ }
+
/* This testpoint is after we signal readiness to the parent. */
if (testpoint(sessiond_thread_manage_clients)) {
goto error;
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 utils_create_pid_file(getpid(), config.pid_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;
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();
projects / lttng-tools.git / blobdiff