#include <getopt.h>
#include <grp.h>
#include <limits.h>
+#include <paths.h>
#include <pthread.h>
#include <signal.h>
#include <stdio.h>
#include "health-sessiond.h"
#include "testpoint.h"
#include "ust-thread.h"
+#include "jul-thread.h"
#define CONSUMERD_FILE "lttng-consumerd"
-/* Const values */
-const char default_tracing_group[] = DEFAULT_TRACING_GROUP;
-
const char *progname;
-const char *opt_tracing_group;
+static const char *tracing_group_name = DEFAULT_TRACING_GROUP;
static const char *opt_pidfile;
static int opt_sig_parent;
static int opt_verbose_consumer;
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.
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
/* 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;
+
static
void setup_consumerd_path(void)
{
return 0;
}
-/*
- * Return group ID of the tracing group or -1 if not found.
- */
-static gid_t allowed_group(void)
-{
- struct group *grp;
-
- if (opt_tracing_group) {
- grp = getgrnam(opt_tracing_group);
- } else {
- grp = getgrnam(default_tracing_group);
- }
- if (!grp) {
- return -1;
- } else {
- return grp->gr_gid;
- }
-}
-
/*
* Init thread quit pipe.
*
static void cleanup(void)
{
int ret;
- char *cmd = NULL;
struct ltt_session *sess, *stmp;
+ char path[PATH_MAX];
DBG("Cleaning up");
}
}
- DBG("Removing %s directory", rundir);
- ret = asprintf(&cmd, "rm -rf %s", rundir);
- if (ret < 0) {
- ERR("asprintf failed. Something is really wrong!");
- }
+ DBG("Removing sessiond and consumerd content of directory %s", rundir);
+
+ /* sessiond */
+ snprintf(path, PATH_MAX,
+ "%s/%s",
+ rundir, DEFAULT_LTTNG_SESSIOND_PIDFILE);
+ 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,
+ rundir);
+ DBG("Removing %s", path);
+ (void) unlink(path);
+
+ snprintf(path, PATH_MAX,
+ DEFAULT_KCONSUMERD_PATH,
+ rundir);
+ DBG("Removing directory %s", path);
+ (void) rmdir(path);
+
+ /* ust consumerd 32 */
+ snprintf(path, PATH_MAX,
+ DEFAULT_USTCONSUMERD32_ERR_SOCK_PATH,
+ rundir);
+ DBG("Removing %s", path);
+ (void) unlink(path);
+
+ snprintf(path, PATH_MAX,
+ DEFAULT_USTCONSUMERD32_PATH,
+ rundir);
+ DBG("Removing directory %s", path);
+ (void) rmdir(path);
+
+ /* ust consumerd 64 */
+ snprintf(path, PATH_MAX,
+ DEFAULT_USTCONSUMERD64_ERR_SOCK_PATH,
+ rundir);
+ DBG("Removing %s", path);
+ (void) unlink(path);
+
+ snprintf(path, PATH_MAX,
+ DEFAULT_USTCONSUMERD64_PATH,
+ rundir);
+ 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.
+ */
- /* Remove lttng run directory */
- ret = system(cmd);
- if (ret < 0) {
- ERR("Unable to clean %s", rundir);
- }
- free(cmd);
free(rundir);
DBG("Cleaning up all sessions");
DBG("[thread] Thread manage kernel started");
- health_register(health_sessiond, HEALTH_TYPE_KERNEL);
+ health_register(health_sessiond, HEALTH_SESSIOND_TYPE_KERNEL);
/*
* This first step of the while is to clean this structure which could free
/* 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.
DBG("[thread] Manage consumer started");
- health_register(health_sessiond, HEALTH_TYPE_CONSUMER);
+ health_register(health_sessiond, HEALTH_SESSIOND_TYPE_CONSUMER);
health_code_update();
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;
rcu_register_thread();
rcu_thread_online();
- health_register(health_sessiond, HEALTH_TYPE_APP_MANAGE);
+ health_register(health_sessiond, HEALTH_SESSIOND_TYPE_APP_MANAGE);
if (testpoint(thread_manage_apps)) {
goto error_testpoint;
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();
*/
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;
}
/*
.count = 0,
};
- health_register(health_sessiond, HEALTH_TYPE_APP_REG_DISPATCH);
+ health_register(health_sessiond, HEALTH_SESSIOND_TYPE_APP_REG_DISPATCH);
health_code_update();
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);
}
DBG("[thread] Manage application registration started");
- health_register(health_sessiond, HEALTH_TYPE_APP_REG);
+ health_register(health_sessiond, HEALTH_SESSIOND_TYPE_APP_REG);
if (testpoint(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.
"lttng-consumerd", verbosity, "-k",
"--consumerd-cmd-sock", consumer_data->cmd_unix_sock_path,
"--consumerd-err-sock", consumer_data->err_unix_sock_path,
+ "--group", tracing_group_name,
NULL);
break;
case LTTNG_CONSUMER64_UST:
ret = execl(consumerd64_bin, "lttng-consumerd", verbosity, "-u",
"--consumerd-cmd-sock", consumer_data->cmd_unix_sock_path,
"--consumerd-err-sock", consumer_data->err_unix_sock_path,
+ "--group", tracing_group_name,
NULL);
if (consumerd64_libdir[0] != '\0') {
free(tmpnew);
ret = execl(consumerd32_bin, "lttng-consumerd", verbosity, "-u",
"--consumerd-cmd-sock", consumer_data->cmd_unix_sock_path,
"--consumerd-err-sock", consumer_data->err_unix_sock_path,
+ "--group", tracing_group_name,
NULL);
if (consumerd32_libdir[0] != '\0') {
free(tmpnew);
return ret;
}
-/*
- * Compute health status of each consumer. If one of them is zero (bad
- * state), we return 0.
- */
-static int check_consumer_health(void)
-{
- int ret;
-
- ret = health_check_state(health_sessiond, HEALTH_TYPE_CONSUMER);
-
- DBG3("Health consumer check %d", ret);
-
- return ret;
-}
-
/*
* Setup necessary data for kernel tracer action.
*/
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:
}
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;
break;
}
case LTTNG_ENABLE_EVENT:
+ case LTTNG_ENABLE_EVENT_WITH_EXCLUSION:
+ case LTTNG_ENABLE_EVENT_WITH_FILTER:
{
- 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]);
+ struct lttng_event_exclusion *exclusion = NULL;
+ struct lttng_filter_bytecode *bytecode = NULL;
+
+ if (cmd_ctx->lsm->cmd_type == LTTNG_ENABLE_EVENT ||
+ (cmd_ctx->lsm->u.enable.exclusion_count == 0 && cmd_ctx->lsm->u.enable.bytecode_len == 0)) {
+ 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, NULL, kernel_poll_pipe[1]);
+ } else {
+ if (cmd_ctx->lsm->u.enable.exclusion_count != 0) {
+ exclusion = zmalloc(sizeof(struct lttng_event_exclusion) +
+ cmd_ctx->lsm->u.enable.exclusion_count * LTTNG_SYMBOL_NAME_LEN);
+ if (!exclusion) {
+ ret = LTTNG_ERR_EXCLUSION_NOMEM;
+ goto error;
+ }
+ DBG("Receiving var len data from client ...");
+ exclusion->count = cmd_ctx->lsm->u.enable.exclusion_count;
+ ret = lttcomm_recv_unix_sock(sock, exclusion->names,
+ cmd_ctx->lsm->u.enable.exclusion_count * LTTNG_SYMBOL_NAME_LEN);
+ if (ret <= 0) {
+ DBG("Nothing recv() from client var len data... continuing");
+ *sock_error = 1;
+ ret = LTTNG_ERR_EXCLUSION_INVAL;
+ goto error;
+ }
+ }
+ if (cmd_ctx->lsm->u.enable.bytecode_len != 0) {
+ bytecode = zmalloc(cmd_ctx->lsm->u.enable.bytecode_len);
+ if (!bytecode) {
+ if (!exclusion)
+ free(exclusion);
+ 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 car len data... continuing");
+ *sock_error = 1;
+ if (!exclusion)
+ free(exclusion);
+ ret = LTTNG_ERR_FILTER_INVAL;
+ goto error;
+ }
+
+ if (bytecode->len + sizeof(*bytecode)
+ != cmd_ctx->lsm->u.enable.bytecode_len) {
+ free(bytecode);
+ if (!exclusion)
+ 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, bytecode,
+ exclusion,
+ kernel_poll_pipe[1]);
+ }
break;
}
case LTTNG_ENABLE_ALL_EVENT:
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);
int sock = -1, new_sock = -1, ret, i, pollfd, err = -1;
uint32_t revents, nb_fd;
struct lttng_poll_event events;
- struct lttcomm_health_msg msg;
- struct lttcomm_health_data reply;
+ struct health_comm_msg msg;
+ struct health_comm_reply reply;
DBG("[thread] Manage health check started");
goto error;
}
+ if (is_root) {
+ /* lttng health client socket path permissions */
+ ret = chown(health_unix_sock_path, 0,
+ utils_get_group_id(tracing_group_name));
+ if (ret < 0) {
+ ERR("Unable to set group on %s", health_unix_sock_path);
+ PERROR("chown");
+ ret = -1;
+ goto error;
+ }
+
+ ret = chmod(health_unix_sock_path,
+ S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP);
+ if (ret < 0) {
+ ERR("Unable to set permissions on %s", health_unix_sock_path);
+ PERROR("chmod");
+ ret = -1;
+ goto error;
+ }
+ }
+
/*
* Set the CLOEXEC flag. Return code is useless because either way, the
* show must go on.
rcu_thread_online();
- switch (msg.component) {
- case LTTNG_HEALTH_CMD:
- reply.ret_code = health_check_state(health_sessiond, HEALTH_TYPE_CMD);
- break;
- case LTTNG_HEALTH_APP_MANAGE:
- reply.ret_code = health_check_state(health_sessiond, HEALTH_TYPE_APP_MANAGE);
- break;
- case LTTNG_HEALTH_APP_REG:
- reply.ret_code = health_check_state(health_sessiond, HEALTH_TYPE_APP_REG);
- break;
- case LTTNG_HEALTH_KERNEL:
- reply.ret_code = health_check_state(health_sessiond, HEALTH_TYPE_KERNEL);
- break;
- case LTTNG_HEALTH_CONSUMER:
- reply.ret_code = check_consumer_health();
- break;
- case LTTNG_HEALTH_HT_CLEANUP:
- reply.ret_code = health_check_state(health_sessiond, HEALTH_TYPE_HT_CLEANUP);
- break;
- case LTTNG_HEALTH_APP_MANAGE_NOTIFY:
- reply.ret_code = health_check_state(health_sessiond, HEALTH_TYPE_APP_MANAGE_NOTIFY);
- break;
- case LTTNG_HEALTH_APP_REG_DISPATCH:
- reply.ret_code = health_check_state(health_sessiond, HEALTH_TYPE_APP_REG_DISPATCH);
- break;
- case LTTNG_HEALTH_ALL:
- reply.ret_code =
- health_check_state(health_sessiond, HEALTH_TYPE_APP_MANAGE) &&
- health_check_state(health_sessiond, HEALTH_TYPE_APP_REG) &&
- health_check_state(health_sessiond, HEALTH_TYPE_CMD) &&
- health_check_state(health_sessiond, HEALTH_TYPE_KERNEL) &&
- check_consumer_health() &&
- health_check_state(health_sessiond, HEALTH_TYPE_HT_CLEANUP) &&
- health_check_state(health_sessiond, HEALTH_TYPE_APP_MANAGE_NOTIFY) &&
- health_check_state(health_sessiond, HEALTH_TYPE_APP_REG_DISPATCH);
- break;
- default:
- reply.ret_code = LTTNG_ERR_UND;
- break;
- }
-
- /*
- * Flip ret value since 0 is a success and 1 indicates a bad health for
- * the client where in the sessiond it is the opposite. Again, this is
- * just to make things easier for us poor developer which enjoy a lot
- * lazyness.
- */
- if (reply.ret_code == 0 || reply.ret_code == 1) {
- reply.ret_code = !reply.ret_code;
+ reply.ret_code = 0;
+ for (i = 0; i < NR_HEALTH_SESSIOND_TYPES; i++) {
+ /*
+ * health_check_state returns 0 if health is
+ * bad.
+ */
+ if (!health_check_state(health_sessiond, i)) {
+ reply.ret_code |= 1ULL << i;
+ }
}
- DBG2("Health check return value %d", reply.ret_code);
+ DBG2("Health check return value %" PRIx64, reply.ret_code);
ret = send_unix_sock(new_sock, (void *) &reply, sizeof(reply));
if (ret < 0) {
rcu_register_thread();
- health_register(health_sessiond, HEALTH_TYPE_CMD);
+ health_register(health_sessiond, HEALTH_SESSIOND_TYPE_CMD);
if (testpoint(thread_manage_clients)) {
goto error_testpoint;
/*
* 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) {
+ kill(child_ppid, SIGUSR1);
+ }
+
if (testpoint(thread_manage_clients_before_loop)) {
goto error;
}
fprintf(stderr, " -d, --daemonize Start as a daemon.\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");
}
/*
{ "verbose-consumer", 0, 0, 'Z' },
{ "no-kernel", 0, 0, 'N' },
{ "pidfile", 1, 0, 'p' },
+ { "jul-tcp-port", 1, 0, 'J' },
{ NULL, 0, 0, 0 }
};
while (1) {
int option_index = 0;
- c = getopt_long(argc, argv, "dhqvVSN" "a:c:g:s:C:E:D:F:Z:u:t:p:",
+ c = getopt_long(argc, argv, "dhqvVSN" "a:c:g:s:C:E:D:F:Z:u:t:p:J:",
long_options, &option_index);
if (c == -1) {
break;
opt_daemon = 1;
break;
case 'g':
- opt_tracing_group = optarg;
+ tracing_group_name = optarg;
break;
case 'h':
usage();
case 'p':
opt_pidfile = optarg;
break;
+ case 'J': /* JUL TCP port. */
+ {
+ unsigned long v;
+
+ errno = 0;
+ v = strtoul(optarg, NULL, 0);
+ if (errno != 0 || !isdigit(optarg[0])) {
+ ERR("Wrong value in --jul-tcp-port parameter: %s", optarg);
+ return -1;
+ }
+ if (v == 0 || v >= 65535) {
+ ERR("Port overflow in --jul-tcp-port parameter: %s", optarg);
+ 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 */
int ret;
gid_t gid;
- ret = allowed_group();
- if (ret < 0) {
- WARN("No tracing group detected");
- /* Setting gid to 0 if no tracing group is found */
- gid = 0;
- } else {
- gid = ret;
- }
+ gid = utils_get_group_id(tracing_group_name);
/* Set lttng run dir */
ret = chown(rundir, 0, gid);
PERROR("chown");
}
- /* Ensure all applications and tracing group can search the run dir */
- ret = chmod(rundir, S_IRWXU | S_IXGRP | S_IXOTH);
+ /*
+ * Ensure all applications and tracing group can search the run
+ * dir. Allow everyone to read the directory, since it does not
+ * buy us anything to hide its content.
+ */
+ ret = chmod(rundir, S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH);
if (ret < 0) {
ERR("Unable to set permissions on %s", rundir);
PERROR("chmod");
}
/* kconsumer error socket path */
- ret = chown(kconsumer_data.err_unix_sock_path, 0, gid);
+ ret = chown(kconsumer_data.err_unix_sock_path, 0, 0);
if (ret < 0) {
ERR("Unable to set group on %s", kconsumer_data.err_unix_sock_path);
PERROR("chown");
}
/* 64-bit ustconsumer error socket path */
- ret = chown(ustconsumer64_data.err_unix_sock_path, 0, gid);
+ ret = chown(ustconsumer64_data.err_unix_sock_path, 0, 0);
if (ret < 0) {
ERR("Unable to set group on %s", ustconsumer64_data.err_unix_sock_path);
PERROR("chown");
}
/* 32-bit ustconsumer compat32 error socket path */
- ret = chown(ustconsumer32_data.err_unix_sock_path, 0, gid);
+ ret = chown(ustconsumer32_data.err_unix_sock_path, 0, 0);
if (ret < 0) {
ERR("Unable to set group on %s", ustconsumer32_data.err_unix_sock_path);
PERROR("chown");
int ret;
char path[PATH_MAX];
- switch (consumer_data->type) {
+ switch (consumer_data->type) {
case LTTNG_CONSUMER_KERNEL:
snprintf(path, PATH_MAX, DEFAULT_KCONSUMERD_PATH, rundir);
break;
DBG2("Creating consumer directory: %s", path);
- ret = mkdir(path, S_IRWXU);
+ ret = mkdir(path, S_IRWXU | S_IRGRP | S_IXGRP);
if (ret < 0) {
if (errno != EEXIST) {
PERROR("mkdir");
}
ret = -1;
}
+ if (is_root) {
+ ret = chown(path, 0, utils_get_group_id(tracing_group_name));
+ if (ret < 0) {
+ ERR("Unable to set group on %s", path);
+ PERROR("chown");
+ goto error;
+ }
+ }
/* Create the kconsumerd error unix socket */
consumer_data->err_sock =
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;
+}
+
+/*
+ * Daemonize this process by forking and making the parent wait for the child
+ * to signal it indicating readiness. Once received, the parent successfully
+ * quits.
+ *
+ * The child process undergoes the same action that daemon(3) does meaning
+ * setsid, chdir, and dup /dev/null into 0, 1 and 2.
+ *
+ * Return 0 on success else -1 on error.
+ */
+static int daemonize(void)
+{
+ int ret;
+ pid_t pid;
+
+ /* Get parent pid of this process. */
+ child_ppid = getppid();
+
+ pid = fork();
+ if (pid < 0) {
+ PERROR("fork");
+ goto error;
+ } else if (pid == 0) {
+ int fd;
+ pid_t sid;
+
+ /* Child */
+
+ /*
+ * Get the newly created parent pid so we can signal that process when
+ * we are ready to operate.
+ */
+ child_ppid = getppid();
+
+ sid = setsid();
+ if (sid < 0) {
+ PERROR("setsid");
+ goto error;
+ }
+
+ /* Try to change directory to /. If we can't well at least notify. */
+ ret = chdir("/");
+ if (ret < 0) {
+ PERROR("chdir");
+ }
+
+ fd = open(_PATH_DEVNULL, O_RDWR, 0);
+ if (fd < 0) {
+ PERROR("open %s", _PATH_DEVNULL);
+ /* Let 0, 1 and 2 open since we can't bind them to /dev/null. */
+ } else {
+ (void) dup2(fd, STDIN_FILENO);
+ (void) dup2(fd, STDOUT_FILENO);
+ (void) dup2(fd, STDERR_FILENO);
+ if (fd > 2) {
+ ret = close(fd);
+ if (ret < 0) {
+ PERROR("close");
+ }
+ }
+ }
+ goto end;
+ } else {
+ /* Parent */
+
+ /*
+ * Waiting for child to notify this parent that it can exit. Note that
+ * sleep() is interrupted before the 1 second delay as soon as the
+ * signal is received, so it will not cause visible delay for the
+ * user.
+ */
+ while (!CMM_LOAD_SHARED(recv_child_signal)) {
+ sleep(1);
+ }
+
+ /*
+ * From this point on, the parent can exit and the child is now an
+ * operationnal session daemon ready to serve clients and applications.
+ */
+ exit(EXIT_SUCCESS);
+ }
+
+end:
+ return 0;
+
+error:
+ return -1;
+}
+
/*
* main
*/
rcu_register_thread();
+ if ((ret = set_signal_handler()) < 0) {
+ goto error;
+ }
+
setup_consumerd_path();
page_size = sysconf(_SC_PAGESIZE);
if (opt_daemon) {
int i;
- /*
- * fork
- * child: setsid, close FD 0, 1, 2, chdir /
- * parent: exit (if fork is successful)
- */
- ret = daemon(0, 0);
+ ret = daemonize();
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();
* Initialize the health check subsystem. This call should set the
* appropriate time values.
*/
- health_sessiond = health_app_create(HEALTH_NUM_TYPE);
+ health_sessiond = health_app_create(NR_HEALTH_SESSIOND_TYPES);
if (!health_sessiond) {
PERROR("health_app_create error");
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");