#include "event.h"
#include "futex.h"
#include "hashtable.h"
-#include "kernel-ctl.h"
+#include "kernel.h"
#include "lttng-sessiond.h"
#include "shm.h"
#include "ust-app.h"
#include "ust-ctl.h"
#include "utils.h"
+#define CONSUMERD_FILE "lttng-consumerd"
+
struct consumer_data {
enum lttng_consumer_type type;
const char *opt_tracing_group;
static int opt_sig_parent;
static int opt_daemon;
+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 char *rundir;
/* Consumer daemon specific control data */
static struct consumer_data kconsumer_data = {
int ust_consumerd64_fd = -1;
int ust_consumerd32_fd = -1;
-static const char *consumerd64_prog = "lttng-consumerd";
-static const char *consumerd32_prog = "lttng-consumerd";
-
-static const char *consumerd64_bindir =
- __stringify(CONFIG_64BIT_BINDIR);
-static const char *consumerd32_bindir =
- __stringify(CONFIG_32BIT_BINDIR);
+static const char *consumerd32_bin =
+ __stringify(CONFIG_CONSUMERD32_BIN);
+static const char *consumerd64_bin =
+ __stringify(CONFIG_CONSUMERD64_BIN);
+static const char *consumerd32_libdir =
+ __stringify(CONFIG_CONSUMERD32_LIBDIR);
+static const char *consumerd64_libdir =
+ __stringify(CONFIG_CONSUMERD64_LIBDIR);
static
void setup_consumerd_path(void)
{
- const char *bindir;
+ const char *bin, *libdir;
/*
* Allow INSTALL_BIN_PATH to be used as a target path for the
- * native architecture size consumer if CONFIG_NBIT_BINDIR as
- * not been defined.
+ * native architecture size consumer if CONFIG_CONSUMER*_PATH
+ * has not been defined.
*/
-#if (CAA_BITS_PER_LONG == 64)
- if (!consumerd64_bindir[0]) {
- consumerd64_bindir = INSTALL_BIN_PATH;
+#if (CAA_BITS_PER_LONG == 32)
+ if (!consumerd32_bin[0]) {
+ consumerd32_bin = INSTALL_BIN_PATH "/" CONSUMERD_FILE;
+ }
+ if (!consumerd32_libdir[0]) {
+ consumerd32_libdir = INSTALL_LIB_PATH;
+ }
+#elif (CAA_BITS_PER_LONG == 64)
+ if (!consumerd64_bin[0]) {
+ consumerd64_bin = INSTALL_BIN_PATH "/" CONSUMERD_FILE;
}
-#elif (CAA_BITS_PER_LONG == 32)
- if (!consumerd32_bindir[0]) {
- consumerd32_bindir = INSTALL_BIN_PATH;
+ if (!consumerd64_libdir[0]) {
+ consumerd64_libdir = INSTALL_LIB_PATH;
}
#else
#error "Unknown bitness"
/*
* runtime env. var. overrides the build default.
*/
- bindir = getenv("LTTNG_TOOLS_64BIT_BINDIR");
- if (bindir) {
- consumerd64_bindir = bindir;
+ bin = getenv("LTTNG_CONSUMERD32_BIN");
+ if (bin) {
+ consumerd32_bin = bin;
}
- bindir = getenv("LTTNG_TOOLS_32BIT_BINDIR");
- if (bindir) {
- consumerd32_bindir = bindir;
+ bin = getenv("LTTNG_CONSUMERD64_BIN");
+ if (bin) {
+ consumerd64_bin = bin;
+ }
+ libdir = getenv("LTTNG_TOOLS_CONSUMERD32_LIBDIR");
+ if (libdir) {
+ consumerd32_libdir = libdir;
+ }
+ libdir = getenv("LTTNG_TOOLS_CONSUMERD64_LIBDIR");
+ if (libdir) {
+ consumerd64_libdir = libdir;
}
}
*/
static void teardown_kernel_session(struct ltt_session *session)
{
- if (!session->kernel_session)
+ if (!session->kernel_session) {
+ DBG3("No kernel session when tearingdown session");
return;
+ }
+
DBG("Tearing down kernel session");
/*
{
int ret;
- if (!session->ust_session)
+ if (!session->ust_session) {
+ DBG3("No UST session when tearingdown session");
return;
+ }
+
DBG("Tearing down UST session(s)");
+
ret = ust_app_destroy_trace_all(session->ust_session);
if (ret) {
ERR("Error in ust_app_destroy_trace_all");
}
+
trace_ust_destroy_session(session->ust_session);
}
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");
pthread_mutex_destroy(&kconsumer_data.pid_mutex);
- DBG("Closing kernel fd");
- close(kernel_tracer_fd);
-
- if (is_root) {
+ if (is_root && !opt_no_kernel) {
+ DBG2("Closing kernel fd");
+ close(kernel_tracer_fd);
DBG("Unloading kernel modules");
modprobe_remove_kernel_modules();
}
close(thread_quit_pipe[1]);
/* <fun> */
- MSG("%c[%d;%dm*** assert failed :-) *** ==> %c[%dm%c[%d;%dm"
+ 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> */
{
int ret;
pid_t pid;
+ const char *consumer_to_use;
const char *verbosity;
+ struct stat st;
DBG("Spawning consumerd");
}
switch (consumer_data->type) {
case LTTNG_CONSUMER_KERNEL:
- execl(INSTALL_BIN_PATH "/lttng-consumerd",
- "lttng-consumerd", verbosity, "-k",
- "--consumerd-cmd-sock", consumer_data->cmd_unix_sock_path,
- "--consumerd-err-sock", consumer_data->err_unix_sock_path,
- NULL);
+ /*
+ * 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(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 kernel consumer at: %s", consumer_to_use);
+ 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,
+ NULL);
break;
case LTTNG_CONSUMER64_UST:
{
- char path[PATH_MAX];
+ char *tmpnew = NULL;
+
+ if (consumerd64_libdir[0] != '\0') {
+ char *tmp;
+ size_t tmplen;
- snprintf(path, PATH_MAX, "%s/%s",
- consumerd64_bindir, consumerd64_prog);
- execl(path, verbosity, "-u",
+ tmp = getenv("LD_LIBRARY_PATH");
+ if (!tmp) {
+ tmp = "";
+ }
+ tmplen = strlen("LD_LIBRARY_PATH=")
+ + strlen(consumerd64_libdir) + 1 /* : */ + strlen(tmp);
+ tmpnew = zmalloc(tmplen + 1 /* \0 */);
+ if (!tmpnew) {
+ ret = -ENOMEM;
+ goto error;
+ }
+ strcpy(tmpnew, "LD_LIBRARY_PATH=");
+ strcat(tmpnew, consumerd64_libdir);
+ if (tmp[0] != '\0') {
+ strcat(tmpnew, ":");
+ strcat(tmpnew, tmp);
+ }
+ ret = putenv(tmpnew);
+ if (ret) {
+ ret = -errno;
+ goto error;
+ }
+ }
+ DBG("Using 64-bit UST consumer at: %s", consumerd64_bin);
+ 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);
+ if (consumerd64_libdir[0] != '\0') {
+ free(tmpnew);
+ }
+ if (ret) {
+ goto error;
+ }
break;
}
case LTTNG_CONSUMER32_UST:
{
- char path[PATH_MAX];
+ char *tmpnew = NULL;
+
+ if (consumerd32_libdir[0] != '\0') {
+ char *tmp;
+ size_t tmplen;
- snprintf(path, PATH_MAX, "%s/%s",
- consumerd32_bindir, consumerd32_prog);
- execl(path, verbosity, "-u",
+ tmp = getenv("LD_LIBRARY_PATH");
+ if (!tmp) {
+ tmp = "";
+ }
+ tmplen = strlen("LD_LIBRARY_PATH=")
+ + strlen(consumerd32_libdir) + 1 /* : */ + strlen(tmp);
+ tmpnew = zmalloc(tmplen + 1 /* \0 */);
+ if (!tmpnew) {
+ ret = -ENOMEM;
+ goto error;
+ }
+ strcpy(tmpnew, "LD_LIBRARY_PATH=");
+ strcat(tmpnew, consumerd32_libdir);
+ if (tmp[0] != '\0') {
+ strcat(tmpnew, ":");
+ strcat(tmpnew, tmp);
+ }
+ ret = putenv(tmpnew);
+ if (ret) {
+ ret = -errno;
+ goto error;
+ }
+ }
+ DBG("Using 32-bit UST consumer at: %s", consumerd32_bin);
+ 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);
+ if (consumerd32_libdir[0] != '\0') {
+ free(tmpnew);
+ }
+ if (ret) {
+ goto error;
+ }
break;
}
default:
perror("start consumer fork");
ret = -errno;
}
+error:
return ret;
}
* Create an UST session and add it to the session ust list.
*/
static int create_ust_session(struct ltt_session *session,
- struct lttng_domain *domain)
+ struct lttng_domain *domain, struct ucred *creds)
{
int ret;
- unsigned int uid;
+ unsigned int sess_uid;
+ gid_t gid;
struct ltt_ust_session *lus = NULL;
switch (domain->type) {
DBG("Creating UST session");
- uid = session->uid;
- lus = trace_ust_create_session(session->path, uid, domain);
+ sess_uid = session->uid;
+ lus = trace_ust_create_session(session->path, sess_uid, domain);
if (lus == NULL) {
ret = LTTCOMM_UST_SESS_FAIL;
goto error;
}
- ret = mkdir_recursive(lus->pathname, S_IRWXU | S_IRWXG,
- geteuid(), allowed_group());
+ /*
+ * Get the right group ID. To use the tracing group, the daemon must be
+ * running with root credentials or else it's the user GID used.
+ */
+ gid = allowed_group();
+ if (gid < 0 || !is_root) {
+ gid = creds->gid;
+ }
+
+ ret = mkdir_recursive(lus->pathname, S_IRWXU | S_IRWXG, creds->uid, gid);
if (ret < 0) {
if (ret != -EEXIST) {
ERR("Trace directory creation error");
/*
* Create a kernel tracer session then create the default channel.
*/
-static int create_kernel_session(struct ltt_session *session)
+static int create_kernel_session(struct ltt_session *session,
+ struct ucred *creds)
{
int ret;
+ gid_t gid;
DBG("Creating kernel session");
session->kernel_session->consumer_fd = kconsumer_data.cmd_sock;
}
+ gid = allowed_group();
+ if (gid < 0) {
+ /*
+ * Use GID 0 has a fallback since kernel session is only allowed under
+ * root or the gid of the calling user
+ */
+ is_root ? (gid = 0) : (gid = creds->gid);
+ }
+
ret = mkdir_recursive(session->kernel_session->trace_path,
- S_IRWXU | S_IRWXG, geteuid(), allowed_group());
+ S_IRWXU | S_IRWXG, creds->uid, gid);
if (ret < 0) {
if (ret != -EEXIST) {
ERR("Trace directory creation error");
uchan->attr.switch_timer_interval;
channels[i].attr.read_timer_interval =
uchan->attr.read_timer_interval;
- channels[i].attr.output = uchan->attr.output;
+ channels[i].enabled = uchan->enabled;
+ switch (uchan->attr.output) {
+ case LTTNG_UST_MMAP:
+ default:
+ channels[i].attr.output = LTTNG_EVENT_MMAP;
+ break;
+ }
i++;
}
break;
int i = 0, ret = 0;
unsigned int nb_event = 0;
struct cds_lfht_iter iter;
+ struct cds_lfht_node *node;
struct ltt_ust_channel *uchan;
struct ltt_ust_event *uevent;
struct lttng_event *tmp;
rcu_read_lock();
- /* Count events in all channels */
- cds_lfht_for_each_entry(ust_global->channels, &iter, uchan, node) {
- nb_event += hashtable_get_count(uchan->events);
+ node = hashtable_lookup(ust_global->channels, (void *) channel_name,
+ strlen(channel_name), &iter);
+ if (node == NULL) {
+ ret = -LTTCOMM_UST_CHAN_NOT_FOUND;
+ goto error;
}
+ uchan = caa_container_of(node, struct ltt_ust_channel, node);
+
+ nb_event += hashtable_get_count(uchan->events);
+
if (nb_event == 0) {
ret = nb_event;
goto error;
goto error;
}
- cds_lfht_for_each_entry(ust_global->channels, &iter, uchan, node) {
- cds_lfht_for_each_entry(uchan->events, &iter, uevent, node) {
- strncpy(tmp[i].name, uevent->attr.name, LTTNG_SYMBOL_NAME_LEN);
- tmp[i].name[LTTNG_SYMBOL_NAME_LEN - 1] = '\0';
- tmp[i].enabled = uevent->enabled;
- switch (uevent->attr.instrumentation) {
- case LTTNG_UST_TRACEPOINT:
- tmp[i].type = LTTNG_EVENT_TRACEPOINT;
- break;
- case LTTNG_UST_PROBE:
- tmp[i].type = LTTNG_EVENT_PROBE;
- break;
- case LTTNG_UST_FUNCTION:
- tmp[i].type = LTTNG_EVENT_FUNCTION;
- break;
- }
- i++;
+ cds_lfht_for_each_entry(uchan->events, &iter, uevent, node) {
+ strncpy(tmp[i].name, uevent->attr.name, LTTNG_SYMBOL_NAME_LEN);
+ tmp[i].name[LTTNG_SYMBOL_NAME_LEN - 1] = '\0';
+ tmp[i].enabled = uevent->enabled;
+ switch (uevent->attr.instrumentation) {
+ case LTTNG_UST_TRACEPOINT:
+ tmp[i].type = LTTNG_EVENT_TRACEPOINT;
+ break;
+ case LTTNG_UST_PROBE:
+ tmp[i].type = LTTNG_EVENT_PROBE;
+ break;
+ case LTTNG_UST_FUNCTION:
+ tmp[i].type = LTTNG_EVENT_FUNCTION;
+ break;
+ case LTTNG_UST_TRACEPOINT_LOGLEVEL:
+ tmp[i].type = LTTNG_EVENT_TRACEPOINT_LOGLEVEL;
+ break;
}
+ i++;
}
ret = nb_event;
int domain, char *channel_name)
{
int ret;
+ struct ltt_ust_session *usess;
- switch (domain) {
- case LTTNG_DOMAIN_KERNEL:
- ret = channel_kernel_disable(session->kernel_session,
- channel_name);
- if (ret != LTTCOMM_OK) {
- goto error;
- }
+ usess = session->ust_session;
- kernel_wait_quiescent(kernel_tracer_fd);
- break;
- case LTTNG_DOMAIN_UST_PID:
- break;
- default:
- ret = LTTCOMM_UNKNOWN_DOMAIN;
+ switch (domain) {
+ case LTTNG_DOMAIN_KERNEL:
+ {
+ ret = channel_kernel_disable(session->kernel_session,
+ channel_name);
+ if (ret != LTTCOMM_OK) {
goto error;
- }
+ }
- ret = LTTCOMM_OK;
+ kernel_wait_quiescent(kernel_tracer_fd);
+ break;
+ }
+ case LTTNG_DOMAIN_UST:
+ {
+ struct ltt_ust_channel *uchan;
+ struct cds_lfht *chan_ht;
-error:
- return ret;
-}
+ chan_ht = usess->domain_global.channels;
-/*
- * 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_find_channel_by_name(chan_ht, channel_name);
+ if (uchan == NULL) {
+ ret = LTTCOMM_UST_CHAN_NOT_FOUND;
+ goto error;
+ }
- uchan = trace_ust_get_channel_by_key(usess->channels, attr->name);
- if (uchan == NULL) {
- ret = LTTCOMM_FATAL;
- goto error;
+ ret = channel_ust_disable(usess, domain, uchan);
+ if (ret != LTTCOMM_OK) {
+ goto error;
+ }
+ break;
}
-
- new_chan = trace_ust_create_channel(attr, usess->path);
- if (new_chan == NULL) {
- PERROR("malloc ltt_ust_channel");
- ret = LTTCOMM_FATAL;
+ case LTTNG_DOMAIN_UST_PID_FOLLOW_CHILDREN:
+ case LTTNG_DOMAIN_UST_EXEC_NAME:
+ case LTTNG_DOMAIN_UST_PID:
+ ret = LTTCOMM_NOT_IMPLEMENTED;
goto error;
- }
-
- ret = channel_ust_copy(new_chan, uchan);
- if (ret < 0) {
- ret = LTTCOMM_FATAL;
+ default:
+ ret = LTTCOMM_UNKNOWN_DOMAIN;
goto error;
}
+ ret = LTTCOMM_OK;
+
error:
return ret;
}
-*/
/*
* Command LTTNG_ENABLE_CHANNEL processed by the client thread.
*/
static int cmd_enable_channel(struct ltt_session *session,
- struct lttng_domain *domain, struct lttng_channel *attr)
+ int domain, struct lttng_channel *attr)
{
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);
- switch (domain->type) {
+ switch (domain) {
case LTTNG_DOMAIN_KERNEL:
{
struct ltt_kernel_channel *kchan;
{
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;
- }
-
- 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 {
- ret = LTTCOMM_UST_CHAN_EXIST;
- goto error;
+ ret = channel_ust_enable(usess, domain, uchan);
}
-
- /* Add channel to all registered applications */
- ret = ust_app_create_channel_all(usess, uchan);
- if (ret != 0) {
- goto error;
- }
-
- uchan->enabled = 1;
-
break;
}
+ case LTTNG_DOMAIN_UST_PID_FOLLOW_CHILDREN:
+ case LTTNG_DOMAIN_UST_EXEC_NAME:
case LTTNG_DOMAIN_UST_PID:
- {
- /*
- int sock;
- struct ltt_ust_channel *uchan;
- struct ltt_ust_session *usess;
- struct ust_app *app;
-
- usess = trace_ust_get_session_by_pid(&session->ust_session_list,
- domain->attr.pid);
- if (usess == NULL) {
- ret = LTTCOMM_UST_CHAN_NOT_FOUND;
- goto error;
- }
-
- app = ust_app_get_by_pid(domain->attr.pid);
- if (app == NULL) {
- ret = LTTCOMM_APP_NOT_FOUND;
- goto error;
- }
- sock = app->sock;
-
- uchan = trace_ust_get_channel_by_name(attr->name, usess);
- if (uchan == NULL) {
- ret = channel_ust_create(usess, attr, sock);
- } else {
- ret = channel_ust_enable(usess, uchan, sock);
- }
-
- if (ret != LTTCOMM_OK) {
- goto error;
- }
-
- ret = copy_ust_channel_to_app(usess, attr, app);
- if (ret != LTTCOMM_OK) {
- goto error;
- }
-
- DBG("UST channel %s created for app sock %d with pid %d",
- attr->name, app->sock, domain->attr.pid);
- */
ret = LTTCOMM_NOT_IMPLEMENTED;
goto error;
- }
default:
ret = LTTCOMM_UNKNOWN_DOMAIN;
goto error;
}
- ret = LTTCOMM_OK;
-
error:
return ret;
}
case LTTNG_DOMAIN_KERNEL:
{
struct ltt_kernel_channel *kchan;
+ struct ltt_kernel_session *ksess;
- kchan = trace_kernel_get_channel_by_name(channel_name,
- session->kernel_session);
+ ksess = session->kernel_session;
+
+ kchan = trace_kernel_get_channel_by_name(channel_name, ksess);
if (kchan == NULL) {
ret = LTTCOMM_KERN_CHAN_NOT_FOUND;
goto error;
}
- ret = event_kernel_disable_tracepoint(session->kernel_session, kchan, event_name);
+ ret = event_kernel_disable_tracepoint(ksess, kchan, event_name);
if (ret != LTTCOMM_OK) {
goto error;
}
break;
}
case LTTNG_DOMAIN_UST:
+ {
+ struct ltt_ust_channel *uchan;
+ struct ltt_ust_session *usess;
+
+ usess = session->ust_session;
+
+ uchan = trace_ust_find_channel_by_name(usess->domain_global.channels,
+ channel_name);
+ if (uchan == NULL) {
+ ret = LTTCOMM_UST_CHAN_NOT_FOUND;
+ goto error;
+ }
+
+ ret = event_ust_disable_tracepoint(usess, domain, uchan, event_name);
+ if (ret != LTTCOMM_OK) {
+ goto error;
+ }
+
+ DBG3("Disable UST event %s in channel %s completed", event_name,
+ channel_name);
+ break;
+ }
case LTTNG_DOMAIN_UST_EXEC_NAME:
case LTTNG_DOMAIN_UST_PID:
case LTTNG_DOMAIN_UST_PID_FOLLOW_CHILDREN:
default:
- /* TODO: Other UST domains */
ret = LTTCOMM_NOT_IMPLEMENTED;
goto error;
}
char *channel_name)
{
int ret;
- struct ltt_kernel_channel *kchan;
switch (domain) {
case LTTNG_DOMAIN_KERNEL:
- kchan = trace_kernel_get_channel_by_name(channel_name,
- session->kernel_session);
+ {
+ struct ltt_kernel_session *ksess;
+ struct ltt_kernel_channel *kchan;
+
+ ksess = session->kernel_session;
+
+ kchan = trace_kernel_get_channel_by_name(channel_name, ksess);
if (kchan == NULL) {
ret = LTTCOMM_KERN_CHAN_NOT_FOUND;
goto error;
}
- ret = event_kernel_disable_all(session->kernel_session, kchan);
+ ret = event_kernel_disable_all(ksess, kchan);
if (ret != LTTCOMM_OK) {
goto error;
}
kernel_wait_quiescent(kernel_tracer_fd);
break;
+ }
+ case LTTNG_DOMAIN_UST:
+ {
+ struct ltt_ust_session *usess;
+ struct ltt_ust_channel *uchan;
+
+ usess = session->ust_session;
+
+ uchan = trace_ust_find_channel_by_name(usess->domain_global.channels,
+ channel_name);
+ if (uchan == NULL) {
+ ret = LTTCOMM_UST_CHAN_NOT_FOUND;
+ goto error;
+ }
+
+ ret = event_ust_disable_all_tracepoints(usess, domain, uchan);
+ if (ret != 0) {
+ goto error;
+ }
+
+ DBG3("Disable all UST events in channel %s completed", channel_name);
+
+ 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;
}
break;
case LTTNG_DOMAIN_UST:
{
- /*
- struct ltt_ust_session *usess;
+ struct ltt_ust_session *usess = session->ust_session;
- cds_list_for_each_entry(usess, &session->ust_session_list.head, list) {
- ret = context_ust_add(usess, ctx,
- event_name, channel_name, domain);
- if (ret != LTTCOMM_OK) {
- goto error;
- }
+ ret = context_ust_add(usess, domain, ctx, event_name, channel_name);
+ 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: UST other domains */
ret = LTTCOMM_NOT_IMPLEMENTED;
goto error;
}
/*
* 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)
ret = channel_kernel_create(session->kernel_session,
attr, kernel_poll_pipe[1]);
if (ret != LTTCOMM_OK) {
+ free(attr);
goto error;
}
+ free(attr);
}
/* Get the newly created kernel channel pointer */
}
case LTTNG_DOMAIN_UST:
{
+ struct lttng_channel *attr;
struct ltt_ust_channel *uchan;
- struct ltt_ust_event *uevent;
+ /* Get channel from global UST domain */
uchan = trace_ust_find_channel_by_name(usess->domain_global.channels,
channel_name);
if (uchan == NULL) {
- /* TODO: Create default channel */
- ret = LTTCOMM_UST_CHAN_NOT_FOUND;
- goto error;
- }
-
- uevent = trace_ust_find_event_by_name(uchan->events, event->name);
- if (uevent == NULL) {
- uevent = trace_ust_create_event(event);
- if (uevent == 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';
- }
+ ret = channel_ust_create(usess, domain, attr);
+ if (ret != LTTCOMM_OK) {
+ free(attr);
+ goto error;
+ }
+ free(attr);
- ret = ust_app_create_event_all(usess, uchan, uevent);
- if (ret < 0) {
- ret = LTTCOMM_UST_ENABLE_FAIL;
- goto error;
+ /* 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;
+ }
}
- /* Add ltt ust event to channel */
- rcu_read_lock();
- hashtable_add_unique(uchan->events, &uevent->node);
- rcu_read_unlock();
-
- uevent->enabled = 1;
+ /* At this point, the session and channel exist on the tracer */
- DBG3("UST ltt event %s added to channel %s", uevent->attr.name,
- uchan->name);
+ ret = event_ust_enable_tracepoint(usess, domain, uchan, event);
+ if (ret != LTTCOMM_OK) {
+ goto error;
+ }
break;
}
case LTTNG_DOMAIN_UST_EXEC_NAME:
if (ret != LTTCOMM_OK) {
goto error;
}
- }
- /* Get the newly created kernel channel pointer */
- kchan = trace_kernel_get_channel_by_name(channel_name,
- session->kernel_session);
- if (kchan == NULL) {
- /* This sould not happen... */
- ret = LTTCOMM_FATAL;
- goto error;
+ /* Get the newly created kernel channel pointer */
+ kchan = trace_kernel_get_channel_by_name(channel_name,
+ session->kernel_session);
+ if (kchan == NULL) {
+ /* This sould not happen... */
+ ret = LTTCOMM_FATAL;
+ 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);
ret = LTTCOMM_KERN_ENABLE_FAIL;
goto error;
}
+
+ /* Manage return value */
if (ret != LTTCOMM_OK) {
goto error;
}
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 */
kernel_wait_quiescent(kernel_tracer_fd);
}
- /* Flag session that trace should start automatically */
if (usess) {
usess->start_trace = 0;
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;
}
DBG("Processing client command %d", cmd_ctx->lsm->cmd_type);
+ if (opt_no_kernel && cmd_ctx->lsm->domain.type == LTTNG_DOMAIN_KERNEL) {
+ ret = LTTCOMM_KERN_NA;
+ goto error;
+ }
+
/*
* Check for command that don't needs to allocate a returned payload. We do
* this here so we don't have to make the call for no payload at each
/* Need a session for kernel command */
if (need_tracing_session) {
if (cmd_ctx->session->kernel_session == NULL) {
- ret = create_kernel_session(cmd_ctx->session);
+ ret = create_kernel_session(cmd_ctx->session, &cmd_ctx->creds);
if (ret < 0) {
ret = LTTCOMM_KERN_SESS_FAIL;
goto error;
if (need_tracing_session) {
if (cmd_ctx->session->ust_session == NULL) {
ret = create_ust_session(cmd_ctx->session,
- &cmd_ctx->lsm->domain);
+ &cmd_ctx->lsm->domain, &cmd_ctx->creds);
if (ret != LTTCOMM_OK) {
goto error;
}
/* Start the UST consumer daemons */
/* 64-bit */
pthread_mutex_lock(&ustconsumer64_data.pid_mutex);
- if (consumerd64_bindir[0] != '\0' &&
+ if (consumerd64_bin[0] != '\0' &&
ustconsumer64_data.pid == 0 &&
cmd_ctx->lsm->cmd_type != LTTNG_REGISTER_CONSUMER) {
pthread_mutex_unlock(&ustconsumer64_data.pid_mutex);
pthread_mutex_unlock(&ustconsumer64_data.pid_mutex);
}
/* 32-bit */
- if (consumerd32_bindir[0] != '\0' &&
+ if (consumerd32_bin[0] != '\0' &&
ustconsumer32_data.pid == 0 &&
cmd_ctx->lsm->cmd_type != LTTNG_REGISTER_CONSUMER) {
pthread_mutex_unlock(&ustconsumer32_data.pid_mutex);
}
case LTTNG_ENABLE_CHANNEL:
{
- ret = cmd_enable_channel(cmd_ctx->session, &cmd_ctx->lsm->domain,
+ ret = cmd_enable_channel(cmd_ctx->session, cmd_ctx->lsm->domain.type,
&cmd_ctx->lsm->u.channel.chan);
break;
}
goto error;
}
+ /* Set socket option for credentials retrieval */
+ ret = lttcomm_setsockopt_creds_unix_sock(sock);
+ if (ret < 0) {
+ goto error;
+ }
+
/* Allocate context command to process the client request */
cmd_ctx = zmalloc(sizeof(struct command_ctx));
if (cmd_ctx == NULL) {
* the client.
*/
DBG("Receiving data from client ...");
- ret = lttcomm_recv_unix_sock(sock, cmd_ctx->lsm,
- sizeof(struct lttcomm_session_msg));
+ ret = lttcomm_recv_creds_unix_sock(sock, cmd_ctx->lsm,
+ sizeof(struct lttcomm_session_msg), &cmd_ctx->creds);
if (ret <= 0) {
DBG("Nothing recv() from client... continuing");
close(sock);
ERR("Failed to send data back to client");
}
- clean_command_ctx(&cmd_ctx);
-
/* End of transmission */
close(sock);
+
+ clean_command_ctx(&cmd_ctx);
}
error:
fprintf(stderr, " --ustconsumerd64-err-sock PATH Specify path for the 64-bit UST consumer error socket\n");
fprintf(stderr, " --ustconsumerd32-cmd-sock PATH Specify path for the 32-bit UST consumer command socket\n");
fprintf(stderr, " --ustconsumerd64-cmd-sock PATH Specify path for the 64-bit UST consumer command socket\n");
- fprintf(stderr, " --ustconsumerd32 PATH Specify path for the 32-bit UST consumer daemon binary\n");
- fprintf(stderr, " --ustconsumerd64 PATH Specify path for the 64-bit UST consumer daemon binary\n");
+ fprintf(stderr, " --consumerd32-path PATH Specify path for the 32-bit UST consumer daemon binary\n");
+ fprintf(stderr, " --consumerd32-libdir PATH Specify path for the 32-bit UST consumer daemon libraries\n");
+ 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, " -g, --group NAME Specify the tracing group name. (default: tracing)\n");
fprintf(stderr, " -V, --version Show version number.\n");
fprintf(stderr, " -q, --quiet No output at all.\n");
fprintf(stderr, " -v, --verbose Verbose mode. Activate DBG() macro.\n");
fprintf(stderr, " --verbose-consumer Verbose mode for consumer. Activate DBG() macro.\n");
+ fprintf(stderr, " --no-kernel Disable kernel tracer\n");
}
/*
{ "apps-sock", 1, 0, 'a' },
{ "kconsumerd-cmd-sock", 1, 0, 'C' },
{ "kconsumerd-err-sock", 1, 0, 'E' },
- { "ustconsumerd64", 1, 0, 't' },
- { "ustconsumerd64-cmd-sock", 1, 0, 'D' },
- { "ustconsumerd64-err-sock", 1, 0, 'F' },
- { "ustconsumerd32", 1, 0, 'u' },
{ "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' },
{ "quiet", 0, 0, 'q' },
{ "verbose", 0, 0, 'v' },
{ "verbose-consumer", 0, 0, 'Z' },
+ { "no-kernel", 0, 0, 'N' },
{ NULL, 0, 0, 0 }
};
while (1) {
int option_index = 0;
- c = getopt_long(argc, argv, "dhqvVS" "a:c:g:s:C:E:D:F:Z:u:t",
+ c = getopt_long(argc, argv, "dhqvVSN" "a:c:g:s:C:E:D:F:Z:u:t",
long_options, &option_index);
if (c == -1) {
break;
case 'G':
snprintf(ustconsumer32_data.cmd_unix_sock_path, PATH_MAX, "%s", optarg);
break;
+ case 'N':
+ opt_no_kernel = 1;
+ break;
case 'q':
opt_quiet = 1;
break;
opt_verbose_consumer += 1;
break;
case 'u':
- consumerd32_bindir = optarg;
+ consumerd32_bin= optarg;
+ break;
+ case 'U':
+ consumerd32_libdir = optarg;
break;
case 't':
- consumerd64_bindir = optarg;
+ consumerd64_bin = optarg;
+ break;
+ case 'T':
+ consumerd64_libdir = optarg;
break;
default:
/* Unknown option or other error.
* Race window between mkdir and chown is OK because we are going from more
* permissive (root.root) to les permissive (root.tracing).
*/
-static int set_permissions(void)
+static int set_permissions(char *rundir)
{
int ret;
gid_t gid;
gid = allowed_group();
if (gid < 0) {
- if (is_root) {
- WARN("No tracing group detected");
- ret = 0;
- } else {
- ERR("Missing tracing group. Aborting execution.");
- ret = -1;
- }
+ WARN("No tracing group detected");
+ ret = 0;
goto end;
}
/* Set lttng run dir */
- ret = chown(LTTNG_RUNDIR, 0, gid);
+ ret = chown(rundir, 0, gid);
if (ret < 0) {
- ERR("Unable to set group on " LTTNG_RUNDIR);
+ ERR("Unable to set group on %s", rundir);
perror("chown");
}
/*
* 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;
}
/* Setup kernel tracer */
- init_kernel_tracer();
+ if (!opt_no_kernel) {
+ init_kernel_tracer();
+ }
/* Set ulimit for open files */
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;
}
}
/* Set credentials to socket */
- if (is_root && ((ret = set_permissions()) < 0)) {
+ if (is_root && ((ret = set_permissions(rundir)) < 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