*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation; either version 2
- * of the License, or (at your option) any later version.
+ * as published by the Free Software Foundation; only version 2
+ * of the License.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
#include "session.h"
#include "traceable-app.h"
#include "lttng-kconsumerd.h"
-#include "libustctl.h"
#include "utils.h"
-/*
- * TODO:
- * teardown: signal SIGTERM handler -> write into pipe. Threads waits
- * with epoll on pipe and on other pipes/sockets for commands. Main
- * simply waits on pthread join.
- */
-
/* Const values */
const char default_home_dir[] = DEFAULT_HOME_DIR;
const char default_tracing_group[] = LTTNG_DEFAULT_TRACING_GROUP;
/* Variables */
int opt_verbose; /* Not static for lttngerr.h */
int opt_quiet; /* Not static for lttngerr.h */
+
const char *progname;
const char *opt_tracing_group;
static int opt_sig_parent;
static int kernel_tracer_fd;
static int kernel_poll_pipe[2];
+/*
+ * 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];
+
/* Pthread, Mutexes and Semaphores */
static pthread_t kconsumerd_thread;
static pthread_t apps_thread;
* mutex lock. The lock MUST be taken if you iterate over the list. The lock
* MUST NOT be taken if you call a public function in session.c.
*
- * The lock is nested inside the structure: session_list_ptr->lock.
+ * The lock is nested inside the structure: session_list_ptr->lock. Please use
+ * lock_session_list and unlock_session_list for lock acquisition.
*/
static struct ltt_session_list *session_list_ptr;
/*
- * teardown_kernel_session
+ * Init quit pipe.
*
- * Complete teardown of a kernel session. This free all data structure related
- * to a kernel session and update counter.
+ * Return -1 on error or 0 if all pipes are created.
+ */
+static int init_thread_quit_pipe(void)
+{
+ int ret;
+
+ ret = pipe2(thread_quit_pipe, O_CLOEXEC);
+ if (ret < 0) {
+ perror("thread quit pipe");
+ goto error;
+ }
+
+error:
+ return ret;
+}
+
+/*
+ * Complete teardown of a kernel session. This free all data structure related
+ * to a kernel session and update counter.
*/
static void teardown_kernel_session(struct ltt_session *session)
{
}
/*
- * cleanup
- *
- * Cleanup the daemon on exit
+ * Cleanup the daemon
*/
static void cleanup()
{
DBG("Cleaning up");
/* <fun> */
- MSG("\n%c[%d;%dm*** assert failed *** ==> %c[%dm", 27,1,31,27,0);
- MSG("%c[%d;%dmMatthew, BEET driven development works!%c[%dm",27,1,33,27,0);
+ MSG("\n%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> */
/* Stopping all threads */
DBG("Terminating all threads");
- pthread_cancel(client_thread);
- pthread_cancel(apps_thread);
- pthread_cancel(kernel_thread);
- if (kconsumerd_pid != 0) {
- pthread_cancel(kconsumerd_thread);
- }
-
- DBG("Unlinking all unix socket");
- unlink(client_unix_sock_path);
- unlink(apps_unix_sock_path);
- unlink(kconsumerd_err_unix_sock_path);
+ close(thread_quit_pipe[0]);
+ close(thread_quit_pipe[1]);
DBG("Removing %s directory", LTTNG_RUNDIR);
ret = asprintf(&cmd, "rm -rf " LTTNG_RUNDIR);
}
DBG("Cleaning up all session");
- /* Cleanup ALL session */
- cds_list_for_each_entry(sess, &session_list_ptr->head, list) {
- teardown_kernel_session(sess);
- // TODO complete session cleanup (including UST)
- }
/* Destroy session list mutex */
- pthread_mutex_destroy(&session_list_ptr->lock);
+ if (session_list_ptr != NULL) {
+ pthread_mutex_destroy(&session_list_ptr->lock);
+
+ /* Cleanup ALL session */
+ cds_list_for_each_entry(sess, &session_list_ptr->head, list) {
+ teardown_kernel_session(sess);
+ // TODO complete session cleanup (including UST)
+ }
+ }
+
+ pthread_mutex_destroy(&kconsumerd_pid_mutex);
DBG("Closing kernel fd");
close(kernel_tracer_fd);
- close(kernel_poll_pipe[0]);
- close(kernel_poll_pipe[1]);
}
/*
- * send_unix_sock
+ * Send data on a unix socket using the liblttsessiondcomm API.
*
- * Send data on a unix socket using the liblttsessiondcomm API.
- *
- * Return lttcomm error code.
+ * Return lttcomm error code.
*/
static int send_unix_sock(int sock, void *buf, size_t len)
{
}
/*
- * clean_command_ctx
- *
- * Free memory of a command context structure.
+ * Free memory of a command context structure.
*/
-static void clean_command_ctx(struct command_ctx *cmd_ctx)
+static void clean_command_ctx(struct command_ctx **cmd_ctx)
{
- DBG("Clean command context structure %p", cmd_ctx);
- if (cmd_ctx) {
- if (cmd_ctx->llm) {
- free(cmd_ctx->llm);
+ DBG("Clean command context structure");
+ if (*cmd_ctx) {
+ if ((*cmd_ctx)->llm) {
+ free((*cmd_ctx)->llm);
}
- if (cmd_ctx->lsm) {
- free(cmd_ctx->lsm);
+ if ((*cmd_ctx)->lsm) {
+ free((*cmd_ctx)->lsm);
}
- free(cmd_ctx);
- cmd_ctx = NULL;
+ free(*cmd_ctx);
+ *cmd_ctx = NULL;
}
}
/*
- * send_kconsumerd_channel_fds
- *
- * Send all stream fds of kernel channel to the consumer.
+ * Send all stream fds of kernel channel to the consumer.
*/
static int send_kconsumerd_channel_fds(int sock, struct ltt_kernel_channel *channel)
{
}
/*
- * send_kconsumerd_fds
- *
- * Send all stream fds of the kernel session to the consumer.
+ * Send all stream fds of the kernel session to the consumer.
*/
static int send_kconsumerd_fds(int sock, struct ltt_kernel_session *session)
{
return ret;
}
+#ifdef DISABLED
/*
- * ust_connect_app
- *
- * Return a socket connected to the libust communication socket
- * of the application identified by the pid.
+ * Return a socket connected to the libust communication socket of the
+ * application identified by the pid.
*
- * If the pid is not found in the traceable list,
- * return -1 to indicate error.
+ * If the pid is not found in the traceable list, return -1 to indicate error.
*/
static int ust_connect_app(pid_t pid)
{
return sock;
}
+#endif /* DISABLED */
/*
- * notify_apps
+ * Notify apps by writing 42 to a named pipe using name. Every applications
+ * waiting for a ltt-sessiond will be notified and re-register automatically to
+ * the session daemon.
*
- * Notify apps by writing 42 to a named pipe using name.
- * Every applications waiting for a ltt-sessiond will be notified
- * and re-register automatically to the session daemon.
- *
- * Return open or write error value.
+ * Return open or write error value.
*/
static int notify_apps(const char *name)
{
}
/*
- * setup_lttng_msg
- *
- * Setup the outgoing data buffer for the response (llm) by allocating the
- * right amount of memory and copying the original information from the lsm
- * structure.
+ * Setup the outgoing data buffer for the response (llm) by allocating the
+ * right amount of memory and copying the original information from the lsm
+ * structure.
*
- * Return total size of the buffer pointed by buf.
+ * Return total size of the buffer pointed by buf.
*/
static int setup_lttng_msg(struct command_ctx *cmd_ctx, size_t size)
{
}
/*
- * update_kernel_pollfd
- *
- * Update the kernel pollfd set of all channel fd available over
- * all tracing session. Add the wakeup pipe at the end of the set.
+ * Update the kernel pollfd set of all channel fd available over all tracing
+ * session. Add the wakeup pipe at the end of the set.
*/
static int update_kernel_pollfd(void)
{
int i = 0;
- unsigned int nb_fd = 1;
+ /*
+ * The wakup pipe and the quit pipe are needed so the number of fds starts
+ * at 2 for those pipes.
+ */
+ unsigned int nb_fd = 2;
struct ltt_session *session;
struct ltt_kernel_channel *channel;
DBG("Updating kernel_pollfd");
/* Get the number of channel of all kernel session */
- pthread_mutex_lock(&session_list_ptr->lock);
+ lock_session_list();
cds_list_for_each_entry(session, &session_list_ptr->head, list) {
lock_session(session);
if (session->kernel_session == NULL) {
}
unlock_session(session);
}
- pthread_mutex_unlock(&session_list_ptr->lock);
+ unlock_session_list();
/* Adding wake up pipe */
- kernel_pollfd[nb_fd - 1].fd = kernel_poll_pipe[0];
- kernel_pollfd[nb_fd - 1].events = POLLIN;
+ kernel_pollfd[nb_fd - 2].fd = kernel_poll_pipe[0];
+ kernel_pollfd[nb_fd - 2].events = POLLIN;
+
+ /* Adding the quit pipe */
+ kernel_pollfd[nb_fd - 1].fd = thread_quit_pipe[0];
return nb_fd;
error:
- pthread_mutex_unlock(&session_list_ptr->lock);
+ unlock_session_list();
return -1;
}
/*
- * update_kernel_stream
+ * Find the channel fd from 'fd' over all tracing session. When found, check
+ * for new channel stream and send those stream fds to the kernel consumer.
*
- * Find the channel fd from 'fd' over all tracing session. When found, check
- * for new channel stream and send those stream fds to the kernel consumer.
- *
- * Useful for CPU hotplug feature.
+ * Useful for CPU hotplug feature.
*/
static int update_kernel_stream(int fd)
{
DBG("Updating kernel streams for channel fd %d", fd);
- pthread_mutex_lock(&session_list_ptr->lock);
+ lock_session_list();
cds_list_for_each_entry(session, &session_list_ptr->head, list) {
lock_session(session);
if (session->kernel_session == NULL) {
}
end:
+ unlock_session_list();
if (session) {
unlock_session(session);
}
- pthread_mutex_unlock(&session_list_ptr->lock);
return ret;
}
/*
- * thread_manage_kernel
- *
- * This thread manage event coming from the kernel.
+ * This thread manage event coming from the kernel.
*
- * Features supported in this thread:
- * -) CPU Hotplug
+ * Features supported in this thread:
+ * -) CPU Hotplug
*/
static void *thread_manage_kernel(void *data)
{
continue;
}
+ /* Thread quit pipe has been closed. Killing thread. */
+ if (kernel_pollfd[nb_fd - 1].revents == POLLNVAL) {
+ goto error;
+ }
+
DBG("Kernel poll event triggered");
/*
* Check if the wake up pipe was triggered. If so, the kernel_pollfd
* must be updated.
*/
- switch (kernel_pollfd[nb_fd - 1].revents) {
+ switch (kernel_pollfd[nb_fd - 2].revents) {
case POLLIN:
ret = read(kernel_poll_pipe[0], &tmp, 1);
update_poll_flag = 1;
if (kernel_pollfd) {
free(kernel_pollfd);
}
+
+ close(kernel_poll_pipe[0]);
+ close(kernel_poll_pipe[1]);
return NULL;
}
/*
- * thread_manage_kconsumerd
- *
- * This thread manage the kconsumerd error sent
- * back to the session daemon.
+ * This thread manage the kconsumerd error sent back to the session daemon.
*/
static void *thread_manage_kconsumerd(void *data)
{
- int sock, ret;
+ int sock = 0, ret;
enum lttcomm_return_code code;
+ struct pollfd pollfd[2];
DBG("[thread] Manage kconsumerd started");
goto error;
}
+ /* First fd is always the quit pipe */
+ pollfd[0].fd = thread_quit_pipe[0];
+
+ /* Apps socket */
+ pollfd[1].fd = kconsumerd_err_sock;
+ pollfd[1].events = POLLIN;
+
+ /* Inifinite blocking call, waiting for transmission */
+ ret = poll(pollfd, 2, -1);
+ if (ret < 0) {
+ perror("poll kconsumerd thread");
+ goto error;
+ }
+
+ /* Thread quit pipe has been closed. Killing thread. */
+ if (pollfd[0].revents == POLLNVAL) {
+ goto error;
+ } else if (pollfd[1].revents == POLLERR) {
+ ERR("Kconsumerd err socket poll error");
+ goto error;
+ }
+
sock = lttcomm_accept_unix_sock(kconsumerd_err_sock);
if (sock < 0) {
goto error;
ERR("Kconsumerd return code : %s", lttcomm_get_readable_code(-code));
error:
- kconsumerd_pid = 0;
DBG("Kconsumerd thread dying");
+ if (kconsumerd_err_sock) {
+ close(kconsumerd_err_sock);
+ }
+ if (kconsumerd_cmd_sock) {
+ close(kconsumerd_cmd_sock);
+ }
+ if (sock) {
+ close(sock);
+ }
+
+ unlink(kconsumerd_err_unix_sock_path);
+ unlink(kconsumerd_cmd_unix_sock_path);
+
+ kconsumerd_pid = 0;
return NULL;
}
/*
- * thread_manage_apps
- *
* This thread manage the application socket communication
*/
static void *thread_manage_apps(void *data)
{
- int sock, ret;
+ int sock = 0, ret;
+ struct pollfd pollfd[2];
/* TODO: Something more elegant is needed but fine for now */
/* FIXME: change all types to either uint8_t, uint32_t, uint64_t
goto error;
}
+ /* First fd is always the quit pipe */
+ pollfd[0].fd = thread_quit_pipe[0];
+
+ /* Apps socket */
+ pollfd[1].fd = apps_sock;
+ pollfd[1].events = POLLIN;
+
/* Notify all applications to register */
notify_apps(default_global_apps_pipe);
while (1) {
DBG("Accepting application registration");
- /* Blocking call, waiting for transmission */
+
+ /* Inifinite blocking call, waiting for transmission */
+ ret = poll(pollfd, 2, -1);
+ if (ret < 0) {
+ perror("poll apps thread");
+ goto error;
+ }
+
+ /* Thread quit pipe has been closed. Killing thread. */
+ if (pollfd[0].revents == POLLNVAL) {
+ goto error;
+ } else if (pollfd[1].revents == POLLERR) {
+ ERR("Apps socket poll error");
+ goto error;
+ }
+
sock = lttcomm_accept_unix_sock(apps_sock);
if (sock < 0) {
goto error;
}
- /* Basic recv here to handle the very simple data
+ /*
+ * Basic recv here to handle the very simple data
* that the libust send to register (reg_msg).
*/
ret = recv(sock, ®_msg, sizeof(reg_msg), 0);
}
error:
+ DBG("Apps thread dying");
+ if (apps_sock) {
+ close(apps_sock);
+ }
+ if (sock) {
+ close(sock);
+ }
+ unlink(apps_unix_sock_path);
return NULL;
}
/*
- * spawn_kconsumerd_thread
- *
- * Start the thread_manage_kconsumerd. This must be done after a kconsumerd
- * exec or it will fails.
+ * Start the thread_manage_kconsumerd. This must be done after a kconsumerd
+ * exec or it will fails.
*/
static int spawn_kconsumerd_thread(void)
{
}
/*
- * spawn_kconsumerd
- *
- * Fork and exec a kernel consumer daemon (kconsumerd).
+ * Fork and exec a kernel consumer daemon (kconsumerd).
*
- * NOTE: It is very important to fork a kconsumerd BEFORE opening any kernel
- * file descriptor using the libkernelctl or kernel-ctl functions. So, a
- * kernel consumer MUST only be spawned before creating a kernel session.
- *
- * Return pid if successful else -1.
+ * Return pid if successful else -1.
*/
static pid_t spawn_kconsumerd(void)
{
int ret;
pid_t pid;
+ const char *verbosity;
DBG("Spawning kconsumerd");
/*
* Exec kconsumerd.
*/
- execlp("ltt-kconsumerd", "ltt-kconsumerd", "--verbose", NULL);
+ if (opt_verbose > 1) {
+ verbosity = "--verbose";
+ } else {
+ verbosity = "--quiet";
+ }
+ execl(INSTALL_BIN_PATH "/ltt-kconsumerd", "ltt-kconsumerd", verbosity, NULL);
if (errno != 0) {
perror("kernel start consumer exec");
}
}
/*
- * start_kconsumerd
- *
- * Spawn the kconsumerd daemon and session daemon thread.
+ * Spawn the kconsumerd daemon and session daemon thread.
*/
static int start_kconsumerd(void)
{
}
/*
- * modprobe_kernel_modules
+ * modprobe_kernel_modules
*/
static int modprobe_kernel_modules(void)
{
}
/*
- * mount_debugfs
+ * mount_debugfs
*/
static int mount_debugfs(char *path)
{
}
/*
- * init_kernel_tracer
- *
- * Setup necessary data for kernel tracer action.
+ * Setup necessary data for kernel tracer action.
*/
static void init_kernel_tracer(void)
{
}
/*
- * start_kernel_trace
- *
- * Start tracing by creating trace directory and sending FDs to the kernel
- * consumer.
+ * Start tracing by creating trace directory and sending FDs to the kernel
+ * consumer.
*/
static int start_kernel_trace(struct ltt_kernel_session *session)
{
- int ret;
+ int ret = 0;
if (session->kconsumer_fds_sent == 0) {
ret = send_kconsumerd_fds(kconsumerd_cmd_sock, session);
}
/*
- * init_default_channel
- *
- * Allocate a channel structure and fill it.
+ * Allocate a channel structure and fill it.
*/
static struct lttng_channel *init_default_channel(void)
{
}
/*
- * create_kernel_session
- *
- * Create a kernel tracer session then create the default channel.
+ * Create a kernel tracer session then create the default channel.
*/
static int create_kernel_session(struct ltt_session *session)
{
int ret;
- struct lttng_channel *chan;
DBG("Creating kernel session");
goto error;
}
- chan = init_default_channel();
- if (chan == NULL) {
- ret = LTTCOMM_FATAL;
- goto error;
- }
-
ret = mkdir_recursive(session->path, S_IRWXU | S_IRWXG );
if (ret < 0) {
if (ret != EEXIST) {
}
}
- DBG("Creating default kernel channel %s", DEFAULT_CHANNEL_NAME);
-
- ret = kernel_create_channel(session->kernel_session, chan, session->path);
- if (ret < 0) {
- ret = LTTCOMM_KERN_CHAN_FAIL;
- goto error;
- }
-
- ret = notify_kernel_pollfd();
-
error:
return ret;
}
/*
- * process_client_msg
+ * Using the session list, filled a lttng_session array to send back to the
+ * client for session listing.
*
- * Process the command requested by the lttng client within the command
- * context structure. This function make sure that the return structure (llm)
- * is set and ready for transmission before returning.
+ * The session list lock MUST be acquired before calling this function. Use
+ * lock_session_list() and unlock_session_list().
+ */
+static void list_lttng_sessions(struct lttng_session *sessions)
+{
+ int i = 0;
+ struct ltt_session *session;
+
+ DBG("Getting all available session");
+ /*
+ * Iterate over session list and append data after the control struct in
+ * the buffer.
+ */
+ cds_list_for_each_entry(session, &session_list_ptr->head, list) {
+ strncpy(sessions[i].path, session->path, PATH_MAX);
+ strncpy(sessions[i].name, session->name, NAME_MAX);
+ i++;
+ }
+}
+
+/*
+ * Process the command requested by the lttng client within the command
+ * context structure. This function make sure that the return structure (llm)
+ * is set and ready for transmission before returning.
*
* Return any error encountered or 0 for success.
*/
static int process_client_msg(struct command_ctx *cmd_ctx)
{
- int ret;
+ int ret = LTTCOMM_OK;
DBG("Processing client command %d", cmd_ctx->lsm->cmd_type);
*/
switch (cmd_ctx->lsm->cmd_type) {
case LTTNG_KERNEL_ADD_CONTEXT:
- case LTTNG_KERNEL_CREATE_CHANNEL:
case LTTNG_KERNEL_DISABLE_ALL_EVENT:
case LTTNG_KERNEL_DISABLE_CHANNEL:
case LTTNG_KERNEL_DISABLE_EVENT:
}
}
+#ifdef DISABLED
/* Connect to ust apps if available pid */
if (cmd_ctx->lsm->pid > 0) {
/* Connect to app using ustctl API */
goto error;
}
}
+#endif /* DISABLED */
/* Process by command type */
switch (cmd_ctx->lsm->cmd_type) {
int found = 0, no_event = 0;
struct ltt_kernel_channel *chan;
struct ltt_kernel_event *event;
+ struct lttng_kernel_context ctx;
/* Setup lttng message with no payload */
ret = setup_lttng_msg(cmd_ctx, 0);
no_event = 1;
}
+ /* Create Kernel context */
+ ctx.ctx = cmd_ctx->lsm->u.context.ctx.ctx;
+ ctx.u.perf_counter.type = cmd_ctx->lsm->u.context.ctx.u.perf_counter.type;
+ ctx.u.perf_counter.config = cmd_ctx->lsm->u.context.ctx.u.perf_counter.config;
+ strncpy(ctx.u.perf_counter.name,
+ cmd_ctx->lsm->u.context.ctx.u.perf_counter.name,
+ sizeof(ctx.u.perf_counter.name));
+
if (strlen(cmd_ctx->lsm->u.context.channel_name) == 0) {
/* Go over all channels */
DBG("Adding context to all channels");
cds_list_for_each_entry(chan,
&cmd_ctx->session->kernel_session->channel_list.head, list) {
if (no_event) {
- ret = kernel_add_channel_context(chan,
- &cmd_ctx->lsm->u.context.ctx);
+ ret = kernel_add_channel_context(chan, &ctx);
if (ret < 0) {
continue;
}
} else {
event = get_kernel_event_by_name(cmd_ctx->lsm->u.context.event_name, chan);
if (event != NULL) {
- ret = kernel_add_event_context(event,
- &cmd_ctx->lsm->u.context.ctx);
+ ret = kernel_add_event_context(event, &ctx);
if (ret < 0) {
ret = LTTCOMM_KERN_CONTEXT_FAIL;
goto error;
}
if (no_event) {
- ret = kernel_add_channel_context(chan,
- &cmd_ctx->lsm->u.context.ctx);
+ ret = kernel_add_channel_context(chan, &ctx);
if (ret < 0) {
ret = LTTCOMM_KERN_CONTEXT_FAIL;
goto error;
} else {
event = get_kernel_event_by_name(cmd_ctx->lsm->u.context.event_name, chan);
if (event != NULL) {
- ret = kernel_add_event_context(event,
- &cmd_ctx->lsm->u.context.ctx);
+ ret = kernel_add_event_context(event, &ctx);
if (ret < 0) {
ret = LTTCOMM_KERN_CONTEXT_FAIL;
goto error;
ret = LTTCOMM_OK;
break;
}
- case LTTNG_KERNEL_CREATE_CHANNEL:
- {
- /* Setup lttng message with no payload */
- ret = setup_lttng_msg(cmd_ctx, 0);
- if (ret < 0) {
- goto setup_error;
- }
-
- /* Kernel tracer */
- DBG("Creating kernel channel");
-
- ret = kernel_create_channel(cmd_ctx->session->kernel_session,
- &cmd_ctx->lsm->u.channel.chan, cmd_ctx->session->path);
- if (ret < 0) {
- ret = LTTCOMM_KERN_CHAN_FAIL;
- goto error;
- }
-
- ret = notify_kernel_pollfd();
- if (ret < 0) {
- ret = LTTCOMM_FATAL;
- goto error;
- }
-
- ret = LTTCOMM_OK;
- break;
- }
case LTTNG_KERNEL_DISABLE_CHANNEL:
{
struct ltt_kernel_channel *chan;
chan = get_kernel_channel_by_name(cmd_ctx->lsm->u.enable.channel_name,
cmd_ctx->session->kernel_session);
if (chan == NULL) {
- ret = LTTCOMM_KERN_CHAN_NOT_FOUND;
- goto error;
+ /* Channel not found, creating it */
+ DBG("Creating kernel channel");
+
+ ret = kernel_create_channel(cmd_ctx->session->kernel_session,
+ &cmd_ctx->lsm->u.channel.chan, cmd_ctx->session->path);
+ if (ret < 0) {
+ ret = LTTCOMM_KERN_CHAN_FAIL;
+ goto error;
+ }
+
+ /* Notify kernel thread that there is a new channel */
+ ret = notify_kernel_pollfd();
+ if (ret < 0) {
+ ret = LTTCOMM_FATAL;
+ goto error;
+ }
} else if (chan->enabled == 0) {
ret = kernel_enable_channel(chan);
if (ret < 0) {
}
case LTTNG_KERNEL_ENABLE_EVENT:
{
- struct ltt_kernel_channel *chan;
+ char *channel_name;
+ struct ltt_kernel_channel *kchan;
struct ltt_kernel_event *ev;
+ struct lttng_channel *chan;
/* Setup lttng message with no payload */
ret = setup_lttng_msg(cmd_ctx, 0);
goto setup_error;
}
- chan = get_kernel_channel_by_name(cmd_ctx->lsm->u.enable.channel_name,
- cmd_ctx->session->kernel_session);
- if (chan == NULL) {
- ret = LTTCOMM_KERN_CHAN_NOT_FOUND;
- goto error;
- }
+ channel_name = cmd_ctx->lsm->u.enable.channel_name;
+
+ do {
+ kchan = get_kernel_channel_by_name(channel_name,
+ cmd_ctx->session->kernel_session);
+ if (kchan == NULL) {
+ DBG("Creating default channel");
- ev = get_kernel_event_by_name(cmd_ctx->lsm->u.enable.event.name, chan);
+ chan = init_default_channel();
+ if (chan == NULL) {
+ ret = LTTCOMM_FATAL;
+ goto error;
+ }
+
+ ret = kernel_create_channel(cmd_ctx->session->kernel_session,
+ chan, cmd_ctx->session->path);
+ if (ret < 0) {
+ ret = LTTCOMM_KERN_CHAN_FAIL;
+ goto error;
+ }
+ }
+ } while (kchan == NULL);
+
+ ev = get_kernel_event_by_name(cmd_ctx->lsm->u.enable.event.name, kchan);
if (ev == NULL) {
DBG("Creating kernel event %s for channel %s.",
- cmd_ctx->lsm->u.enable.event.name, chan->channel->name);
- ret = kernel_create_event(&cmd_ctx->lsm->u.enable.event, chan);
+ cmd_ctx->lsm->u.enable.event.name, channel_name);
+ ret = kernel_create_event(&cmd_ctx->lsm->u.enable.event, kchan);
} else {
DBG("Enabling kernel event %s for channel %s.",
- cmd_ctx->lsm->u.enable.event.name, chan->channel->name);
+ cmd_ctx->lsm->u.enable.event.name, channel_name);
ret = kernel_enable_event(ev);
+ if (ret == -EEXIST) {
+ ret = LTTCOMM_KERN_EVENT_EXIST;
+ goto error;
+ }
}
if (ret < 0) {
case LTTNG_KERNEL_ENABLE_ALL_EVENT:
{
int pos, size;
- char *event_list, *event, *ptr;
- struct ltt_kernel_channel *chan;
+ char *event_list, *event, *ptr, *channel_name;
+ struct ltt_kernel_channel *kchan;
struct ltt_kernel_event *ev;
struct lttng_event ev_attr;
+ struct lttng_channel *chan;
/* Setup lttng message with no payload */
ret = setup_lttng_msg(cmd_ctx, 0);
DBG("Enabling all kernel event");
- chan = get_kernel_channel_by_name(cmd_ctx->lsm->u.enable.channel_name,
- cmd_ctx->session->kernel_session);
- if (chan == NULL) {
- ret = LTTCOMM_KERN_CHAN_NOT_FOUND;
- goto error;
- }
+ channel_name = cmd_ctx->lsm->u.enable.channel_name;
+
+ do {
+ kchan = get_kernel_channel_by_name(channel_name,
+ cmd_ctx->session->kernel_session);
+ if (kchan == NULL) {
+ DBG("Creating default channel");
+
+ chan = init_default_channel();
+ if (chan == NULL) {
+ ret = LTTCOMM_FATAL;
+ goto error;
+ }
+
+ ret = kernel_create_channel(cmd_ctx->session->kernel_session,
+ chan, cmd_ctx->session->path);
+ if (ret < 0) {
+ ret = LTTCOMM_KERN_CHAN_FAIL;
+ goto error;
+ }
+ }
+ } while (kchan == NULL);
/* For each event in the kernel session */
- cds_list_for_each_entry(ev, &chan->events_list.head, list) {
+ cds_list_for_each_entry(ev, &kchan->events_list.head, list) {
DBG("Enabling kernel event %s for channel %s.",
- ev->event->name, chan->channel->name);
+ ev->event->name, channel_name);
ret = kernel_enable_event(ev);
if (ret < 0) {
continue;
ptr = event_list;
while ((size = sscanf(ptr, "event { name = %m[^;]; };%n\n", &event, &pos)) == 1) {
- ev = get_kernel_event_by_name(event, chan);
+ ev = get_kernel_event_by_name(event, kchan);
if (ev == NULL) {
strncpy(ev_attr.name, event, LTTNG_SYM_NAME_LEN);
/* Default event type for enable all */
- ev_attr.type = LTTNG_EVENT_TRACEPOINTS;
+ ev_attr.type = LTTNG_EVENT_TRACEPOINT;
/* Enable each single tracepoint event */
- ret = kernel_create_event(&ev_attr, chan);
+ ret = kernel_create_event(&ev_attr, kchan);
if (ret < 0) {
/* Ignore error here and continue */
}
*/
case LTTNG_LIST_SESSIONS:
{
- unsigned int session_count;
+ lock_session_list();
- session_count = get_session_count();
- if (session_count == 0) {
+ if (session_list_ptr->count == 0) {
ret = LTTCOMM_NO_SESSION;
goto error;
}
- ret = setup_lttng_msg(cmd_ctx, sizeof(struct lttng_session) * session_count);
+ ret = setup_lttng_msg(cmd_ctx, sizeof(struct lttng_session) *
+ session_list_ptr->count);
if (ret < 0) {
goto setup_error;
}
- get_lttng_session((struct lttng_session *)(cmd_ctx->llm->payload));
+ /* Filled the session array */
+ list_lttng_sessions((struct lttng_session *)(cmd_ctx->llm->payload));
+
+ unlock_session_list();
ret = LTTCOMM_OK;
break;
}
/*
- * thread_manage_clients
- *
- * This thread manage all clients request using the unix
- * client socket for communication.
+ * This thread manage all clients request using the unix client socket for
+ * communication.
*/
static void *thread_manage_clients(void *data)
{
- int sock, ret;
- struct command_ctx *cmd_ctx;
+ int sock = 0, ret;
+ struct command_ctx *cmd_ctx = NULL;
+ struct pollfd pollfd[2];
DBG("[thread] Manage client started");
goto error;
}
+ /* First fd is always the quit pipe */
+ pollfd[0].fd = thread_quit_pipe[0];
+
+ /* Apps socket */
+ pollfd[1].fd = client_sock;
+ pollfd[1].events = POLLIN;
+
/* Notify parent pid that we are ready
* to accept command for client side.
*/
}
while (1) {
- /* Blocking call, waiting for transmission */
DBG("Accepting client command ...");
+
+ /* Inifinite blocking call, waiting for transmission */
+ ret = poll(pollfd, 2, -1);
+ if (ret < 0) {
+ perror("poll client thread");
+ goto error;
+ }
+
+ /* Thread quit pipe has been closed. Killing thread. */
+ if (pollfd[0].revents == POLLNVAL) {
+ goto error;
+ } else if (pollfd[1].revents == POLLERR) {
+ ERR("Client socket poll error");
+ goto error;
+ }
+
sock = lttcomm_accept_unix_sock(client_sock);
if (sock < 0) {
goto error;
/* TODO: Inform client somehow of the fatal error. At this point,
* ret < 0 means that a malloc failed (ENOMEM). */
/* Error detected but still accept command */
- clean_command_ctx(cmd_ctx);
+ clean_command_ctx(&cmd_ctx);
continue;
}
ERR("Failed to send data back to client");
}
- clean_command_ctx(cmd_ctx);
+ clean_command_ctx(&cmd_ctx);
/* End of transmission */
close(sock);
}
error:
+ DBG("Client thread dying");
+ if (client_sock) {
+ close(client_sock);
+ }
+ if (sock) {
+ close(sock);
+ }
+
+ unlink(client_unix_sock_path);
+
+ clean_command_ctx(&cmd_ctx);
return NULL;
}
opt_quiet = 1;
break;
case 'v':
- opt_verbose = 1;
+ /* Verbose level can increase using multiple -v */
+ opt_verbose += 1;
break;
default:
/* Unknown option or other error.
}
/*
- * init_daemon_socket
- *
- * Creates the two needed socket by the daemon.
+ * Creates the two needed socket by the daemon.
* apps_sock - The communication socket for all UST apps.
* client_sock - The communication of the cli tool (lttng).
*/
}
/*
- * check_existing_daemon
- *
- * Check if the global socket is available.
- * If yes, error is returned.
+ * Check if the global socket is available. If yes, error is returned.
*/
static int check_existing_daemon()
{
}
/*
- * set_permissions
- *
- * Set the tracing group gid onto the client socket.
+ * 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).
+ * 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)
{
}
/*
- * create_kernel_poll_pipe
- *
- * Create the pipe used to wake up the kernel thread.
+ * Create the pipe used to wake up the kernel thread.
*/
static int create_kernel_poll_pipe(void)
{
}
/*
- * create_lttng_rundir
- *
- * Create the lttng run directory needed for all
- * global sockets and pipe.
+ * Create the lttng run directory needed for all global sockets and pipe.
*/
static int create_lttng_rundir(void)
{
}
/*
- * set_kconsumerd_sockets
- *
- * Setup sockets and directory needed by the kconsumerd
- * communication with the session daemon.
+ * Setup sockets and directory needed by the kconsumerd communication with the
+ * session daemon.
*/
static int set_kconsumerd_sockets(void)
{
}
/*
- * sighandler
- *
- * Signal handler for the daemon
+ * Signal handler for the daemon
*/
static void sighandler(int sig)
{
}
/*
- * set_signal_handler
- *
- * Setup signal handler for :
+ * Setup signal handler for :
* SIGINT, SIGTERM, SIGPIPE
*/
static int set_signal_handler(void)
}
/*
- * set_ulimit
- *
- * Set open files limit to unlimited. This daemon can open a large number of
- * file descriptors in order to consumer multiple kernel traces.
+ * Set open files limit to unlimited. This daemon can open a large number of
+ * file descriptors in order to consumer multiple kernel traces.
*/
static void set_ulimit(void)
{
int ret;
struct rlimit lim;
+ /* The kernel does not allowed an infinite limit for open files */
lim.rlim_cur = 65535;
lim.rlim_max = 65535;
void *status;
const char *home_path;
+ /* Create thread quit pipe */
+ if (init_thread_quit_pipe() < 0) {
+ goto exit;
+ }
+
/* Parse arguments */
progname = argv[0];
if ((ret = parse_args(argc, argv) < 0)) {
- goto error;
+ goto exit;
}
/* Daemonize */
ret = daemon(0, 0);
if (ret < 0) {
perror("daemon");
- goto error;
+ goto exit;
}
}
if (is_root) {
ret = create_lttng_rundir();
if (ret < 0) {
- goto error;
+ goto exit;
}
if (strlen(apps_unix_sock_path) == 0) {
snprintf(client_unix_sock_path, PATH_MAX,
DEFAULT_GLOBAL_CLIENT_UNIX_SOCK);
}
-
- ret = set_kconsumerd_sockets();
- if (ret < 0) {
- goto error;
- }
-
- /* Setup kernel tracer */
- init_kernel_tracer();
-
- /* Set ulimit for open files */
- set_ulimit();
} else {
home_path = get_home_dir();
if (home_path == NULL) {
- ERR("Can't get HOME directory for sockets creation.\n \
- Please specify --socket PATH.");
- goto error;
+ /* TODO: Add --socket PATH option */
+ ERR("Can't get HOME directory for sockets creation.");
+ goto exit;
}
if (strlen(apps_unix_sock_path) == 0) {
DBG("Client socket path %s", client_unix_sock_path);
DBG("Application socket path %s", apps_unix_sock_path);
- /* See if daemon already exist. If any of the two
- * socket needed by the daemon are present, this test fails
+ /*
+ * See if daemon already exist. If any of the two socket needed by the
+ * daemon are present, this test fails. However, if the daemon is killed
+ * with a SIGKILL, those unix socket must be unlinked by hand.
*/
if ((ret = check_existing_daemon()) == 0) {
ERR("Already running daemon.\n");
- /* We do not goto error because we must not
- * cleanup() because a daemon is already running.
+ /*
+ * We do not goto error because we must not cleanup() because a daemon
+ * is already running.
*/
- exit(EXIT_FAILURE);
+ goto exit;
+ }
+
+ /* After this point, we can safely call cleanup() so goto error is used */
+
+ /*
+ * These actions must be executed as root. We do that *after* setting up
+ * the sockets path because we MUST make the check for another daemon using
+ * those paths *before* trying to set the kernel consumer sockets and init
+ * kernel tracer.
+ */
+ if (is_root) {
+ ret = set_kconsumerd_sockets();
+ if (ret < 0) {
+ goto error;
+ }
+
+ /* Setup kernel tracer */
+ init_kernel_tracer();
+
+ /* Set ulimit for open files */
+ set_ulimit();
}
if (set_signal_handler() < 0) {
goto error;
}
- /* Get session list pointer */
+ /*
+ * Get session list pointer. This pointer MUST NOT be free().
+ * This list is statically declared in session.c
+ */
session_list_ptr = get_session_list();
while (1) {
error:
cleanup();
+
+exit:
exit(EXIT_FAILURE);
}