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;
* NR_LTTNG_SESSIOND_READY must match the number of calls to
* sessiond_notify_ready().
*/
-#define NR_LTTNG_SESSIOND_READY 3
+#define NR_LTTNG_SESSIOND_READY 4
int lttng_sessiond_ready = NR_LTTNG_SESSIOND_READY;
int sessiond_check_thread_quit_pipe(int fd, uint32_t events)
ret = waitpid(consumer_data->pid, &status, 0);
if (ret == -1) {
PERROR("consumerd waitpid pid: %d", consumer_data->pid)
- }
- if (!WIFEXITED(status)) {
+ } else if (!WIFEXITED(status)) {
ERR("consumerd termination with error: %d",
WEXITSTATUS(ret));
}
free(kmod_extra_probes_list);
run_as_destroy_worker();
-
- /* <fun> */
- DBG("%c[%d;%dm*** assert failed :-) *** ==> %c[%dm%c[%d;%dm"
- "Matthew, BEET driven development works!%c[%dm",
- 27, 1, 31, 27, 0, 27, 1, 33, 27, 0);
- /* </fun> */
}
/*
consumer_data->metadata_sock.lock = zmalloc(sizeof(pthread_mutex_t));
if (consumer_data->metadata_sock.lock == NULL) {
PERROR("zmalloc pthread mutex");
- ret = -1;
goto error;
}
pthread_mutex_init(consumer_data->metadata_sock.lock, NULL);
.count = 0,
};
+ rcu_register_thread();
+
health_register(health_sessiond, HEALTH_SESSIOND_TYPE_APP_REG_DISPATCH);
if (testpoint(sessiond_thread_app_reg_dispatch)) {
DBG("[thread] Dispatch UST command started");
- while (!CMM_LOAD_SHARED(dispatch_thread_exit)) {
+ for (;;) {
health_code_update();
/* Atomically prepare the queue futex */
futex_nto1_prepare(&ust_cmd_queue.futex);
+ if (CMM_LOAD_SHARED(dispatch_thread_exit)) {
+ break;
+ }
+
do {
struct ust_app *app = NULL;
ust_cmd = NULL;
ERR("Health error occurred in %s", __func__);
}
health_unregister(health_sessiond);
+ rcu_unregister_thread();
return NULL;
}
* lttcomm_setsockopt_snd_timeout expect msec as
* parameter.
*/
- (void) lttcomm_setsockopt_rcv_timeout(sock,
- app_socket_timeout * 1000);
- (void) lttcomm_setsockopt_snd_timeout(sock,
- app_socket_timeout * 1000);
+ if (app_socket_timeout >= 0) {
+ (void) lttcomm_setsockopt_rcv_timeout(sock,
+ app_socket_timeout * 1000);
+ (void) lttcomm_setsockopt_snd_timeout(sock,
+ app_socket_timeout * 1000);
+ }
/*
* Set the CLOEXEC flag. Return code is useless because
pthread_mutex_lock(&consumer_data->cond_mutex);
/* Get time for sem_timedwait absolute timeout */
- clock_ret = clock_gettime(CLOCK_MONOTONIC, &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
} else {
DBG("Could not find any valid consumerd executable");
ret = -EINVAL;
- break;
+ goto error;
}
DBG("Using kernel consumer at: %s", consumer_to_use);
ret = execl(consumer_to_use,
break;
}
default:
- PERROR("unknown consumer type");
+ ERR("unknown consumer type");
exit(EXIT_FAILURE);
}
if (errno != 0) {
kernel_tracer_fd = open(module_proc_lttng, O_RDWR);
if (kernel_tracer_fd < 0) {
DBG("Failed to open %s", module_proc_lttng);
- ret = -1;
goto error_open;
}
case LTTNG_CREATE_SESSION:
case LTTNG_CREATE_SESSION_SNAPSHOT:
case LTTNG_CREATE_SESSION_LIVE:
- case LTTNG_CALIBRATE:
case LTTNG_LIST_SESSIONS:
case LTTNG_LIST_TRACEPOINTS:
case LTTNG_LIST_SYSCALLS:
ret = LTTNG_OK;
break;
}
- case LTTNG_CALIBRATE:
- {
- ret = cmd_calibrate(cmd_ctx->lsm->domain.type,
- &cmd_ctx->lsm->u.calibrate);
- break;
- }
case LTTNG_REGISTER_CONSUMER:
{
struct consumer_data *cdata;
if (ret) {
PERROR("close");
}
- new_sock = -1;
continue;
}
if (ret) {
PERROR("close");
}
- new_sock = -1;
}
exit:
}
lttng_poll_clean(&events);
-
+ stop_threads();
rcu_unregister_thread();
return NULL;
}
}
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 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
*/
static void sighandler(int sig)
{
switch (sig) {
- case SIGPIPE:
- DBG("SIGPIPE caught");
- return;
case SIGINT:
DBG("SIGINT caught");
stop_threads();
return ret;
}
- sa.sa_handler = sighandler;
sa.sa_mask = sigset;
sa.sa_flags = 0;
+
+ sa.sa_handler = sighandler;
if ((ret = sigaction(SIGTERM, &sa, NULL)) < 0) {
PERROR("sigaction");
return ret;
return ret;
}
- if ((ret = sigaction(SIGPIPE, &sa, NULL)) < 0) {
+ if ((ret = sigaction(SIGUSR1, &sa, NULL)) < 0) {
PERROR("sigaction");
return ret;
}
- if ((ret = sigaction(SIGUSR1, &sa, NULL)) < 0) {
+ sa.sa_handler = SIG_IGN;
+ if ((ret = sigaction(SIGPIPE, &sa, NULL)) < 0) {
PERROR("sigaction");
return ret;
}
return ret;
}
+static int set_clock_plugin_env(void)
+{
+ int ret = 0;
+ const char *original_env_value;
+ char *full_path = NULL;
+ char *new_env_value = NULL;
+
+ original_env_value = getenv("LTTNG_UST_CLOCK_PLUGIN");
+ if (!original_env_value) {
+ goto end;
+ }
+
+ full_path = utils_expand_path(original_env_value);
+ if (!full_path) {
+ ERR("Failed to expand LTTNG_UST_CLOCK_PLUGIN path \"%s\"",
+ original_env_value);
+ ret = -1;
+ goto end;
+ }
+ ret = asprintf(&new_env_value, "LTTNG_UST_CLOCK_PLUGIN=%s",
+ full_path);
+ free(full_path);
+ if (ret < 0) {
+ PERROR("asprintf");
+ goto end;
+ }
+
+ DBG("Updating environment: %s", new_env_value);
+ ret = putenv(new_env_value);
+ if (ret) {
+ free(new_env_value);
+ PERROR("putenv of LTTNG_UST_CLOCK_PLUGIN");
+ goto end;
+ }
+end:
+ return ret;
+}
+
/*
* main
*/
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;
+ goto exit_options;
+ }
+
/* Daemonize */
if (opt_daemon || opt_background) {
int i;
exit_health:
exit_init_data:
+ /*
+ * Wait for all pending call_rcu work to complete before tearing
+ * down data structures. call_rcu worker may be trying to
+ * perform lookups in those structures.
+ */
+ rcu_barrier();
/*
* sessiond_cleanup() is called when no other thread is running, except
* the ht_cleanup thread, which is needed to destroy the hash tables.