#include "session.h"
#include "traceable-app.h"
#include "lttng-kconsumerd.h"
-#include "libustctl.h"
#include "utils.h"
/*
*
* 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;
}
}
return ret;
}
+#ifdef DISABLED
/*
* ust_connect_app
*
return sock;
}
+#endif /* DISABLED */
/*
* notify_apps
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 - 2].fd = kernel_poll_pipe[0];
return nb_fd;
error:
- pthread_mutex_unlock(&session_list_ptr->lock);
+ unlock_session_list();
return -1;
}
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;
}
return ret;
}
+/*
+ * Using the session list, filled a lttng_session array to send back to the
+ * client for session listing.
+ *
+ * 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_client_msg
*
}
}
+#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) {
*/
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;
/* 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);
unlink(client_unix_sock_path);
- clean_command_ctx(cmd_ctx);
+ clean_command_ctx(&cmd_ctx);
return NULL;
}
int ret;
struct rlimit lim;
+ /* The kernel does not allowed an infinite limit for open files */
lim.rlim_cur = 65535;
lim.rlim_max = 65535;
/* Create thread quit pipe */
if (init_thread_quit_pipe() < 0) {
- /* No goto error because nothing is initialized at this point */
- exit(EXIT_FAILURE);
+ 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) {
/* TODO: Add --socket PATH option */
ERR("Can't get HOME directory for sockets creation.");
- goto error;
+ goto exit;
}
if (strlen(apps_unix_sock_path) == 0) {
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) {
error:
cleanup();
+
+exit:
exit(EXIT_FAILURE);
}
projects / lttng-tools.git / blobdiff