static int opt_daemon;
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 char *rundir;
/* Consumer daemon specific control data */
static struct consumer_data kconsumer_data = {
DBG("Cleaning up");
- if (is_root) {
- DBG("Removing %s directory", LTTNG_RUNDIR);
- ret = asprintf(&cmd, "rm -rf " LTTNG_RUNDIR);
- if (ret < 0) {
- ERR("asprintf failed. Something is really wrong!");
- }
+ DBG("Removing %s directory", rundir);
+ ret = asprintf(&cmd, "rm -rf %s", rundir);
+ if (ret < 0) {
+ ERR("asprintf failed. Something is really wrong!");
+ }
- /* Remove lttng run directory */
- ret = system(cmd);
- if (ret < 0) {
- ERR("Unable to clean " LTTNG_RUNDIR);
- }
+ /* Remove lttng run directory */
+ ret = system(cmd);
+ if (ret < 0) {
+ ERR("Unable to clean %s", rundir);
}
+ free(cmd);
DBG("Cleaning up all session");
switch (consumer_data->type) {
case LTTNG_CONSUMER_KERNEL:
/*
- * Find out which consumerd to execute. We will first
- * try the 64-bit path, then the 32-bit one, then
- * fallback on sessiond's installation directory.
+ * Find out which consumerd to execute. We will
+ * first try the 64-bit path, then the
+ * sessiond's installation directory, and
+ * fallback on the 32-bit one,
*/
if (stat(consumerd64_bin, &st) == 0) {
consumer_to_use = consumerd64_bin;
- } else if (stat(consumerd32_bin, &st) == 0) {
- consumer_to_use = consumerd32_bin;
} else if (stat(INSTALL_BIN_PATH "/" CONSUMERD_FILE, &st) == 0) {
consumer_to_use = INSTALL_BIN_PATH "/" CONSUMERD_FILE;
+ } else if (stat(consumerd32_bin, &st) == 0) {
+ consumer_to_use = consumerd32_bin;
} else {
break;
}
}
}
DBG("Using 64-bit UST consumer at: %s", consumerd64_bin);
- ret = execl(consumerd64_bin, verbosity, "-u",
+ 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,
NULL);
}
}
DBG("Using 32-bit UST consumer at: %s", consumerd32_bin);
- ret = execl(consumerd32_bin, verbosity, "-u",
+ 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,
NULL);
tmp[i].type = LTTNG_EVENT_FUNCTION;
break;
case LTTNG_UST_TRACEPOINT_LOGLEVEL:
- /* TODO */
- ret = -LTTCOMM_NOT_IMPLEMENTED;
- goto error;
+ tmp[i].type = LTTNG_EVENT_TRACEPOINT_LOGLEVEL;
break;
}
i++;
case LTTNG_DOMAIN_UST:
{
struct ltt_ust_channel *uchan;
+ struct cds_lfht *chan_ht;
- /* Get channel in global UST domain HT */
- uchan = trace_ust_find_channel_by_name(usess->domain_global.channels,
- channel_name);
+ chan_ht = usess->domain_global.channels;
+
+ uchan = trace_ust_find_channel_by_name(chan_ht, channel_name);
if (uchan == NULL) {
ret = LTTCOMM_UST_CHAN_NOT_FOUND;
goto error;
}
- /* Already disabled */
- if (!uchan->enabled) {
- DBG2("UST channel %s already disabled", channel_name);
- break;
- }
-
- ret = ust_app_disable_channel_glb(usess, uchan);
- if (ret < 0) {
- ret = LTTCOMM_UST_DISABLE_FAIL;
+ ret = channel_ust_disable(usess, domain, uchan);
+ if (ret != LTTCOMM_OK) {
goto error;
}
-
- uchan->enabled = 0;
-
break;
}
case LTTNG_DOMAIN_UST_PID_FOLLOW_CHILDREN:
return ret;
}
-/*
- * Copy channel from attributes and set it in the application channel list.
- */
-/*
-static int copy_ust_channel_to_app(struct ltt_ust_session *usess,
- struct lttng_channel *attr, struct ust_app *app)
-{
- int ret;
- struct ltt_ust_channel *uchan, *new_chan;
-
- uchan = trace_ust_get_channel_by_key(usess->channels, attr->name);
- if (uchan == NULL) {
- ret = LTTCOMM_FATAL;
- goto error;
- }
-
- new_chan = trace_ust_create_channel(attr, usess->path);
- if (new_chan == NULL) {
- PERROR("malloc ltt_ust_channel");
- ret = LTTCOMM_FATAL;
- goto error;
- }
-
- ret = channel_ust_copy(new_chan, uchan);
- if (ret < 0) {
- ret = LTTCOMM_FATAL;
- goto error;
- }
-
-error:
- return ret;
-}
-*/
-
/*
* Command LTTNG_ENABLE_CHANNEL processed by the client thread.
*/
{
int ret;
struct ltt_ust_session *usess = session->ust_session;
+ struct cds_lfht *chan_ht;
DBG("Enabling channel %s for session %s", attr->name, session->name);
{
struct ltt_ust_channel *uchan;
- DBG2("Enabling channel for LTTNG_DOMAIN_UST");
+ chan_ht = usess->domain_global.channels;
- /* Get channel in global UST domain HT */
- uchan = trace_ust_find_channel_by_name(usess->domain_global.channels,
- attr->name);
+ uchan = trace_ust_find_channel_by_name(chan_ht, attr->name);
if (uchan == NULL) {
- uchan = trace_ust_create_channel(attr, usess->pathname);
- if (uchan == NULL) {
- ret = LTTCOMM_UST_CHAN_FAIL;
- goto error;
- }
-
- /* Add channel to all registered applications */
- ret = ust_app_create_channel_glb(usess, uchan);
- if (ret != 0) {
- ret = LTTCOMM_UST_CHAN_FAIL;
- goto error;
- }
-
- rcu_read_lock();
- hashtable_add_unique(usess->domain_global.channels, &uchan->node);
- rcu_read_unlock();
-
- DBG2("UST channel %s added to global domain HT", attr->name);
+ ret = channel_ust_create(usess, domain, attr);
} else {
- /* If already enabled, everything is OK */
- if (uchan->enabled) {
- break;
- }
-
- ret = ust_app_enable_channel_glb(usess, uchan);
- if (ret < 0) {
- if (ret != -EEXIST) {
- ret = LTTCOMM_UST_CHAN_ENABLE_FAIL;
- goto error;
- } else {
- ret = LTTCOMM_OK;
- }
- }
+ ret = channel_ust_enable(usess, domain, uchan);
}
-
- uchan->enabled = 1;
-
break;
}
case LTTNG_DOMAIN_UST_PID_FOLLOW_CHILDREN:
goto error;
}
- ret = LTTCOMM_OK;
-
error:
return ret;
}
}
case LTTNG_DOMAIN_UST:
{
- struct ltt_ust_session *usess;
struct ltt_ust_channel *uchan;
- struct ltt_ust_event *uevent;
+ struct ltt_ust_session *usess;
usess = session->ust_session;
goto error;
}
- uevent = trace_ust_find_event_by_name(uchan->events, event_name);
- if (uevent == NULL) {
- ret = LTTCOMM_UST_EVENT_NOT_FOUND;
- goto error;
- }
-
- ret = ust_app_disable_event_glb(usess, uchan, uevent);
- if (ret < 0) {
- ret = LTTCOMM_UST_DISABLE_FAIL;
+ ret = event_ust_disable_tracepoint(usess, domain, uchan, event_name);
+ if (ret != LTTCOMM_OK) {
goto error;
}
- uevent->enabled = 0;
-
- DBG2("Disable UST event %s in channel %s completed", event_name,
+ DBG3("Disable UST event %s in channel %s completed", event_name,
channel_name);
-
break;
}
case LTTNG_DOMAIN_UST_EXEC_NAME:
goto error;
}
- ret = ust_app_disable_all_event_glb(usess, uchan);
- if (ret < 0) {
- ret = LTTCOMM_UST_DISABLE_FAIL;
+ ret = event_ust_disable_all_tracepoints(usess, domain, uchan);
+ if (ret != 0) {
goto error;
}
- DBG2("Disable all UST event in channel %s completed", channel_name);
+ DBG3("Disable all UST events in channel %s completed", channel_name);
break;
}
/*
* Command LTTNG_ENABLE_EVENT processed by the client thread.
+ *
+ * TODO: currently, both events and loglevels are kept within the same
+ * namespace for UST global registry/app registery, so if an event
+ * happen to have the same name as the loglevel (very unlikely though),
+ * and an attempt is made to enable/disable both in the same session,
+ * the first to be created will be the only one allowed to exist.
*/
static int cmd_enable_event(struct ltt_session *session, int domain,
char *channel_name, struct lttng_event *event)
snprintf(attr->name, NAME_MAX, "%s", channel_name);
attr->name[NAME_MAX - 1] = '\0';
- /* Use the internal command enable channel */
- ret = cmd_enable_channel(session, domain, attr);
+ ret = channel_ust_create(usess, domain, attr);
if (ret != LTTCOMM_OK) {
free(attr);
goto error;
}
switch (event_type) {
- case LTTNG_KERNEL_SYSCALL:
+ case LTTNG_EVENT_SYSCALL:
ret = event_kernel_enable_all_syscalls(session->kernel_session,
kchan, kernel_tracer_fd);
break;
- case LTTNG_KERNEL_TRACEPOINT:
+ case LTTNG_EVENT_TRACEPOINT:
/*
* This call enables all LTTNG_KERNEL_TRACEPOINTS and
* events already registered to the channel.
ret = event_kernel_enable_all_tracepoints(session->kernel_session,
kchan, kernel_tracer_fd);
break;
- case LTTNG_KERNEL_ALL:
+ case LTTNG_EVENT_ALL:
/* Enable syscalls and tracepoints */
ret = event_kernel_enable_all(session->kernel_session,
kchan, kernel_tracer_fd);
kernel_wait_quiescent(kernel_tracer_fd);
break;
+ case LTTNG_DOMAIN_UST:
+ {
+ struct lttng_channel *attr;
+ struct ltt_ust_channel *uchan;
+ struct ltt_ust_session *usess = session->ust_session;
+
+ /* Get channel from global UST domain */
+ uchan = trace_ust_find_channel_by_name(usess->domain_global.channels,
+ channel_name);
+ if (uchan == NULL) {
+ /* Create default channel */
+ attr = channel_new_default_attr(domain);
+ if (attr == NULL) {
+ ret = LTTCOMM_FATAL;
+ goto error;
+ }
+ snprintf(attr->name, NAME_MAX, "%s", channel_name);
+ attr->name[NAME_MAX - 1] = '\0';
+
+ /* Use the internal command enable channel */
+ ret = channel_ust_create(usess, domain, attr);
+ if (ret != LTTCOMM_OK) {
+ free(attr);
+ goto error;
+ }
+ free(attr);
+
+ /* Get the newly created channel reference back */
+ uchan = trace_ust_find_channel_by_name(
+ usess->domain_global.channels, channel_name);
+ if (uchan == NULL) {
+ /* Something is really wrong */
+ ret = LTTCOMM_FATAL;
+ goto error;
+ }
+ }
+
+ /* At this point, the session and channel exist on the tracer */
+
+ switch (event_type) {
+ case LTTNG_EVENT_ALL:
+ case LTTNG_EVENT_TRACEPOINT:
+ ret = event_ust_enable_all_tracepoints(usess, domain, uchan);
+ if (ret != LTTCOMM_OK) {
+ goto error;
+ }
+ break;
+ default:
+ ret = LTTCOMM_UST_ENABLE_FAIL;
+ goto error;
+ }
+
+ /* Manage return value */
+ if (ret != LTTCOMM_OK) {
+ goto error;
+ }
+
+ break;
+ }
+ case LTTNG_DOMAIN_UST_EXEC_NAME:
+ case LTTNG_DOMAIN_UST_PID:
+ case LTTNG_DOMAIN_UST_PID_FOLLOW_CHILDREN:
default:
- /* TODO: Userspace tracing */
ret = LTTCOMM_NOT_IMPLEMENTED;
goto error;
}
ksession = session->kernel_session;
usess = session->ust_session;
- if (session->enabled)
- return LTTCOMM_UST_START_FAIL;
+ if (session->enabled) {
+ ret = LTTCOMM_UST_START_FAIL;
+ goto error;
+ }
+
session->enabled = 1;
/* Kernel tracing */
ksession = session->kernel_session;
usess = session->ust_session;
- if (!session->enabled)
- return LTTCOMM_UST_START_FAIL;
+ if (!session->enabled) {
+ ret = LTTCOMM_UST_START_FAIL;
+ goto error;
+ }
+
session->enabled = 0;
/* Kernel tracer */
switch (domain) {
case LTTNG_DOMAIN_KERNEL:
/* Can't register a consumer if there is already one */
- if (session->kernel_session->consumer_fd != 0) {
+ if (session->kernel_session->consumer_fds_sent != 0) {
ret = LTTCOMM_KERN_CONSUMER_FAIL;
goto error;
}
/*
* Create the lttng run directory needed for all global sockets and pipe.
*/
-static int create_lttng_rundir(void)
+static int create_lttng_rundir(const char *rundir)
{
int ret;
- ret = mkdir(LTTNG_RUNDIR, S_IRWXU | S_IRWXG );
+ DBG3("Creating LTTng run directory: %s", rundir);
+
+ ret = mkdir(rundir, S_IRWXU | S_IRWXG );
if (ret < 0) {
if (errno != EEXIST) {
- ERR("Unable to create " LTTNG_RUNDIR);
+ ERR("Unable to create %s", rundir);
goto error;
} else {
ret = 0;
* Setup sockets and directory needed by the kconsumerd communication with the
* session daemon.
*/
-static int set_consumer_sockets(struct consumer_data *consumer_data)
+static int set_consumer_sockets(struct consumer_data *consumer_data,
+ const char *rundir)
{
int ret;
- const char *path;
+ char path[PATH_MAX];
- switch (consumer_data->type) {
+ switch (consumer_data->type) {
case LTTNG_CONSUMER_KERNEL:
- path = KCONSUMERD_PATH;
+ snprintf(path, PATH_MAX, KCONSUMERD_PATH, rundir);
break;
case LTTNG_CONSUMER64_UST:
- path = USTCONSUMERD64_PATH;
+ snprintf(path, PATH_MAX, USTCONSUMERD64_PATH, rundir);
break;
case LTTNG_CONSUMER32_UST:
- path = USTCONSUMERD32_PATH;
+ snprintf(path, PATH_MAX, USTCONSUMERD32_PATH, rundir);
break;
default:
ERR("Consumer type unknown");
goto error;
}
+ DBG2("Creating consumer directory: %s", path);
+
ret = mkdir(path, S_IRWXU | S_IRWXG);
if (ret < 0) {
if (errno != EEXIST) {
S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP);
if (ret < 0) {
ERR("Set file permissions failed: %s", consumer_data->err_unix_sock_path);
- perror("chmod");
+ PERROR("chmod");
goto error;
}
is_root = !getuid();
if (is_root) {
- ret = create_lttng_rundir();
+ rundir = strdup(LTTNG_RUNDIR);
+
+ /* Create global run dir with root access */
+ ret = create_lttng_rundir(rundir);
if (ret < 0) {
goto error;
}
snprintf(wait_shm_path, PATH_MAX,
DEFAULT_GLOBAL_APPS_WAIT_SHM_PATH);
}
+
+ /* Setup kernel consumerd path */
+ snprintf(kconsumer_data.err_unix_sock_path, PATH_MAX,
+ KCONSUMERD_ERR_SOCK_PATH, rundir);
+ snprintf(kconsumer_data.cmd_unix_sock_path, PATH_MAX,
+ KCONSUMERD_CMD_SOCK_PATH, rundir);
+
+ DBG2("Kernel consumer err path: %s",
+ kconsumer_data.err_unix_sock_path);
+ DBG2("Kernel consumer cmd path: %s",
+ kconsumer_data.cmd_unix_sock_path);
} else {
home_path = get_home_dir();
if (home_path == NULL) {
goto error;
}
+ /*
+ * Create rundir from home path. This will create something like
+ * $HOME/.lttng
+ */
+ ret = asprintf(&rundir, LTTNG_HOME_RUNDIR, home_path);
+ if (ret < 0) {
+ ret = -ENOMEM;
+ goto error;
+ }
+
+ ret = create_lttng_rundir(rundir);
+ if (ret < 0) {
+ goto error;
+ }
+
if (strlen(apps_unix_sock_path) == 0) {
snprintf(apps_unix_sock_path, PATH_MAX,
DEFAULT_HOME_APPS_UNIX_SOCK, home_path);
DBG("Client socket path %s", client_unix_sock_path);
DBG("Application socket path %s", apps_unix_sock_path);
+ DBG("LTTng run directory path: %s", rundir);
+
+ /* 32 bits consumerd path setup */
+ snprintf(ustconsumer32_data.err_unix_sock_path, PATH_MAX,
+ USTCONSUMERD32_ERR_SOCK_PATH, rundir);
+ snprintf(ustconsumer32_data.cmd_unix_sock_path, PATH_MAX,
+ USTCONSUMERD32_CMD_SOCK_PATH, rundir);
+
+ DBG2("UST consumer 32 bits err path: %s",
+ ustconsumer32_data.err_unix_sock_path);
+ DBG2("UST consumer 32 bits cmd path: %s",
+ ustconsumer32_data.cmd_unix_sock_path);
+
+ /* 64 bits consumerd path setup */
+ snprintf(ustconsumer64_data.err_unix_sock_path, PATH_MAX,
+ USTCONSUMERD64_ERR_SOCK_PATH, rundir);
+ snprintf(ustconsumer64_data.cmd_unix_sock_path, PATH_MAX,
+ USTCONSUMERD64_CMD_SOCK_PATH, rundir);
+
+ DBG2("UST consumer 64 bits err path: %s",
+ ustconsumer64_data.err_unix_sock_path);
+ DBG2("UST consumer 64 bits cmd path: %s",
+ ustconsumer64_data.cmd_unix_sock_path);
/*
* See if daemon already exist.
* kernel tracer.
*/
if (is_root) {
- ret = set_consumer_sockets(&kconsumer_data);
- if (ret < 0) {
- goto exit;
- }
-
- ret = set_consumer_sockets(&ustconsumer64_data);
- if (ret < 0) {
- goto exit;
- }
-
- ret = set_consumer_sockets(&ustconsumer32_data);
+ ret = set_consumer_sockets(&kconsumer_data, rundir);
if (ret < 0) {
goto exit;
}
set_ulimit();
}
+ ret = set_consumer_sockets(&ustconsumer64_data, rundir);
+ if (ret < 0) {
+ goto exit;
+ }
+
+ ret = set_consumer_sockets(&ustconsumer32_data, rundir);
+ if (ret < 0) {
+ goto exit;
+ }
+
if ((ret = set_signal_handler()) < 0) {
goto exit;
}
cleanup();
rcu_thread_offline();
rcu_unregister_thread();
- if (!ret)
+ if (!ret) {
exit(EXIT_SUCCESS);
+ }
error:
exit(EXIT_FAILURE);
}
projects / lttng-tools.git / blobdiff