/*
* 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,
#include <getopt.h>
#include <grp.h>
#include <limits.h>
+#include <paths.h>
#include <pthread.h>
#include <signal.h>
#include <stdio.h>
#include <common/futex.h>
#include <common/relayd/relayd.h>
#include <common/utils.h>
+#include <common/daemonize.h>
+#include <common/config/config.h>
#include "lttng-sessiond.h"
#include "buffer-registry.h"
#include "health-sessiond.h"
#include "testpoint.h"
#include "ust-thread.h"
+#include "jul-thread.h"
+#include "save.h"
#define CONSUMERD_FILE "lttng-consumerd"
const char *progname;
static const char *tracing_group_name = DEFAULT_TRACING_GROUP;
-static const char *opt_pidfile;
+static int tracing_group_name_override;
+static char *opt_pidfile;
static int opt_sig_parent;
static int opt_verbose_consumer;
-static int opt_daemon;
+static int opt_daemon, opt_background;
static int opt_no_kernel;
-static int is_root; /* Set to 1 if the daemon is running as root */
static pid_t ppid; /* Parent PID for --sig-parent option */
+static pid_t child_ppid; /* Internal parent PID use with daemonize. */
static char *rundir;
+/* Set to 1 when a SIGUSR1 signal is received. */
+static int recv_child_signal;
+
/*
* Consumer daemon specific control data. Every value not initialized here is
* set to 0 by the static definition.
.cond_mutex = PTHREAD_MUTEX_INITIALIZER,
};
+/* Command line options */
+static const struct option long_options[] = {
+ { "client-sock", 1, 0, 'c' },
+ { "apps-sock", 1, 0, 'a' },
+ { "kconsumerd-cmd-sock", 1, 0, 'C' },
+ { "kconsumerd-err-sock", 1, 0, 'E' },
+ { "ustconsumerd32-cmd-sock", 1, 0, 'G' },
+ { "ustconsumerd32-err-sock", 1, 0, 'H' },
+ { "ustconsumerd64-cmd-sock", 1, 0, 'D' },
+ { "ustconsumerd64-err-sock", 1, 0, 'F' },
+ { "consumerd32-path", 1, 0, 'u' },
+ { "consumerd32-libdir", 1, 0, 'U' },
+ { "consumerd64-path", 1, 0, 't' },
+ { "consumerd64-libdir", 1, 0, 'T' },
+ { "daemonize", 0, 0, 'd' },
+ { "background", 0, 0, 'b' },
+ { "sig-parent", 0, 0, 'S' },
+ { "help", 0, 0, 'h' },
+ { "group", 1, 0, 'g' },
+ { "version", 0, 0, 'V' },
+ { "quiet", 0, 0, 'q' },
+ { "verbose", 0, 0, 'v' },
+ { "verbose-consumer", 0, 0, 'Z' },
+ { "no-kernel", 0, 0, 'N' },
+ { "pidfile", 1, 0, 'p' },
+ { "jul-tcp-port", 1, 0, 'J' },
+ { "config", 1, 0, 'f' },
+ { NULL, 0, 0, 0 }
+};
+
+/* Command line options to ignore from configuration file */
+static const char *config_ignore_options[] = { "help", "version", "config" };
+
/* Shared between threads */
static int dispatch_thread_exit;
static pthread_t dispatch_thread;
static pthread_t health_thread;
static pthread_t ht_cleanup_thread;
+static pthread_t jul_reg_thread;
/*
* UST registration command queue. This queue is tied with a futex and uses a N
* wakers / 1 waiter implemented and detailed in futex.c/.h
*
- * The thread_manage_apps and thread_dispatch_ust_registration interact with
- * this queue and the wait/wake scheme.
+ * The thread_registration_apps and thread_dispatch_ust_registration uses this
+ * queue along with the wait/wake scheme. The thread_manage_apps receives down
+ * the line new application socket and monitors it for any I/O error or clean
+ * close that triggers an unregistration of the application.
*/
static struct ust_cmd_queue ust_cmd_queue;
static const char *consumerd64_bin = CONFIG_CONSUMERD64_BIN;
static const char *consumerd32_libdir = CONFIG_CONSUMERD32_LIBDIR;
static const char *consumerd64_libdir = CONFIG_CONSUMERD64_LIBDIR;
+static int consumerd32_bin_override;
+static int consumerd64_bin_override;
+static int consumerd32_libdir_override;
+static int consumerd64_libdir_override;
static const char *module_proc_lttng = "/proc/lttng";
/* Application health monitoring */
struct health_app *health_sessiond;
+/* JUL TCP port for registration. Used by the JUL thread. */
+unsigned int jul_tcp_port = DEFAULT_JUL_TCP_PORT;
+
+/* Am I root or not. */
+int is_root; /* Set to 1 if the daemon is running as root */
+
+const char * const config_section_name = "sessiond";
+
+/*
+ * Whether sessiond is ready for commands/health check requests.
+ * NR_LTTNG_SESSIOND_READY must match the number of calls to
+ * lttng_sessiond_notify_ready().
+ */
+#define NR_LTTNG_SESSIOND_READY 2
+int lttng_sessiond_ready = NR_LTTNG_SESSIOND_READY;
+
+/* Notify parents that we are ready for cmd and health check */
+static
+void lttng_sessiond_notify_ready(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 the parent of the fork() process that we are
+ * ready.
+ */
+ if (opt_daemon || opt_background) {
+ kill(child_ppid, SIGUSR1);
+ }
+ }
+}
+
static
void setup_consumerd_path(void)
{
DBG("Removing %s", path);
(void) unlink(path);
+ snprintf(path, PATH_MAX, "%s/%s", rundir,
+ DEFAULT_LTTNG_SESSIOND_JULPORT_FILE);
+ DBG("Removing %s", path);
+ (void) unlink(path);
+
/* kconsumerd */
snprintf(path, PATH_MAX,
DEFAULT_KCONSUMERD_ERR_SOCK_PATH,
DBG("Removing directory %s", path);
(void) rmdir(path);
+ /*
+ * We do NOT rmdir rundir because there are other processes
+ * using it, for instance lttng-relayd, which can start in
+ * parallel with this teardown.
+ */
+
free(rundir);
DBG("Cleaning up all sessions");
close_consumer_sockets();
+ /*
+ * If the override option is set, the pointer points to a *non* const thus
+ * freeing it even though the variable type is set to const.
+ */
+ if (tracing_group_name_override) {
+ free((void *) tracing_group_name);
+ }
+ if (consumerd32_bin_override) {
+ free((void *) consumerd32_bin);
+ }
+ if (consumerd64_bin_override) {
+ free((void *) consumerd64_bin);
+ }
+ if (consumerd32_libdir_override) {
+ free((void *) consumerd32_libdir);
+ }
+ if (consumerd64_libdir_override) {
+ free((void *) consumerd64_libdir);
+ }
+
+ if (opt_pidfile) {
+ free(opt_pidfile);
+ }
+
/* <fun> */
DBG("%c[%d;%dm*** assert failed :-) *** ==> %c[%dm%c[%d;%dm"
"Matthew, BEET driven development works!%c[%dm",
*/
lttng_poll_init(&events);
- if (testpoint(thread_manage_kernel)) {
+ if (testpoint(sessiond_thread_manage_kernel)) {
goto error_testpoint;
}
health_code_update();
- if (testpoint(thread_manage_kernel_before_loop)) {
+ if (testpoint(sessiond_thread_manage_kernel_before_loop)) {
goto error_testpoint;
}
/* Check for data on kernel pipe */
if (pollfd == kernel_poll_pipe[0] && (revents & LPOLLIN)) {
- do {
- ret = read(kernel_poll_pipe[0], &tmp, 1);
- } while (ret < 0 && errno == EINTR);
+ (void) lttng_read(kernel_poll_pipe[0],
+ &tmp, 1);
/*
* Ret value is useless here, if this pipe gets any actions an
* update is required anyway.
restart:
health_poll_entry();
- if (testpoint(thread_manage_consumer)) {
+ if (testpoint(sessiond_thread_manage_consumer)) {
goto error;
}
}
health_code_update();
-
if (code == LTTCOMM_CONSUMERD_COMMAND_SOCK_READY) {
/* Connect both socket, command and metadata. */
consumer_data->cmd_sock =
}
consumer_data->cmd_sock = -1;
}
- if (*consumer_data->metadata_sock.fd_ptr >= 0) {
+ if (consumer_data->metadata_sock.fd_ptr &&
+ *consumer_data->metadata_sock.fd_ptr >= 0) {
ret = close(*consumer_data->metadata_sock.fd_ptr);
if (ret) {
PERROR("close");
}
}
-
if (sock >= 0) {
ret = close(sock);
if (ret) {
pthread_mutex_unlock(&consumer_data->lock);
/* Cleanup metadata socket mutex. */
- pthread_mutex_destroy(consumer_data->metadata_sock.lock);
- free(consumer_data->metadata_sock.lock);
-
+ if (consumer_data->metadata_sock.lock) {
+ pthread_mutex_destroy(consumer_data->metadata_sock.lock);
+ free(consumer_data->metadata_sock.lock);
+ }
lttng_poll_clean(&events);
error_poll:
if (err) {
static void *thread_manage_apps(void *data)
{
int i, ret, pollfd, err = -1;
+ ssize_t size_ret;
uint32_t revents, nb_fd;
struct lttng_poll_event events;
health_register(health_sessiond, HEALTH_SESSIOND_TYPE_APP_MANAGE);
- if (testpoint(thread_manage_apps)) {
+ if (testpoint(sessiond_thread_manage_apps)) {
goto error_testpoint;
}
goto error;
}
- if (testpoint(thread_manage_apps_before_loop)) {
+ if (testpoint(sessiond_thread_manage_apps_before_loop)) {
goto error;
}
int sock;
/* Empty pipe */
- do {
- ret = read(apps_cmd_pipe[0], &sock, sizeof(sock));
- } while (ret < 0 && errno == EINTR);
- if (ret < 0 || ret < sizeof(sock)) {
+ size_ret = lttng_read(apps_cmd_pipe[0], &sock, sizeof(sock));
+ if (size_ret < sizeof(sock)) {
PERROR("read apps cmd pipe");
goto error;
}
goto error;
}
- /*
- * Set socket timeout for both receiving and ending.
- * app_socket_timeout is in seconds, whereas
- * lttcomm_setsockopt_rcv_timeout and
- * 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);
-
DBG("Apps with sock %d added to poll set", sock);
-
- health_code_update();
-
- break;
}
} else {
/*
/* Socket closed on remote end. */
ust_app_unregister(pollfd);
- break;
}
}
*/
static int send_socket_to_thread(int fd, int sock)
{
- int ret;
+ ssize_t ret;
/*
* It's possible that the FD is set as invalid with -1 concurrently just
goto error;
}
- do {
- ret = write(fd, &sock, sizeof(sock));
- } while (ret < 0 && errno == EINTR);
- if (ret < 0 || ret != sizeof(sock)) {
+ ret = lttng_write(fd, &sock, sizeof(sock));
+ if (ret < sizeof(sock)) {
PERROR("write apps pipe %d", fd);
if (ret < 0) {
ret = -errno;
/* All good. Don't send back the write positive ret value. */
ret = 0;
error:
- return ret;
+ return (int) ret;
}
/*
health_register(health_sessiond, HEALTH_SESSIOND_TYPE_APP_REG_DISPATCH);
+ if (testpoint(sessiond_thread_app_reg_dispatch)) {
+ goto error_testpoint;
+ }
+
health_code_update();
CDS_INIT_LIST_HEAD(&wait_queue.head);
if (ret < 0) {
PERROR("close ust sock dispatch %d", ust_cmd->sock);
}
- lttng_fd_put(1, LTTNG_FD_APPS);
+ lttng_fd_put(LTTNG_FD_APPS, 1);
free(ust_cmd);
goto error;
}
if (ret < 0) {
PERROR("close ust sock dispatch %d", ust_cmd->sock);
}
- lttng_fd_put(1, LTTNG_FD_APPS);
+ lttng_fd_put(LTTNG_FD_APPS, 1);
free(wait_node);
free(ust_cmd);
continue;
if (ret < 0) {
PERROR("close ust sock dispatch %d", ust_cmd->sock);
}
- lttng_fd_put(1, LTTNG_FD_APPS);
+ lttng_fd_put(LTTNG_FD_APPS, 1);
}
free(ust_cmd);
}
free(wait_node);
}
+error_testpoint:
DBG("Dispatch thread dying");
if (err) {
health_error();
health_register(health_sessiond, HEALTH_SESSIOND_TYPE_APP_REG);
- if (testpoint(thread_registration_apps)) {
+ if (testpoint(sessiond_thread_registration_apps)) {
goto error_testpoint;
}
goto error;
}
+ /*
+ * Set socket timeout for both receiving and ending.
+ * app_socket_timeout is in seconds, whereas
+ * lttcomm_setsockopt_rcv_timeout and
+ * 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);
+
/*
* Set the CLOEXEC flag. Return code is useless because
* either way, the show must go on.
exit:
error:
- if (err) {
- health_error();
- ERR("Health error occurred in %s", __func__);
- }
-
/* Notify that the registration thread is gone */
notify_ust_apps(0);
error_create_poll:
error_testpoint:
DBG("UST Registration thread cleanup complete");
+ if (err) {
+ health_error();
+ ERR("Health error occurred in %s", __func__);
+ }
health_unregister(health_sessiond);
return NULL;
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");
- ret = pthread_cancel(consumer_data->thread);
- if (ret < 0) {
+ 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;
}
*/
if (opt_verbose_consumer) {
verbosity = "--verbose";
- } else {
+ } else if (lttng_opt_quiet) {
verbosity = "--quiet";
+ } else {
+ verbosity = "";
}
+
switch (consumer_data->type) {
case LTTNG_CONSUMER_KERNEL:
/*
consumer_to_use = consumerd32_bin;
} else {
DBG("Could not find any valid consumerd executable");
+ ret = -EINVAL;
break;
}
DBG("Using kernel consumer at: %s", consumer_to_use);
- execl(consumer_to_use,
+ ret = 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,
if (consumerd64_libdir[0] != '\0') {
free(tmpnew);
}
- if (ret) {
- goto error;
- }
break;
}
case LTTNG_CONSUMER32_UST:
if (consumerd32_libdir[0] != '\0') {
free(tmpnew);
}
- if (ret) {
- goto error;
- }
break;
}
default:
exit(EXIT_FAILURE);
}
if (errno != 0) {
- PERROR("kernel start consumer exec");
+ PERROR("Consumer execl()");
}
+ /* Reaching this point, we got a failure on our execl(). */
exit(EXIT_FAILURE);
} else if (pid > 0) {
ret = pid;
consumer = session->kernel_session->consumer;
dir_name = DEFAULT_KERNEL_TRACE_DIR;
break;
+ case LTTNG_DOMAIN_JUL:
case LTTNG_DOMAIN_UST:
DBG3("Copying tracing session consumer output in UST session");
if (session->ust_session->consumer) {
assert(session->consumer);
switch (domain->type) {
+ case LTTNG_DOMAIN_JUL:
case LTTNG_DOMAIN_UST:
break;
default:
case LTTNG_SNAPSHOT_DEL_OUTPUT:
case LTTNG_SNAPSHOT_LIST_OUTPUT:
case LTTNG_SNAPSHOT_RECORD:
+ case LTTNG_SAVE_SESSION:
need_domain = 0;
break;
default:
case LTTNG_LIST_SESSIONS:
case LTTNG_LIST_TRACEPOINTS:
case LTTNG_LIST_TRACEPOINT_FIELDS:
+ case LTTNG_SAVE_SESSION:
need_tracing_session = 0;
break;
default:
}
break;
+ case LTTNG_DOMAIN_JUL:
case LTTNG_DOMAIN_UST:
{
if (!ust_app_supported()) {
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_JUL:
case LTTNG_DOMAIN_UST:
if (uatomic_read(&ust_consumerd_state) != CONSUMER_STARTED) {
ret = LTTNG_ERR_NO_USTCONSUMERD;
}
case LTTNG_ENABLE_EVENT:
{
+ 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 car 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(exclusion);
+ goto error;
+ }
+
+ bytecode = zmalloc(bytecode_len);
+ if (!bytecode) {
+ 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 car len data... continuing");
+ *sock_error = 1;
+ free(bytecode);
+ free(exclusion);
+ ret = LTTNG_ERR_FILTER_INVAL;
+ goto error;
+ }
+
+ if ((bytecode->len + sizeof(*bytecode)) != bytecode_len) {
+ free(bytecode);
+ free(exclusion);
+ ret = LTTNG_ERR_FILTER_INVAL;
+ 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, NULL, kernel_poll_pipe[1]);
+ &cmd_ctx->lsm->u.enable.event,
+ filter_expression, bytecode, exclusion,
+ kernel_poll_pipe[1]);
break;
}
case LTTNG_ENABLE_ALL_EVENT:
ret = cmd_enable_event_all(cmd_ctx->session, &cmd_ctx->lsm->domain,
cmd_ctx->lsm->u.enable.channel_name,
- cmd_ctx->lsm->u.enable.event.type, NULL, kernel_poll_pipe[1]);
+ cmd_ctx->lsm->u.enable.event.type, NULL, NULL,
+ kernel_poll_pipe[1]);
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;
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;
cmd_ctx->lsm->u.reg.path, cdata);
break;
}
- case LTTNG_ENABLE_EVENT_WITH_FILTER:
- {
- struct lttng_filter_bytecode *bytecode;
-
- if (cmd_ctx->lsm->u.enable.bytecode_len > LTTNG_FILTER_MAX_LEN) {
- ret = LTTNG_ERR_FILTER_INVAL;
- goto error;
- }
- if (cmd_ctx->lsm->u.enable.bytecode_len == 0) {
- ret = LTTNG_ERR_FILTER_INVAL;
- goto error;
- }
- bytecode = zmalloc(cmd_ctx->lsm->u.enable.bytecode_len);
- if (!bytecode) {
- ret = LTTNG_ERR_FILTER_NOMEM;
- goto error;
- }
- /* Receive var. len. data */
- DBG("Receiving var len data from client ...");
- ret = lttcomm_recv_unix_sock(sock, bytecode,
- cmd_ctx->lsm->u.enable.bytecode_len);
- if (ret <= 0) {
- DBG("Nothing recv() from client var len data... continuing");
- *sock_error = 1;
- ret = LTTNG_ERR_FILTER_INVAL;
- goto error;
- }
-
- if (bytecode->len + sizeof(*bytecode)
- != cmd_ctx->lsm->u.enable.bytecode_len) {
- free(bytecode);
- ret = LTTNG_ERR_FILTER_INVAL;
- 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, bytecode, kernel_poll_pipe[1]);
- break;
- }
case LTTNG_DATA_PENDING:
{
ret = cmd_data_pending(cmd_ctx->session);
free(uris);
break;
}
+ case LTTNG_SAVE_SESSION:
+ {
+ ret = cmd_save_sessions(&cmd_ctx->lsm->u.save_session.attr,
+ &cmd_ctx->creds);
+ break;
+ }
default:
ret = LTTNG_ERR_UND;
break;
goto error;
}
+ lttng_sessiond_notify_ready();
+
while (1) {
DBG("Health check ready");
rcu_thread_online();
- reply.ret_code = 0;
+ memset(&reply, 0, sizeof(reply));
for (i = 0; i < NR_HEALTH_SESSIOND_TYPES; i++) {
/*
* health_check_state returns 0 if health is
health_register(health_sessiond, HEALTH_SESSIOND_TYPE_CMD);
- if (testpoint(thread_manage_clients)) {
- goto error_testpoint;
- }
-
health_code_update();
ret = lttcomm_listen_unix_sock(client_sock);
goto error;
}
- /*
- * Notify parent pid that we are ready to accept command for client side.
- */
- if (opt_sig_parent) {
- kill(ppid, SIGUSR1);
+ lttng_sessiond_notify_ready();
+
+ /* This testpoint is after we signal readiness to the parent. */
+ if (testpoint(sessiond_thread_manage_clients)) {
+ goto error;
}
- if (testpoint(thread_manage_clients_before_loop)) {
+ if (testpoint(sessiond_thread_manage_clients_before_loop)) {
goto error;
}
error_listen:
error_create_poll:
-error_testpoint:
unlink(client_unix_sock_path);
if (client_sock >= 0) {
ret = close(client_sock);
fprintf(stderr, " --consumerd64-path PATH Specify path for the 64-bit UST consumer daemon binary\n");
fprintf(stderr, " --consumerd64-libdir PATH Specify path for the 64-bit UST consumer daemon libraries\n");
fprintf(stderr, " -d, --daemonize Start as a daemon.\n");
+ fprintf(stderr, " -b, --background Start as a daemon, keeping console open.\n");
fprintf(stderr, " -g, --group NAME Specify the tracing group name. (default: tracing)\n");
fprintf(stderr, " -V, --version Show version number.\n");
- fprintf(stderr, " -S, --sig-parent Send SIGCHLD to parent pid to notify readiness.\n");
+ fprintf(stderr, " -S, --sig-parent Send SIGUSR1 to parent pid to notify readiness.\n");
fprintf(stderr, " -q, --quiet No output at all.\n");
fprintf(stderr, " -v, --verbose Verbose mode. Activate DBG() macro.\n");
fprintf(stderr, " -p, --pidfile FILE Write a pid to FILE name overriding the default value.\n");
fprintf(stderr, " --verbose-consumer Verbose mode for consumer. Activate DBG() macro.\n");
fprintf(stderr, " --no-kernel Disable kernel tracer\n");
+ fprintf(stderr, " --jul-tcp-port JUL application registration TCP port\n");
+ fprintf(stderr, " -f --config Load daemon configuration file\n");
}
/*
- * daemon argument parsing
+ * 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 parse_args(int argc, char **argv)
+static int set_option(int opt, const char *arg, const char *optname)
{
- int c;
-
- static struct option long_options[] = {
- { "client-sock", 1, 0, 'c' },
- { "apps-sock", 1, 0, 'a' },
- { "kconsumerd-cmd-sock", 1, 0, 'C' },
- { "kconsumerd-err-sock", 1, 0, 'E' },
- { "ustconsumerd32-cmd-sock", 1, 0, 'G' },
- { "ustconsumerd32-err-sock", 1, 0, 'H' },
- { "ustconsumerd64-cmd-sock", 1, 0, 'D' },
- { "ustconsumerd64-err-sock", 1, 0, 'F' },
- { "consumerd32-path", 1, 0, 'u' },
- { "consumerd32-libdir", 1, 0, 'U' },
- { "consumerd64-path", 1, 0, 't' },
- { "consumerd64-libdir", 1, 0, 'T' },
- { "daemonize", 0, 0, 'd' },
- { "sig-parent", 0, 0, 'S' },
- { "help", 0, 0, 'h' },
- { "group", 1, 0, 'g' },
- { "version", 0, 0, 'V' },
- { "quiet", 0, 0, 'q' },
- { "verbose", 0, 0, 'v' },
- { "verbose-consumer", 0, 0, 'Z' },
- { "no-kernel", 0, 0, 'N' },
- { "pidfile", 1, 0, 'p' },
- { NULL, 0, 0, 0 }
- };
+ int ret = 0;
+
+ switch (opt) {
+ case 0:
+ fprintf(stderr, "option %s", optname);
+ if (arg) {
+ fprintf(stderr, " with arg %s\n", arg);
+ }
+ break;
+ case 'c':
+ snprintf(client_unix_sock_path, PATH_MAX, "%s", arg);
+ break;
+ case 'a':
+ snprintf(apps_unix_sock_path, PATH_MAX, "%s", arg);
+ break;
+ case 'd':
+ opt_daemon = 1;
+ break;
+ case 'b':
+ opt_background = 1;
+ break;
+ case 'g':
+ tracing_group_name = strdup(arg);
+ break;
+ case 'h':
+ usage();
+ exit(EXIT_FAILURE);
+ case 'V':
+ fprintf(stdout, "%s\n", VERSION);
+ exit(EXIT_SUCCESS);
+ case 'S':
+ opt_sig_parent = 1;
+ break;
+ case 'E':
+ snprintf(kconsumer_data.err_unix_sock_path, PATH_MAX, "%s", arg);
+ break;
+ case 'C':
+ snprintf(kconsumer_data.cmd_unix_sock_path, PATH_MAX, "%s", arg);
+ break;
+ case 'F':
+ snprintf(ustconsumer64_data.err_unix_sock_path, PATH_MAX, "%s", arg);
+ break;
+ case 'D':
+ snprintf(ustconsumer64_data.cmd_unix_sock_path, PATH_MAX, "%s", arg);
+ break;
+ case 'H':
+ snprintf(ustconsumer32_data.err_unix_sock_path, PATH_MAX, "%s", arg);
+ break;
+ case 'G':
+ snprintf(ustconsumer32_data.cmd_unix_sock_path, PATH_MAX, "%s", arg);
+ break;
+ case 'N':
+ opt_no_kernel = 1;
+ break;
+ case 'q':
+ lttng_opt_quiet = 1;
+ break;
+ case 'v':
+ /* Verbose level can increase using multiple -v */
+ if (arg) {
+ lttng_opt_verbose = config_parse_value(arg);
+ } else {
+ lttng_opt_verbose += 1;
+ }
+ break;
+ case 'Z':
+ if (arg) {
+ opt_verbose_consumer = config_parse_value(arg);
+ } else {
+ opt_verbose_consumer += 1;
+ }
+ break;
+ case 'u':
+ consumerd32_bin = strdup(arg);
+ consumerd32_bin_override = 1;
+ break;
+ case 'U':
+ consumerd32_libdir = strdup(arg);
+ consumerd32_libdir_override = 1;
+ break;
+ case 't':
+ consumerd64_bin = strdup(arg);
+ consumerd64_bin_override = 1;
+ break;
+ case 'T':
+ consumerd64_libdir = strdup(arg);
+ consumerd64_libdir_override = 1;
+ break;
+ case 'p':
+ opt_pidfile = strdup(arg);
+ break;
+ case 'J': /* JUL TCP port. */
+ {
+ unsigned long v;
+
+ errno = 0;
+ v = strtoul(arg, NULL, 0);
+ if (errno != 0 || !isdigit(arg[0])) {
+ ERR("Wrong value in --jul-tcp-port parameter: %s", arg);
+ return -1;
+ }
+ if (v == 0 || v >= 65535) {
+ ERR("Port overflow in --jul-tcp-port parameter: %s", arg);
+ return -1;
+ }
+ jul_tcp_port = (uint32_t) v;
+ DBG3("JUL TCP port set to non default: %u", jul_tcp_port);
+ break;
+ }
+ default:
+ /* Unknown option or other error.
+ * Error is printed by getopt, just return */
+ ret = -1;
+ }
+
+ return ret;
+}
+
+/*
+ * config_entry_handler_cb used to handle options read from a config file.
+ * See config_entry_handler_cb comment in common/config/config.h for the
+ * return value conventions.
+ */
+static int config_entry_handler(const struct config_entry *entry, void *unused)
+{
+ int ret = 0, i;
+
+ if (!entry || !entry->name || !entry->value) {
+ ret = -EINVAL;
+ goto end;
+ }
+
+ /* Check if the option is to be ignored */
+ for (i = 0; i < sizeof(config_ignore_options) / sizeof(char *); i++) {
+ if (!strcmp(entry->name, config_ignore_options[i])) {
+ goto end;
+ }
+ }
+
+ for (i = 0; i < (sizeof(long_options) / sizeof(struct option)) - 1;
+ i++) {
+
+ /* Ignore if not fully matched. */
+ if (strcmp(entry->name, long_options[i].name)) {
+ continue;
+ }
+
+ /*
+ * If the option takes no argument on the command line, we have to
+ * check if the value is "true". We support non-zero numeric values,
+ * true, on and yes.
+ */
+ if (!long_options[i].has_arg) {
+ ret = config_parse_value(entry->value);
+ if (ret <= 0) {
+ if (ret) {
+ WARN("Invalid configuration value \"%s\" for option %s",
+ entry->value, entry->name);
+ }
+ /* False, skip boolean config option. */
+ goto end;
+ }
+ }
+
+ ret = set_option(long_options[i].val, entry->value, entry->name);
+ goto end;
+ }
+
+ WARN("Unrecognized option \"%s\" in daemon configuration file.", entry->name);
+
+end:
+ return ret;
+}
+
+/*
+ * daemon configuration loading and argument parsing
+ */
+static int set_options(int argc, char **argv)
+{
+ int ret = 0, c = 0, option_index = 0;
+ int orig_optopt = optopt, orig_optind = optind;
+ char *optstring;
+ const char *config_path = NULL;
+
+ optstring = utils_generate_optstring(long_options,
+ sizeof(long_options) / sizeof(struct option));
+ if (!optstring) {
+ ret = -ENOMEM;
+ goto end;
+ }
+
+ /* Check for the --config option */
+ while ((c = getopt_long(argc, argv, optstring, long_options,
+ &option_index)) != -1) {
+ if (c == '?') {
+ ret = -EINVAL;
+ goto end;
+ } else if (c != 'f') {
+ /* if not equal to --config option. */
+ continue;
+ }
+ config_path = utils_expand_path(optarg);
+ if (!config_path) {
+ ERR("Failed to resolve path: %s", optarg);
+ }
+ }
+
+ ret = config_get_section_entries(config_path, config_section_name,
+ config_entry_handler, NULL);
+ if (ret) {
+ if (ret > 0) {
+ ERR("Invalid configuration option at line %i", ret);
+ ret = -1;
+ }
+ goto end;
+ }
+
+ /* Reset getopt's global state */
+ optopt = orig_optopt;
+ optind = orig_optind;
while (1) {
- int option_index = 0;
- c = getopt_long(argc, argv, "dhqvVSN" "a:c:g:s:C:E:D:F:Z:u:t:p:",
- long_options, &option_index);
+ c = getopt_long(argc, argv, optstring, long_options, &option_index);
if (c == -1) {
break;
}
- switch (c) {
- case 0:
- fprintf(stderr, "option %s", long_options[option_index].name);
- if (optarg) {
- fprintf(stderr, " with arg %s\n", optarg);
- }
- break;
- case 'c':
- snprintf(client_unix_sock_path, PATH_MAX, "%s", optarg);
- break;
- case 'a':
- snprintf(apps_unix_sock_path, PATH_MAX, "%s", optarg);
- break;
- case 'd':
- opt_daemon = 1;
- break;
- case 'g':
- tracing_group_name = optarg;
- break;
- case 'h':
- usage();
- exit(EXIT_FAILURE);
- case 'V':
- fprintf(stdout, "%s\n", VERSION);
- exit(EXIT_SUCCESS);
- case 'S':
- opt_sig_parent = 1;
- break;
- case 'E':
- snprintf(kconsumer_data.err_unix_sock_path, PATH_MAX, "%s", optarg);
- break;
- case 'C':
- snprintf(kconsumer_data.cmd_unix_sock_path, PATH_MAX, "%s", optarg);
- break;
- case 'F':
- snprintf(ustconsumer64_data.err_unix_sock_path, PATH_MAX, "%s", optarg);
- break;
- case 'D':
- snprintf(ustconsumer64_data.cmd_unix_sock_path, PATH_MAX, "%s", optarg);
- break;
- case 'H':
- snprintf(ustconsumer32_data.err_unix_sock_path, PATH_MAX, "%s", optarg);
- break;
- case 'G':
- snprintf(ustconsumer32_data.cmd_unix_sock_path, PATH_MAX, "%s", optarg);
- break;
- case 'N':
- opt_no_kernel = 1;
- break;
- case 'q':
- lttng_opt_quiet = 1;
- break;
- case 'v':
- /* Verbose level can increase using multiple -v */
- lttng_opt_verbose += 1;
- break;
- case 'Z':
- opt_verbose_consumer += 1;
- break;
- case 'u':
- consumerd32_bin= optarg;
- break;
- case 'U':
- consumerd32_libdir = optarg;
- break;
- case 't':
- consumerd64_bin = optarg;
- break;
- case 'T':
- consumerd64_libdir = optarg;
- break;
- case 'p':
- opt_pidfile = optarg;
+ ret = set_option(c, optarg, long_options[option_index].name);
+ if (ret < 0) {
break;
- default:
- /* Unknown option or other error.
- * Error is printed by getopt, just return */
- return -1;
}
}
- return 0;
+end:
+ free(optstring);
+ return ret;
}
/*
DBG("SIGTERM caught");
stop_threads();
break;
+ case SIGUSR1:
+ CMM_STORE_SHARED(recv_child_signal, 1);
+ break;
default:
break;
}
return ret;
}
- DBG("Signal handler set for SIGTERM, SIGPIPE and SIGINT");
+ if ((ret = sigaction(SIGUSR1, &sa, NULL)) < 0) {
+ PERROR("sigaction");
+ return ret;
+ }
+
+ DBG("Signal handler set for SIGTERM, SIGUSR1, SIGPIPE and SIGINT");
return ret;
}
return;
}
+/*
+ * Write JUL TCP port using the rundir.
+ */
+static void write_julport(void)
+{
+ int ret;
+ char path[PATH_MAX];
+
+ assert(rundir);
+
+ ret = snprintf(path, sizeof(path), "%s/"
+ DEFAULT_LTTNG_SESSIOND_JULPORT_FILE, rundir);
+ if (ret < 0) {
+ PERROR("snprintf julport path");
+ goto error;
+ }
+
+ /*
+ * Create TCP JUL port file in rundir. Return value is of no importance.
+ * The execution will continue even though we are not able to write the
+ * file.
+ */
+ (void) utils_create_pid_file(jul_tcp_port, path);
+
+error:
+ return;
+}
+
/*
* main
*/
rcu_register_thread();
+ if ((ret = set_signal_handler()) < 0) {
+ goto error;
+ }
+
setup_consumerd_path();
page_size = sysconf(_SC_PAGESIZE);
WARN("Fallback page size to %ld", page_size);
}
- /* Parse arguments */
+ /* Parse arguments and load the daemon configuration file */
progname = argv[0];
- if ((ret = parse_args(argc, argv)) < 0) {
+ if ((ret = set_options(argc, argv)) < 0) {
goto error;
}
/* Daemonize */
- if (opt_daemon) {
+ if (opt_daemon || opt_background) {
int i;
- /*
- * fork
- * child: setsid, close FD 0, 1, 2, chdir /
- * parent: exit (if fork is successful)
- */
- ret = daemon(0, 0);
+ ret = lttng_daemonize(&child_ppid, &recv_child_signal,
+ !opt_background);
if (ret < 0) {
- PERROR("daemon");
goto error;
}
+
/*
- * 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.
+ * 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.
*/
for (i = 3; i < sysconf(_SC_OPEN_MAX); i++) {
(void) close(i);
*/
ust_app_ht_alloc();
+ /* Initialize JUL domain subsystem. */
+ if ((ret = jul_init()) < 0) {
+ /* ENOMEM at this point. */
+ goto error;
+ }
+
/* After this point, we can safely call cleanup() with "goto exit" */
/*
goto exit;
}
- if ((ret = set_signal_handler()) < 0) {
- goto exit;
- }
-
/* Setup the needed unix socket */
if ((ret = init_daemon_socket()) < 0) {
goto exit;
}
write_pidfile();
+ write_julport();
/* Initialize communication library */
lttcomm_init();
goto exit_health_sessiond_cleanup;
}
- /* Create thread to manage the client socket */
+ /* Create thread to clean up RCU hash tables */
ret = pthread_create(&ht_cleanup_thread, NULL,
thread_ht_cleanup, (void *) NULL);
if (ret != 0) {
goto exit_ht_cleanup;
}
- /* Create thread to manage the client socket */
+ /* Create health-check thread */
ret = pthread_create(&health_thread, NULL,
thread_manage_health, (void *) NULL);
if (ret != 0) {
goto exit_apps_notify;
}
+ /* Create JUL registration thread. */
+ ret = pthread_create(&jul_reg_thread, NULL,
+ jul_thread_manage_registration, (void *) NULL);
+ if (ret != 0) {
+ PERROR("pthread_create apps");
+ goto exit_jul_reg;
+ }
+
/* Don't start this thread if kernel tracing is not requested nor root */
if (is_root && !opt_no_kernel) {
/* Create kernel thread to manage kernel event */
}
exit_kernel:
+ ret = pthread_join(jul_reg_thread, &status);
+ if (ret != 0) {
+ PERROR("pthread_join JUL");
+ goto error; /* join error, exit without cleanup */
+ }
+
+exit_jul_reg:
ret = pthread_join(apps_notify_thread, &status);
if (ret != 0) {
PERROR("pthread_join apps notify");
projects / lttng-tools.git / blobdiff