#include <unistd.h>
#include <config.h>
-#include <bin/lttng-consumerd/lttng-consumerd.h>
-#include <common/lttngerr.h>
+#include <common/common.h>
+#include <common/compat/poll.h>
+#include <common/defaults.h>
#include <common/kernel-consumer/kernel-consumer.h>
#include <common/ust-consumer/ust-consumer.h>
-#include <common/runas.h>
-#include <common/compat/poll.h>
#include "lttng-sessiond.h"
#include "channel.h"
#include "event.h"
#include "futex.h"
#include "kernel.h"
+#include "modprobe.h"
#include "shm.h"
#include "ust-ctl.h"
#include "utils.h"
/* Const values */
const char default_home_dir[] = DEFAULT_HOME_DIR;
-const char default_tracing_group[] = LTTNG_DEFAULT_TRACING_GROUP;
+const char default_tracing_group[] = DEFAULT_TRACING_GROUP;
const char default_ust_sock_dir[] = DEFAULT_UST_SOCK_DIR;
const char default_global_apps_pipe[] = DEFAULT_GLOBAL_APPS_PIPE;
/* Consumer daemon specific control data */
static struct consumer_data kconsumer_data = {
.type = LTTNG_CONSUMER_KERNEL,
- .err_unix_sock_path = KCONSUMERD_ERR_SOCK_PATH,
- .cmd_unix_sock_path = KCONSUMERD_CMD_SOCK_PATH,
+ .err_unix_sock_path = DEFAULT_KCONSUMERD_ERR_SOCK_PATH,
+ .cmd_unix_sock_path = DEFAULT_KCONSUMERD_CMD_SOCK_PATH,
};
static struct consumer_data ustconsumer64_data = {
.type = LTTNG_CONSUMER64_UST,
- .err_unix_sock_path = USTCONSUMERD64_ERR_SOCK_PATH,
- .cmd_unix_sock_path = USTCONSUMERD64_CMD_SOCK_PATH,
+ .err_unix_sock_path = DEFAULT_USTCONSUMERD64_ERR_SOCK_PATH,
+ .cmd_unix_sock_path = DEFAULT_USTCONSUMERD64_CMD_SOCK_PATH,
};
static struct consumer_data ustconsumer32_data = {
.type = LTTNG_CONSUMER32_UST,
- .err_unix_sock_path = USTCONSUMERD32_ERR_SOCK_PATH,
- .cmd_unix_sock_path = USTCONSUMERD32_CMD_SOCK_PATH,
+ .err_unix_sock_path = DEFAULT_USTCONSUMERD32_ERR_SOCK_PATH,
+ .cmd_unix_sock_path = DEFAULT_USTCONSUMERD32_CMD_SOCK_PATH,
};
static int dispatch_thread_exit;
static char wait_shm_path[PATH_MAX];
/* Sockets and FDs */
-static int client_sock;
-static int apps_sock;
-static int kernel_tracer_fd;
-static int kernel_poll_pipe[2];
+static int client_sock = -1;
+static int apps_sock = -1;
+static int kernel_tracer_fd = -1;
+static int kernel_poll_pipe[2] = { -1, -1 };
/*
* Quit pipe for all threads. This permits a single cancellation point
* for all threads when receiving an event on the pipe.
*/
-static int thread_quit_pipe[2];
+static int thread_quit_pipe[2] = { -1, -1 };
/*
* This pipe is used to inform the thread managing application communication
* that a command is queued and ready to be processed.
*/
-static int apps_cmd_pipe[2];
+static int apps_cmd_pipe[2] = { -1, -1 };
/* Pthread, Mutexes and Semaphores */
static pthread_t apps_thread;
if (bin) {
consumerd64_bin = bin;
}
- libdir = getenv("LTTNG_TOOLS_CONSUMERD32_LIBDIR");
+ libdir = getenv("LTTNG_CONSUMERD32_LIBDIR");
if (libdir) {
consumerd32_libdir = libdir;
}
- libdir = getenv("LTTNG_TOOLS_CONSUMERD64_LIBDIR");
+ libdir = getenv("LTTNG_CONSUMERD64_LIBDIR");
if (libdir) {
consumerd64_libdir = libdir;
}
return 0;
}
-/*
- * Remove modules in reverse load order.
- */
-static int modprobe_remove_kernel_modules(void)
-{
- int ret = 0, i;
- char modprobe[256];
-
- for (i = ARRAY_SIZE(kernel_modules_list) - 1; i >= 0; i--) {
- ret = snprintf(modprobe, sizeof(modprobe),
- "/sbin/modprobe -r -q %s",
- kernel_modules_list[i].name);
- if (ret < 0) {
- perror("snprintf modprobe -r");
- goto error;
- }
- modprobe[sizeof(modprobe) - 1] = '\0';
- ret = system(modprobe);
- if (ret == -1) {
- ERR("Unable to launch modprobe -r for module %s",
- kernel_modules_list[i].name);
- } else if (kernel_modules_list[i].required
- && WEXITSTATUS(ret) != 0) {
- ERR("Unable to remove module %s",
- kernel_modules_list[i].name);
- } else {
- DBG("Modprobe removal successful %s",
- kernel_modules_list[i].name);
- }
- }
-
-error:
- return ret;
-}
-
/*
* Return group ID of the tracing group or -1 if not found.
*/
ret = pipe2(thread_quit_pipe, O_CLOEXEC);
if (ret < 0) {
- perror("thread quit pipe");
+ PERROR("thread quit pipe");
goto error;
}
static void teardown_kernel_session(struct ltt_session *session)
{
if (!session->kernel_session) {
- DBG3("No kernel session when tearingdown session");
+ DBG3("No kernel session when tearing down session");
return;
}
int ret;
if (!session->ust_session) {
- DBG3("No UST session when tearingdown session");
+ DBG3("No UST session when tearing down session");
return;
}
*/
static void cleanup(void)
{
- int ret;
+ int ret, i;
char *cmd;
struct ltt_session *sess, *stmp;
}
free(cmd);
- DBG("Cleaning up all session");
+ DBG("Cleaning up all sessions");
/* Destroy session list mutex */
if (session_list_ptr != NULL) {
if (is_root && !opt_no_kernel) {
DBG2("Closing kernel fd");
- close(kernel_tracer_fd);
+ if (kernel_tracer_fd >= 0) {
+ ret = close(kernel_tracer_fd);
+ if (ret) {
+ PERROR("close");
+ }
+ }
DBG("Unloading kernel modules");
- modprobe_remove_kernel_modules();
+ modprobe_remove_lttng_all();
}
- close(thread_quit_pipe[0]);
- close(thread_quit_pipe[1]);
+ /*
+ * Closing all pipes used for communication between threads.
+ */
+ for (i = 0; i < 2; i++) {
+ if (kernel_poll_pipe[i] >= 0) {
+ ret = close(kernel_poll_pipe[i]);
+ if (ret) {
+ PERROR("close");
+ }
+
+ }
+ }
+ for (i = 0; i < 2; i++) {
+ if (thread_quit_pipe[i] >= 0) {
+ ret = close(thread_quit_pipe[i]);
+ if (ret) {
+ PERROR("close");
+ }
+ }
+ }
+ for (i = 0; i < 2; i++) {
+ if (apps_cmd_pipe[i] >= 0) {
+ ret = close(apps_cmd_pipe[i]);
+ if (ret) {
+ PERROR("close");
+ }
+ }
+ }
/* <fun> */
DBG("%c[%d;%dm*** assert failed :-) *** ==> %c[%dm%c[%d;%dm"
DBG("Sending channel %d to consumer", lkm.u.channel.channel_key);
ret = lttcomm_send_unix_sock(sock, &lkm, sizeof(lkm));
if (ret < 0) {
- perror("send consumer channel");
+ PERROR("send consumer channel");
goto error;
}
DBG("Sending stream %d to consumer", lkm.u.stream.stream_key);
ret = lttcomm_send_unix_sock(sock, &lkm, sizeof(lkm));
if (ret < 0) {
- perror("send consumer stream");
+ PERROR("send consumer stream");
goto error;
}
ret = lttcomm_send_fds_unix_sock(sock, &stream->fd, 1);
if (ret < 0) {
- perror("send consumer stream ancillary data");
+ PERROR("send consumer stream ancillary data");
goto error;
}
}
DBG("Sending metadata channel %d to consumer", lkm.u.stream.stream_key);
ret = lttcomm_send_unix_sock(sock, &lkm, sizeof(lkm));
if (ret < 0) {
- perror("send consumer channel");
+ PERROR("send consumer channel");
goto error;
}
DBG("Sending metadata stream %d to consumer", lkm.u.stream.stream_key);
ret = lttcomm_send_unix_sock(sock, &lkm, sizeof(lkm));
if (ret < 0) {
- perror("send consumer stream");
+ PERROR("send consumer stream");
goto error;
}
ret = lttcomm_send_fds_unix_sock(sock, &session->metadata_stream_fd, 1);
if (ret < 0) {
- perror("send consumer stream");
+ PERROR("send consumer stream");
goto error;
}
}
cmd_ctx->llm = zmalloc(sizeof(struct lttcomm_lttng_msg) + buf_size);
if (cmd_ctx->llm == NULL) {
- perror("zmalloc");
+ PERROR("zmalloc");
ret = -ENOMEM;
goto error;
}
{
struct ltt_session *sess, *stmp;
+ session_lock_list();
+
/* For all tracing session(s) */
cds_list_for_each_entry_safe(sess, stmp, &session_list_ptr->head, list) {
+ session_lock(sess);
if (sess->ust_session) {
ust_app_global_update(sess->ust_session, app_sock);
}
+ session_unlock(sess);
}
+
+ session_unlock_list();
}
/*
ret = create_thread_poll_set(&events, 2);
if (ret < 0) {
- goto error;
+ goto error_poll_create;
}
ret = lttng_poll_add(&events, kernel_poll_pipe[0], LPOLLIN);
lttng_poll_reset(&events);
/* Poll infinite value of time */
+ restart:
ret = lttng_poll_wait(&events, -1);
if (ret < 0) {
+ /*
+ * Restart interrupted system call.
+ */
+ if (errno == EINTR) {
+ goto restart;
+ }
goto error;
} else if (ret == 0) {
/* Should not happen since timeout is infinite */
}
error:
- DBG("Kernel thread dying");
- close(kernel_poll_pipe[0]);
- close(kernel_poll_pipe[1]);
-
lttng_poll_clean(&events);
-
+error_poll_create:
+ DBG("Kernel thread dying");
return NULL;
}
*/
static void *thread_manage_consumer(void *data)
{
- int sock = 0, i, ret, pollfd;
+ int sock = -1, i, ret, pollfd;
uint32_t revents, nb_fd;
enum lttcomm_return_code code;
struct lttng_poll_event events;
ret = lttcomm_listen_unix_sock(consumer_data->err_sock);
if (ret < 0) {
- goto error;
+ goto error_listen;
}
/*
*/
ret = create_thread_poll_set(&events, 2);
if (ret < 0) {
- goto error;
+ goto error_poll;
}
ret = lttng_poll_add(&events, consumer_data->err_sock, LPOLLIN | LPOLLRDHUP);
nb_fd = LTTNG_POLL_GETNB(&events);
/* Inifinite blocking call, waiting for transmission */
+restart:
ret = lttng_poll_wait(&events, -1);
if (ret < 0) {
+ /*
+ * Restart interrupted system call.
+ */
+ if (errno == EINTR) {
+ goto restart;
+ }
goto error;
}
nb_fd = LTTNG_POLL_GETNB(&events);
/* Inifinite blocking call, waiting for transmission */
+restart_poll:
ret = lttng_poll_wait(&events, -1);
if (ret < 0) {
+ /*
+ * Restart interrupted system call.
+ */
+ if (errno == EINTR) {
+ goto restart_poll;
+ }
goto error;
}
ERR("consumer return code : %s", lttcomm_get_readable_code(-code));
error:
- DBG("consumer thread dying");
- close(consumer_data->err_sock);
- close(consumer_data->cmd_sock);
- close(sock);
+ if (consumer_data->err_sock >= 0) {
+ ret = close(consumer_data->err_sock);
+ if (ret) {
+ PERROR("close");
+ }
+ }
+ if (consumer_data->cmd_sock >= 0) {
+ ret = close(consumer_data->cmd_sock);
+ if (ret) {
+ PERROR("close");
+ }
+ }
+ if (sock >= 0) {
+ ret = close(sock);
+ if (ret) {
+ PERROR("close");
+ }
+ }
unlink(consumer_data->err_unix_sock_path);
unlink(consumer_data->cmd_unix_sock_path);
consumer_data->pid = 0;
lttng_poll_clean(&events);
+error_poll:
+error_listen:
+ DBG("consumer thread cleanup completed");
return NULL;
}
ret = create_thread_poll_set(&events, 2);
if (ret < 0) {
- goto error;
+ goto error_poll_create;
}
ret = lttng_poll_add(&events, apps_cmd_pipe[0], LPOLLIN | LPOLLRDHUP);
DBG("Apps thread polling on %d fds", nb_fd);
/* Inifinite blocking call, waiting for transmission */
+ restart:
ret = lttng_poll_wait(&events, -1);
if (ret < 0) {
+ /*
+ * Restart interrupted system call.
+ */
+ if (errno == EINTR) {
+ goto restart;
+ }
goto error;
}
/* Empty pipe */
ret = read(apps_cmd_pipe[0], &ust_cmd, sizeof(ust_cmd));
if (ret < 0 || ret < sizeof(ust_cmd)) {
- perror("read apps cmd pipe");
+ PERROR("read apps cmd pipe");
goto error;
}
}
/*
- * Add channel(s) and event(s) to newly registered apps
- * from lttng global UST domain.
+ * Validate UST version compatibility.
*/
- update_ust_app(ust_cmd.sock);
+ ret = ust_app_validate_version(ust_cmd.sock);
+ if (ret >= 0) {
+ /*
+ * Add channel(s) and event(s) to newly registered apps
+ * from lttng global UST domain.
+ */
+ update_ust_app(ust_cmd.sock);
+ }
ret = ust_app_register_done(ust_cmd.sock);
if (ret < 0) {
/*
* We just need here to monitor the close of the UST
* socket and poll set monitor those by default.
+ * Listen on POLLIN (even if we never expect any
+ * data) to ensure that hangup wakes us.
*/
- ret = lttng_poll_add(&events, ust_cmd.sock, 0);
+ ret = lttng_poll_add(&events, ust_cmd.sock, LPOLLIN);
if (ret < 0) {
goto error;
}
}
error:
- DBG("Application communication apps dying");
- close(apps_cmd_pipe[0]);
- close(apps_cmd_pipe[1]);
-
lttng_poll_clean(&events);
-
+error_poll_create:
+ DBG("Application communication apps thread cleanup complete");
rcu_thread_offline();
rcu_unregister_thread();
return NULL;
ret = write(apps_cmd_pipe[1], ust_cmd,
sizeof(struct ust_command));
if (ret < 0) {
- perror("write apps cmd pipe");
+ PERROR("write apps cmd pipe");
if (errno == EBADF) {
/*
* We can't inform the application thread to process
*/
static void *thread_registration_apps(void *data)
{
- int sock = 0, i, ret, pollfd;
+ int sock = -1, i, ret, pollfd;
uint32_t revents, nb_fd;
struct lttng_poll_event events;
/*
ret = lttcomm_listen_unix_sock(apps_sock);
if (ret < 0) {
- goto error;
+ goto error_listen;
}
/*
*/
ret = create_thread_poll_set(&events, 2);
if (ret < 0) {
- goto error;
+ goto error_create_poll;
}
/* Add the application registration socket */
ret = lttng_poll_add(&events, apps_sock, LPOLLIN | LPOLLRDHUP);
if (ret < 0) {
- goto error;
+ goto error_poll_add;
}
/* Notify all applications to register */
nb_fd = LTTNG_POLL_GETNB(&events);
/* Inifinite blocking call, waiting for transmission */
+ restart:
ret = lttng_poll_wait(&events, -1);
if (ret < 0) {
+ /*
+ * Restart interrupted system call.
+ */
+ if (errno == EINTR) {
+ goto restart;
+ }
goto error;
}
/* Create UST registration command for enqueuing */
ust_cmd = zmalloc(sizeof(struct ust_command));
if (ust_cmd == NULL) {
- perror("ust command zmalloc");
+ PERROR("ust command zmalloc");
goto error;
}
sizeof(struct ust_register_msg));
if (ret < 0 || ret < sizeof(struct ust_register_msg)) {
if (ret < 0) {
- perror("lttcomm_recv_unix_sock register apps");
+ PERROR("lttcomm_recv_unix_sock register apps");
} else {
ERR("Wrong size received on apps register");
}
free(ust_cmd);
- close(sock);
+ ret = close(sock);
+ if (ret) {
+ PERROR("close");
+ }
+ sock = -1;
continue;
}
ust_cmd->sock = sock;
+ sock = -1;
DBG("UST registration received with pid:%d ppid:%d uid:%d"
" gid:%d sock:%d name:%s (version %d.%d)",
}
error:
- DBG("UST Registration thread dying");
-
/* Notify that the registration thread is gone */
notify_ust_apps(0);
- close(apps_sock);
- close(sock);
+ if (apps_sock >= 0) {
+ ret = close(apps_sock);
+ if (ret) {
+ PERROR("close");
+ }
+ }
+ if (sock >= 0) {
+ ret = close(sock);
+ if (ret) {
+ PERROR("close");
+ }
+ }
unlink(apps_unix_sock_path);
+error_poll_add:
lttng_poll_clean(&events);
+error_listen:
+error_create_poll:
+ DBG("UST Registration thread cleanup complete");
return NULL;
}
break;
}
default:
- perror("unknown consumer type");
+ PERROR("unknown consumer type");
exit(EXIT_FAILURE);
}
if (errno != 0) {
- perror("kernel start consumer exec");
+ PERROR("kernel start consumer exec");
}
exit(EXIT_FAILURE);
} else if (pid > 0) {
ret = pid;
} else {
- perror("start consumer fork");
+ PERROR("start consumer fork");
ret = -errno;
}
error:
}
/*
- * modprobe_kernel_modules
+ * Check version of the lttng-modules.
*/
-static int modprobe_kernel_modules(void)
+static int validate_lttng_modules_version(void)
{
- int ret = 0, i;
- char modprobe[256];
-
- for (i = 0; i < ARRAY_SIZE(kernel_modules_list); i++) {
- ret = snprintf(modprobe, sizeof(modprobe),
- "/sbin/modprobe %s%s",
- kernel_modules_list[i].required ? "" : "-q ",
- kernel_modules_list[i].name);
- if (ret < 0) {
- perror("snprintf modprobe");
- goto error;
- }
- modprobe[sizeof(modprobe) - 1] = '\0';
- ret = system(modprobe);
- if (ret == -1) {
- ERR("Unable to launch modprobe for module %s",
- kernel_modules_list[i].name);
- } else if (kernel_modules_list[i].required
- && WEXITSTATUS(ret) != 0) {
- ERR("Unable to load module %s",
- kernel_modules_list[i].name);
- } else {
- DBG("Modprobe successfully %s",
- kernel_modules_list[i].name);
- }
- }
-
-error:
- return ret;
+ return kernel_validate_version(kernel_tracer_fd);
}
/*
- * mount_debugfs
+ * Setup necessary data for kernel tracer action.
*/
-static int mount_debugfs(char *path)
+static int init_kernel_tracer(void)
{
int ret;
- char *type = "debugfs";
- ret = run_as_mkdir_recursive(path, S_IRWXU | S_IRWXG, geteuid(), getegid());
- if (ret < 0) {
- PERROR("Cannot create debugfs path");
- goto error;
- }
-
- ret = mount(type, path, type, 0, NULL);
+ /* Modprobe lttng kernel modules */
+ ret = modprobe_lttng_control();
if (ret < 0) {
- PERROR("Cannot mount debugfs");
- goto error;
- }
-
- DBG("Mounted debugfs successfully at %s", path);
-
-error:
- return ret;
-}
-
-/*
- * Setup necessary data for kernel tracer action.
- */
-static void init_kernel_tracer(void)
-{
- int ret;
- char *proc_mounts = "/proc/mounts";
- char line[256];
- char *debugfs_path = NULL, *lttng_path = NULL;
- FILE *fp;
-
- /* Detect debugfs */
- fp = fopen(proc_mounts, "r");
- if (fp == NULL) {
- ERR("Unable to probe %s", proc_mounts);
goto error;
}
- while (fgets(line, sizeof(line), fp) != NULL) {
- if (strstr(line, "debugfs") != NULL) {
- /* Remove first string */
- strtok(line, " ");
- /* Dup string here so we can reuse line later on */
- debugfs_path = strdup(strtok(NULL, " "));
- DBG("Got debugfs path : %s", debugfs_path);
- break;
- }
+ /* Open debugfs lttng */
+ kernel_tracer_fd = open(module_proc_lttng, O_RDWR);
+ if (kernel_tracer_fd < 0) {
+ DBG("Failed to open %s", module_proc_lttng);
+ ret = -1;
+ goto error_open;
}
- fclose(fp);
-
- /* Mount debugfs if needded */
- if (debugfs_path == NULL) {
- ret = asprintf(&debugfs_path, "/mnt/debugfs");
- if (ret < 0) {
- perror("asprintf debugfs path");
- goto error;
- }
- ret = mount_debugfs(debugfs_path);
- if (ret < 0) {
- perror("Cannot mount debugfs");
- goto error;
- }
+ /* Validate kernel version */
+ ret = validate_lttng_modules_version();
+ if (ret < 0) {
+ goto error_version;
}
- /* Modprobe lttng kernel modules */
- ret = modprobe_kernel_modules();
+ ret = modprobe_lttng_data();
if (ret < 0) {
- goto error;
+ goto error_modules;
}
- /* Setup lttng kernel path */
- ret = asprintf(<tng_path, "%s/lttng", debugfs_path);
- if (ret < 0) {
- perror("asprintf lttng path");
- goto error;
+ DBG("Kernel tracer fd %d", kernel_tracer_fd);
+ return 0;
+
+error_version:
+ modprobe_remove_lttng_control();
+ ret = close(kernel_tracer_fd);
+ if (ret) {
+ PERROR("close");
}
+ kernel_tracer_fd = -1;
+ return LTTCOMM_KERN_VERSION;
- /* Open debugfs lttng */
- kernel_tracer_fd = open(lttng_path, O_RDWR);
- if (kernel_tracer_fd < 0) {
- DBG("Failed to open %s", lttng_path);
- goto error;
+error_modules:
+ ret = close(kernel_tracer_fd);
+ if (ret) {
+ PERROR("close");
}
- free(lttng_path);
- free(debugfs_path);
- DBG("Kernel tracer fd %d", kernel_tracer_fd);
- return;
+error_open:
+ modprobe_remove_lttng_control();
error:
- if (lttng_path) {
- free(lttng_path);
- }
- if (debugfs_path) {
- free(debugfs_path);
- }
WARN("No kernel tracer available");
- kernel_tracer_fd = 0;
- return;
+ kernel_tracer_fd = -1;
+ return LTTCOMM_KERN_NA;
}
/*
case LTTNG_UST_FUNCTION:
tmp[i].type = LTTNG_EVENT_FUNCTION;
break;
- case LTTNG_UST_TRACEPOINT_LOGLEVEL:
- tmp[i].type = LTTNG_EVENT_TRACEPOINT_LOGLEVEL;
+ }
+ tmp[i].loglevel = uevent->attr.loglevel;
+ switch (uevent->attr.loglevel_type) {
+ case LTTNG_UST_LOGLEVEL_ALL:
+ tmp[i].loglevel_type = LTTNG_EVENT_LOGLEVEL_ALL;
+ break;
+ case LTTNG_UST_LOGLEVEL_RANGE:
+ tmp[i].loglevel_type = LTTNG_EVENT_LOGLEVEL_RANGE;
+ break;
+ case LTTNG_UST_LOGLEVEL_SINGLE:
+ tmp[i].loglevel_type = LTTNG_EVENT_LOGLEVEL_SINGLE;
break;
}
i++;
}
break;
}
+#if 0
case LTTNG_DOMAIN_UST_PID_FOLLOW_CHILDREN:
case LTTNG_DOMAIN_UST_EXEC_NAME:
case LTTNG_DOMAIN_UST_PID:
- ret = LTTCOMM_NOT_IMPLEMENTED;
- goto error;
+#endif
default:
ret = LTTCOMM_UNKNOWN_DOMAIN;
goto error;
}
break;
}
+#if 0
case LTTNG_DOMAIN_UST_PID_FOLLOW_CHILDREN:
case LTTNG_DOMAIN_UST_EXEC_NAME:
case LTTNG_DOMAIN_UST_PID:
- ret = LTTCOMM_NOT_IMPLEMENTED;
- goto error;
+#endif
default:
ret = LTTCOMM_UNKNOWN_DOMAIN;
goto error;
channel_name);
break;
}
+#if 0
case LTTNG_DOMAIN_UST_EXEC_NAME:
case LTTNG_DOMAIN_UST_PID:
case LTTNG_DOMAIN_UST_PID_FOLLOW_CHILDREN:
+#endif
default:
- ret = LTTCOMM_NOT_IMPLEMENTED;
+ ret = LTTCOMM_UND;
goto error;
}
break;
}
+#if 0
case LTTNG_DOMAIN_UST_EXEC_NAME:
case LTTNG_DOMAIN_UST_PID:
case LTTNG_DOMAIN_UST_PID_FOLLOW_CHILDREN:
+#endif
default:
- ret = LTTCOMM_NOT_IMPLEMENTED;
+ ret = LTTCOMM_UND;
goto error;
}
}
break;
}
+#if 0
case LTTNG_DOMAIN_UST_EXEC_NAME:
case LTTNG_DOMAIN_UST_PID:
case LTTNG_DOMAIN_UST_PID_FOLLOW_CHILDREN:
+#endif
default:
- ret = LTTCOMM_NOT_IMPLEMENTED;
+ ret = LTTCOMM_UND;
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)
}
break;
}
+#if 0
case LTTNG_DOMAIN_UST_EXEC_NAME:
case LTTNG_DOMAIN_UST_PID:
case LTTNG_DOMAIN_UST_PID_FOLLOW_CHILDREN:
+#endif
default:
- ret = LTTCOMM_NOT_IMPLEMENTED;
+ ret = LTTCOMM_UND;
goto error;
}
break;
}
+#if 0
case LTTNG_DOMAIN_UST_EXEC_NAME:
case LTTNG_DOMAIN_UST_PID:
case LTTNG_DOMAIN_UST_PID_FOLLOW_CHILDREN:
+#endif
default:
- ret = LTTCOMM_NOT_IMPLEMENTED;
+ ret = LTTCOMM_UND;
goto error;
}
}
break;
default:
- ret = LTTCOMM_NOT_IMPLEMENTED;
+ ret = LTTCOMM_UND;
goto error;
}
*/
ret = notify_thread_pipe(kernel_poll_pipe[1]);
if (ret < 0) {
- perror("write kernel poll pipe");
+ PERROR("write kernel poll pipe");
}
ret = session_destroy(session);
}
break;
}
+ case LTTNG_DOMAIN_UST:
+ {
+ struct lttng_ust_calibrate ucalibrate;
+
+ ucalibrate.type = calibrate->type;
+ ret = ust_app_calibrate_glb(&ucalibrate);
+ if (ret < 0) {
+ ret = LTTCOMM_UST_CALIBRATE_FAIL;
+ goto error;
+ }
+ break;
+ }
default:
- /* TODO: Userspace tracing */
- ret = LTTCOMM_NOT_IMPLEMENTED;
+ ret = LTTCOMM_UND;
goto error;
}
break;
default:
/* TODO: Userspace tracing */
- ret = LTTCOMM_NOT_IMPLEMENTED;
+ ret = LTTCOMM_UND;
goto error;
}
break;
default:
*channels = NULL;
- ret = -LTTCOMM_NOT_IMPLEMENTED;
+ ret = -LTTCOMM_UND;
goto error;
}
break;
}
default:
- ret = -LTTCOMM_NOT_IMPLEMENTED;
+ ret = -LTTCOMM_UND;
goto error;
}
{
int ret = LTTCOMM_OK;
int need_tracing_session = 1;
+ int need_domain;
DBG("Processing client command %d", cmd_ctx->lsm->cmd_type);
- if (opt_no_kernel && cmd_ctx->lsm->domain.type == LTTNG_DOMAIN_KERNEL) {
+ switch (cmd_ctx->lsm->cmd_type) {
+ case LTTNG_CREATE_SESSION:
+ case LTTNG_DESTROY_SESSION:
+ case LTTNG_LIST_SESSIONS:
+ case LTTNG_LIST_DOMAINS:
+ case LTTNG_START_TRACE:
+ case LTTNG_STOP_TRACE:
+ need_domain = 0;
+ break;
+ default:
+ need_domain = 1;
+ }
+
+ if (opt_no_kernel && need_domain
+ && cmd_ctx->lsm->domain.type == LTTNG_DOMAIN_KERNEL) {
ret = LTTCOMM_KERN_NA;
goto error;
}
/* Commands that DO NOT need a session. */
switch (cmd_ctx->lsm->cmd_type) {
- case LTTNG_CALIBRATE:
case LTTNG_CREATE_SESSION:
+ case LTTNG_CALIBRATE:
case LTTNG_LIST_SESSIONS:
case LTTNG_LIST_TRACEPOINTS:
need_tracing_session = 0;
break;
}
+ if (!need_domain) {
+ goto skip_domain;
+ }
/*
* Check domain type for specific "pre-action".
*/
}
/* Kernel tracer check */
- if (kernel_tracer_fd == 0) {
+ if (kernel_tracer_fd == -1) {
/* Basically, load kernel tracer modules */
- init_kernel_tracer();
- if (kernel_tracer_fd == 0) {
- ret = LTTCOMM_KERN_NA;
+ ret = init_kernel_tracer();
+ if (ret != 0) {
goto error;
}
}
default:
break;
}
+skip_domain:
/*
* Check that the UID or GID match that of the tracing session.
ret = cmd_disable_event(cmd_ctx->session, cmd_ctx->lsm->domain.type,
cmd_ctx->lsm->u.disable.channel_name,
cmd_ctx->lsm->u.disable.name);
- ret = LTTCOMM_OK;
break;
}
case LTTNG_DISABLE_ALL_EVENT:
session_lock_list();
nr_sessions = lttng_sessions_count(cmd_ctx->creds.uid, cmd_ctx->creds.gid);
- if (nr_sessions == 0) {
- ret = LTTCOMM_NO_SESSION;
- session_unlock_list();
- goto error;
- }
+
ret = setup_lttng_msg(cmd_ctx, sizeof(struct lttng_session) * nr_sessions);
if (ret < 0) {
session_unlock_list();
*/
static void *thread_manage_clients(void *data)
{
- int sock = 0, ret, i, pollfd;
+ int sock = -1, ret, i, pollfd;
uint32_t revents, nb_fd;
struct command_ctx *cmd_ctx = NULL;
struct lttng_poll_event events;
* Notify parent pid that we are ready to accept command for client side.
*/
if (opt_sig_parent) {
- kill(ppid, SIGCHLD);
+ kill(ppid, SIGUSR1);
}
while (1) {
nb_fd = LTTNG_POLL_GETNB(&events);
/* Inifinite blocking call, waiting for transmission */
+ restart:
ret = lttng_poll_wait(&events, -1);
if (ret < 0) {
+ /*
+ * Restart interrupted system call.
+ */
+ if (errno == EINTR) {
+ goto restart;
+ }
goto error;
}
/* Allocate context command to process the client request */
cmd_ctx = zmalloc(sizeof(struct command_ctx));
if (cmd_ctx == NULL) {
- perror("zmalloc cmd_ctx");
+ PERROR("zmalloc cmd_ctx");
goto error;
}
/* Allocate data buffer for reception */
cmd_ctx->lsm = zmalloc(sizeof(struct lttcomm_session_msg));
if (cmd_ctx->lsm == NULL) {
- perror("zmalloc cmd_ctx->lsm");
+ PERROR("zmalloc cmd_ctx->lsm");
goto error;
}
sizeof(struct lttcomm_session_msg), &cmd_ctx->creds);
if (ret <= 0) {
DBG("Nothing recv() from client... continuing");
- close(sock);
+ ret = close(sock);
+ if (ret) {
+ PERROR("close");
+ }
+ sock = -1;
free(cmd_ctx);
continue;
}
}
/* End of transmission */
- close(sock);
+ ret = close(sock);
+ if (ret) {
+ PERROR("close");
+ }
+ sock = -1;
clean_command_ctx(&cmd_ctx);
}
error:
DBG("Client thread dying");
unlink(client_unix_sock_path);
- close(client_sock);
- close(sock);
+ if (client_sock >= 0) {
+ ret = close(client_sock);
+ if (ret) {
+ PERROR("close");
+ }
+ }
+ if (sock >= 0) {
+ ret = close(sock);
+ if (ret) {
+ PERROR("close");
+ }
+ }
lttng_poll_clean(&events);
clean_command_ctx(&cmd_ctx);
ret = chmod(client_unix_sock_path, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP);
if (ret < 0) {
ERR("Set file permissions failed: %s", client_unix_sock_path);
- perror("chmod");
+ PERROR("chmod");
goto end;
}
S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH);
if (ret < 0) {
ERR("Set file permissions failed: %s", apps_unix_sock_path);
- perror("chmod");
+ PERROR("chmod");
goto end;
}
*/
static int check_existing_daemon(void)
{
- if (access(client_unix_sock_path, F_OK) < 0 &&
- access(apps_unix_sock_path, F_OK) < 0) {
- return 0;
- }
-
/* Is there anybody out there ? */
if (lttng_session_daemon_alive()) {
return -EEXIST;
- } else {
- return 0;
}
+
+ return 0;
}
/*
* Set the tracing group gid onto the client socket.
*
* Race window between mkdir and chown is OK because we are going from more
- * permissive (root.root) to les permissive (root.tracing).
+ * permissive (root.root) to less permissive (root.tracing).
*/
static int set_permissions(char *rundir)
{
ret = chown(rundir, 0, gid);
if (ret < 0) {
ERR("Unable to set group on %s", rundir);
- perror("chown");
+ PERROR("chown");
+ }
+
+ /* Ensure tracing group can search the run dir */
+ ret = chmod(rundir, S_IRWXU | S_IXGRP | S_IXOTH);
+ if (ret < 0) {
+ ERR("Unable to set permissions on %s", rundir);
+ PERROR("chmod");
}
/* lttng client socket path */
ret = chown(client_unix_sock_path, 0, gid);
if (ret < 0) {
ERR("Unable to set group on %s", client_unix_sock_path);
- perror("chown");
+ PERROR("chown");
}
/* kconsumer error socket path */
ret = chown(kconsumer_data.err_unix_sock_path, 0, gid);
if (ret < 0) {
ERR("Unable to set group on %s", kconsumer_data.err_unix_sock_path);
- perror("chown");
+ PERROR("chown");
}
/* 64-bit ustconsumer error socket path */
ret = chown(ustconsumer64_data.err_unix_sock_path, 0, gid);
if (ret < 0) {
ERR("Unable to set group on %s", ustconsumer64_data.err_unix_sock_path);
- perror("chown");
+ PERROR("chown");
}
/* 32-bit ustconsumer compat32 error socket path */
ret = chown(ustconsumer32_data.err_unix_sock_path, 0, gid);
if (ret < 0) {
ERR("Unable to set group on %s", ustconsumer32_data.err_unix_sock_path);
- perror("chown");
+ PERROR("chown");
}
DBG("All permissions are set");
/*
* Create the pipe used to wake up the kernel thread.
+ * Closed in cleanup().
*/
static int create_kernel_poll_pipe(void)
{
/*
* Create the application command pipe to wake thread_manage_apps.
+ * Closed in cleanup().
*/
static int create_apps_cmd_pipe(void)
{
DBG3("Creating LTTng run directory: %s", rundir);
- ret = mkdir(rundir, S_IRWXU | S_IRWXG );
+ ret = mkdir(rundir, S_IRWXU);
if (ret < 0) {
if (errno != EEXIST) {
ERR("Unable to create %s", rundir);
switch (consumer_data->type) {
case LTTNG_CONSUMER_KERNEL:
- snprintf(path, PATH_MAX, KCONSUMERD_PATH, rundir);
+ snprintf(path, PATH_MAX, DEFAULT_KCONSUMERD_PATH, rundir);
break;
case LTTNG_CONSUMER64_UST:
- snprintf(path, PATH_MAX, USTCONSUMERD64_PATH, rundir);
+ snprintf(path, PATH_MAX, DEFAULT_USTCONSUMERD64_PATH, rundir);
break;
case LTTNG_CONSUMER32_UST:
- snprintf(path, PATH_MAX, USTCONSUMERD32_PATH, rundir);
+ snprintf(path, PATH_MAX, DEFAULT_USTCONSUMERD32_PATH, rundir);
break;
default:
ERR("Consumer type unknown");
DBG2("Creating consumer directory: %s", path);
- ret = mkdir(path, S_IRWXU | S_IRWXG);
+ ret = mkdir(path, S_IRWXU);
if (ret < 0) {
if (errno != EEXIST) {
ERR("Failed to create %s", path);
{
switch (sig) {
case SIGPIPE:
- DBG("SIGPIPE caugth");
+ DBG("SIGPIPE caught");
return;
case SIGINT:
- DBG("SIGINT caugth");
+ DBG("SIGINT caught");
stop_threads();
break;
case SIGTERM:
- DBG("SIGTERM caugth");
+ DBG("SIGTERM caught");
stop_threads();
break;
default:
sigset_t sigset;
if ((ret = sigemptyset(&sigset)) < 0) {
- perror("sigemptyset");
+ PERROR("sigemptyset");
return ret;
}
sa.sa_mask = sigset;
sa.sa_flags = 0;
if ((ret = sigaction(SIGTERM, &sa, NULL)) < 0) {
- perror("sigaction");
+ PERROR("sigaction");
return ret;
}
if ((ret = sigaction(SIGINT, &sa, NULL)) < 0) {
- perror("sigaction");
+ PERROR("sigaction");
return ret;
}
if ((ret = sigaction(SIGPIPE, &sa, NULL)) < 0) {
- perror("sigaction");
+ PERROR("sigaction");
return ret;
}
ret = setrlimit(RLIMIT_NOFILE, &lim);
if (ret < 0) {
- perror("failed to set open files limit");
+ PERROR("failed to set open files limit");
}
}
void *status;
const char *home_path;
+ init_kernel_workarounds();
+
rcu_register_thread();
/* Create thread quit pipe */
if (opt_daemon) {
ret = daemon(0, 0);
if (ret < 0) {
- perror("daemon");
+ PERROR("daemon");
goto error;
}
}
is_root = !getuid();
if (is_root) {
- rundir = strdup(LTTNG_RUNDIR);
+ rundir = strdup(DEFAULT_LTTNG_RUNDIR);
/* Create global run dir with root access */
ret = create_lttng_rundir(rundir);
/* Setup kernel consumerd path */
snprintf(kconsumer_data.err_unix_sock_path, PATH_MAX,
- KCONSUMERD_ERR_SOCK_PATH, rundir);
+ DEFAULT_KCONSUMERD_ERR_SOCK_PATH, rundir);
snprintf(kconsumer_data.cmd_unix_sock_path, PATH_MAX,
- KCONSUMERD_CMD_SOCK_PATH, rundir);
+ DEFAULT_KCONSUMERD_CMD_SOCK_PATH, rundir);
DBG2("Kernel consumer err path: %s",
kconsumer_data.err_unix_sock_path);
* Create rundir from home path. This will create something like
* $HOME/.lttng
*/
- ret = asprintf(&rundir, LTTNG_HOME_RUNDIR, home_path);
+ ret = asprintf(&rundir, DEFAULT_LTTNG_HOME_RUNDIR, home_path);
if (ret < 0) {
ret = -ENOMEM;
goto error;
/* 32 bits consumerd path setup */
snprintf(ustconsumer32_data.err_unix_sock_path, PATH_MAX,
- USTCONSUMERD32_ERR_SOCK_PATH, rundir);
+ DEFAULT_USTCONSUMERD32_ERR_SOCK_PATH, rundir);
snprintf(ustconsumer32_data.cmd_unix_sock_path, PATH_MAX,
- USTCONSUMERD32_CMD_SOCK_PATH, rundir);
+ DEFAULT_USTCONSUMERD32_CMD_SOCK_PATH, rundir);
DBG2("UST consumer 32 bits err path: %s",
ustconsumer32_data.err_unix_sock_path);
/* 64 bits consumerd path setup */
snprintf(ustconsumer64_data.err_unix_sock_path, PATH_MAX,
- USTCONSUMERD64_ERR_SOCK_PATH, rundir);
+ DEFAULT_USTCONSUMERD64_ERR_SOCK_PATH, rundir);
snprintf(ustconsumer64_data.cmd_unix_sock_path, PATH_MAX,
- USTCONSUMERD64_CMD_SOCK_PATH, rundir);
+ DEFAULT_USTCONSUMERD64_CMD_SOCK_PATH, rundir);
DBG2("UST consumer 64 bits err path: %s",
ustconsumer64_data.err_unix_sock_path);
ret = pthread_create(&client_thread, NULL,
thread_manage_clients, (void *) NULL);
if (ret != 0) {
- perror("pthread_create clients");
+ PERROR("pthread_create clients");
goto exit_client;
}
ret = pthread_create(&dispatch_thread, NULL,
thread_dispatch_ust_registration, (void *) NULL);
if (ret != 0) {
- perror("pthread_create dispatch");
+ PERROR("pthread_create dispatch");
goto exit_dispatch;
}
ret = pthread_create(®_apps_thread, NULL,
thread_registration_apps, (void *) NULL);
if (ret != 0) {
- perror("pthread_create registration");
+ PERROR("pthread_create registration");
goto exit_reg_apps;
}
ret = pthread_create(&apps_thread, NULL,
thread_manage_apps, (void *) NULL);
if (ret != 0) {
- perror("pthread_create apps");
+ PERROR("pthread_create apps");
goto exit_apps;
}
ret = pthread_create(&kernel_thread, NULL,
thread_manage_kernel, (void *) NULL);
if (ret != 0) {
- perror("pthread_create kernel");
+ PERROR("pthread_create kernel");
goto exit_kernel;
}
ret = pthread_join(kernel_thread, &status);
if (ret != 0) {
- perror("pthread_join");
+ PERROR("pthread_join");
goto error; /* join error, exit without cleanup */
}
exit_kernel:
ret = pthread_join(apps_thread, &status);
if (ret != 0) {
- perror("pthread_join");
+ PERROR("pthread_join");
goto error; /* join error, exit without cleanup */
}
exit_apps:
ret = pthread_join(reg_apps_thread, &status);
if (ret != 0) {
- perror("pthread_join");
+ PERROR("pthread_join");
goto error; /* join error, exit without cleanup */
}
exit_reg_apps:
ret = pthread_join(dispatch_thread, &status);
if (ret != 0) {
- perror("pthread_join");
+ PERROR("pthread_join");
goto error; /* join error, exit without cleanup */
}
exit_dispatch:
ret = pthread_join(client_thread, &status);
if (ret != 0) {
- perror("pthread_join");
+ PERROR("pthread_join");
goto error; /* join error, exit without cleanup */
}
ret = join_consumer_thread(&kconsumer_data);
if (ret != 0) {
- perror("join_consumer");
+ PERROR("join_consumer");
goto error; /* join error, exit without cleanup */
}
projects / lttng-tools.git / blobdiff