static pid_t child_ppid; /* Internal parent PID use with daemonize. */
static char *rundir;
static int lockfile_fd = -1;
+static int opt_print_version;
/* Set to 1 when a SIGUSR1 signal is received. */
static int recv_child_signal;
struct lttng_ht *agent_apps_ht_by_sock = NULL;
/*
- * Whether sessiond is ready for commands/health check requests.
- * NR_LTTNG_SESSIOND_READY must match the number of calls to
- * sessiond_notify_ready().
+ * 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.
+ *
+ * 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 two (2) support threads are:
+ * - agent_thread
+ * - health_thread
*/
-#define NR_LTTNG_SESSIOND_READY 3
-int lttng_sessiond_ready = NR_LTTNG_SESSIOND_READY;
+int lttng_sessiond_ready = 2;
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 (opt_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 (opt_sig_parent) {
+ kill(ppid, SIGUSR1);
+ }
- /*
- * Notify the parent of the fork() process that we are
- * ready.
- */
- if (opt_daemon || opt_background) {
- kill(child_ppid, SIGUSR1);
- }
+ /*
+ * Notify the parent of the fork() process that we are
+ * ready.
+ */
+ if (opt_daemon || opt_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
void setup_consumerd_path(void)
{
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;
}
exit(ret ? EXIT_FAILURE : EXIT_SUCCESS);
} else if (string_match(optname, "version") || opt == 'V') {
- fprintf(stdout, "%s\n", VERSION);
- exit(EXIT_SUCCESS);
+ opt_print_version = 1;
} else if (string_match(optname, "sig-parent") || opt == 'S') {
opt_sig_parent = 1;
} else if (string_match(optname, "kconsumerd-err-sock")) {
return ret;
}
+static void sessiond_config_log(void)
+{
+ DBG("LTTng-sessiond " VERSION " - " VERSION_NAME "%s%s",
+ GIT_VERSION[0] == '\0' ? "" : " - " GIT_VERSION,
+ EXTRA_VERSION_NAME[0] == '\0' ? "" : " - " EXTRA_VERSION_NAME);
+ if (EXTRA_VERSION_DESCRIPTION[0] != '\0') {
+ DBG("LTTng-sessiond extra version description:\n\t" EXTRA_VERSION_DESCRIPTION "\n");
+ }
+ if (EXTRA_VERSION_PATCHES[0] != '\0') {
+ DBG("LTTng-sessiond extra patches:\n\t" EXTRA_VERSION_PATCHES "\n");
+ }
+}
+
+static void print_version(void) {
+ fprintf(stdout, "%s\n", VERSION);
+}
+
/*
* daemon configuration loading and argument parsing
*/
goto exit_options;
}
+ sessiond_config_log();
+
+ if (opt_print_version) {
+ print_version();
+ retval = 0;
+ goto exit_options;
+ }
+
ret = set_clock_plugin_env();
if (ret) {
retval = -1;
projects / lttng-tools.git / blobdiff