X-Git-Url: https://git.lttng.org/?p=lttng-tools.git;a=blobdiff_plain;f=ltt-sessiond%2Fmain.c;h=9b76a56adce2486efca5aecd66f29b2aca1343e3;hp=f2205e4b12edd2f39f407f8be74afae8aa0ee992;hb=4e332453e14dd64400835b60c0a93c3629e173d3;hpb=d6f421500e248dee6c9b8ccac863a3840d4fbff6

diff --git a/ltt-sessiond/main.c b/ltt-sessiond/main.c
index f2205e4b1..9b76a56ad 100644
--- a/ltt-sessiond/main.c
+++ b/ltt-sessiond/main.c
@@ -40,10 +40,18 @@
 #include "liblttsessiondcomm.h"
 #include "ltt-sessiond.h"
 #include "lttngerr.h"
+#include "kernel-ctl.h"
 #include "session.h"
 #include "trace.h"
 #include "traceable-app.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[] = DEFAULT_TRACING_GROUP;
@@ -52,19 +60,19 @@ const char default_global_apps_pipe[] = DEFAULT_GLOBAL_APPS_PIPE;
 
 /* Static functions */
 static int check_existing_daemon(void);
-static int connect_app(pid_t pid);
+static int ust_connect_app(pid_t pid);
 static int init_daemon_socket(void);
 static int notify_apps(const char* name);
-static int process_client_msg(int sock, struct lttcomm_session_msg*);
+static int process_client_msg(struct command_ctx *cmd_ctx);
 static int send_unix_sock(int sock, void *buf, size_t len);
 static int set_signal_handler(void);
 static int set_permissions(void);
-static int setup_data_buffer(char **buf, size_t size, struct lttcomm_lttng_msg *llm);
+static int setup_lttng_msg(struct command_ctx *cmd_ctx, size_t size);
 static int create_lttng_rundir(void);
 static int set_kconsumerd_sockets(void);
 static void cleanup(void);
-static void copy_common_data(struct lttcomm_lttng_msg *llm, struct lttcomm_session_msg *lsm);
 static void sighandler(int sig);
+static void clean_command_ctx(struct command_ctx *cmd_ctx);
 
 static void *thread_manage_clients(void *data);
 static void *thread_manage_apps(void *data);
@@ -88,8 +96,7 @@ static char kconsumerd_cmd_unix_sock_path[PATH_MAX];	/* kconsumerd command Unix
 static int client_sock;
 static int apps_sock;
 static int kconsumerd_err_sock;
-
-static struct ltt_session *current_session;
+static int kernel_tracer_fd;
 
 /*
  *  thread_manage_kconsumerd
@@ -135,6 +142,9 @@ static void *thread_manage_apps(void *data)
 	int sock, ret;
 
 	/* TODO: Something more elegant is needed but fine for now */
+	/* FIXME: change all types to either uint8_t, uint32_t, uint64_t
+	 * for 32-bit vs 64-bit compat processes. */
+	/* replicate in ust with version number */
 	struct {
 		int reg;	/* 1:register, 0:unregister */
 		pid_t pid;
@@ -143,15 +153,16 @@ static void *thread_manage_apps(void *data)
 
 	DBG("[thread] Manage apps started");
 
-	/* Notify all applications to register */
-	notify_apps(default_global_apps_pipe);
-
 	ret = lttcomm_listen_unix_sock(apps_sock);
 	if (ret < 0) {
 		goto error;
 	}
 
+	/* Notify all applications to register */
+	notify_apps(default_global_apps_pipe);
+
 	while (1) {
+		DBG("Accepting application registration");
 		/* Blocking call, waiting for transmission */
 		sock = lttcomm_accept_unix_sock(apps_sock);
 		if (sock < 0) {
@@ -197,7 +208,7 @@ error:
 static void *thread_manage_clients(void *data)
 {
 	int sock, ret;
-	struct lttcomm_session_msg lsm;
+	struct command_ctx *cmd_ctx;
 
 	DBG("[thread] Manage client started");
 
@@ -215,31 +226,54 @@ static void *thread_manage_clients(void *data)
 
 	while (1) {
 		/* Blocking call, waiting for transmission */
+		DBG("Accepting client command ...");
 		sock = lttcomm_accept_unix_sock(client_sock);
 		if (sock < 0) {
 			goto error;
 		}
 
+		/* Allocate context command to process the client request */
+		cmd_ctx = malloc(sizeof(struct command_ctx));
+
+		/* Allocate data buffer for reception */
+		cmd_ctx->lsm = malloc(sizeof(struct lttcomm_session_msg));
+		cmd_ctx->llm = NULL;
+		cmd_ctx->session = NULL;
+
 		/*
 		 * Data is received from the lttng client. The struct
-		 * lttcomm_session_msg (lsm) contains the command and data
-		 * request of the client.
+		 * lttcomm_session_msg (lsm) contains the command and data request of
+		 * the client.
 		 */
-		ret = lttcomm_recv_unix_sock(sock, &lsm, sizeof(lsm));
+		DBG("Receiving data from client ...");
+		ret = lttcomm_recv_unix_sock(sock, cmd_ctx->lsm, sizeof(struct lttcomm_session_msg));
 		if (ret <= 0) {
 			continue;
 		}
 
-		/* This function dispatch the work to the LTTng or UST libs
-		 * and then sends back the response to the client. This is needed
-		 * because there might be more then one lttcomm_lttng_msg to
-		 * send out so process_client_msg do both jobs.
+		/*
+		 * This function dispatch the work to the kernel or userspace tracer
+		 * libs and fill the lttcomm_lttng_msg data structure of all the needed
+		 * informations for the client. The command context struct contains
+		 * everything this function may needs.
 		 */
-		ret = process_client_msg(sock, &lsm);
+		ret = process_client_msg(cmd_ctx);
 		if (ret < 0) {
+			/* 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);
 			continue;
 		}
+
+		DBG("Sending response (size: %d, retcode: %d)",
+				cmd_ctx->lttng_msg_size, cmd_ctx->llm->ret_code);
+		ret = send_unix_sock(sock, cmd_ctx->llm, cmd_ctx->lttng_msg_size);
+		if (ret < 0) {
+			ERR("Failed to send data back to client");
+		}
+
+		clean_command_ctx(cmd_ctx);
 	}
 
 error:
@@ -264,7 +298,27 @@ static int send_unix_sock(int sock, void *buf, size_t len)
 }
 
 /*
- * 	connect_app
+ *  clean_command_ctx
+ *
+ *  Free memory of a command context structure.
+ */
+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);
+		}
+		if (cmd_ctx->lsm) {
+			free(cmd_ctx->lsm);
+		}
+		free(cmd_ctx);
+		cmd_ctx = NULL;
+	}
+}
+
+/*
+ * 	ust_connect_app
  *
  * 	Return a socket connected to the libust communication socket
  * 	of the application identified by the pid.
@@ -272,7 +326,7 @@ static int send_unix_sock(int sock, void *buf, size_t len)
  * 	If the pid is not found in the traceable list,
  * 	return -1 to indicate error.
  */
-static int connect_app(pid_t pid)
+static int ust_connect_app(pid_t pid)
 {
 	int sock;
 	struct ltt_traceable_app *lta;
@@ -327,371 +381,355 @@ error:
 }
 
 /*
- *  ust_create_trace
+ *  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.
  *
- *  Create an userspace trace using pid.
- *  This trace is then appended to the current session
- *  ust trace list.
+ *  Return total size of the buffer pointed by buf.
  */
-static int ust_create_trace(pid_t pid)
+static int setup_lttng_msg(struct command_ctx *cmd_ctx, size_t size)
 {
-	int sock, ret;
-	struct ltt_ust_trace *trace;
+	int ret, buf_size, trace_name_size;
 
-	DBG("Creating trace for pid %d", pid);
+	/*
+	 * Check for the trace_name. If defined, it's part of the payload data of
+	 * the llm structure.
+	 */
+	trace_name_size = strlen(cmd_ctx->lsm->trace_name);
+	buf_size = trace_name_size + size;
 
-	trace = malloc(sizeof(struct ltt_ust_trace));
-	if (trace == NULL) {
+	cmd_ctx->llm = malloc(sizeof(struct lttcomm_lttng_msg) + buf_size);
+	if (cmd_ctx->llm == NULL) {
 		perror("malloc");
-		ret = -1;
+		ret = -ENOMEM;
 		goto error;
 	}
 
-	/* Init */
-	trace->pid = pid;
-	trace->shmid = 0;
-	/* NOTE: to be removed. Trace name will no longer be
-	 * required for LTTng userspace tracer. For now, we set it
-	 * to 'auto' for API compliance.
-	 */
-	snprintf(trace->name, 5, "auto");
-
-	/* Connect to app using ustctl API */
-	sock = connect_app(pid);
-	if (sock < 0) {
-		ret = LTTCOMM_NO_TRACEABLE;
-		goto error;
+	/* Copy common data */
+	cmd_ctx->llm->cmd_type = cmd_ctx->lsm->cmd_type;
+	cmd_ctx->llm->pid = cmd_ctx->lsm->pid;
+	if (!uuid_is_null(cmd_ctx->lsm->session_uuid)) {
+		uuid_copy(cmd_ctx->llm->session_uuid, cmd_ctx->lsm->session_uuid);
 	}
 
-	ret = ustctl_create_trace(sock, trace->name);
-	if (ret < 0) {
-		ret = LTTCOMM_CREATE_FAIL;
-		goto error;
-	}
+	cmd_ctx->llm->trace_name_offset = trace_name_size;
+	cmd_ctx->llm->data_size = size;
+	cmd_ctx->lttng_msg_size = sizeof(struct lttcomm_lttng_msg) + buf_size;
 
-	/* Check if current session is valid */
-	if (current_session) {
-		cds_list_add(&trace->list, &current_session->ust_traces);
-		current_session->ust_trace_count++;
-	}
+	/* Copy trace name to the llm structure. Begining of the payload. */
+	memcpy(cmd_ctx->llm->payload, cmd_ctx->lsm->trace_name, trace_name_size);
+
+	return buf_size;
 
 error:
 	return ret;
 }
 
 /*
- *  ust_start_trace
+ * 	process_client_msg
  *
- *  Start a trace. This trace, identified by the pid, must be
- *  in the current session ust_traces list.
+ *  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 ust_start_trace(pid_t pid)
+static int process_client_msg(struct command_ctx *cmd_ctx)
 {
-	int sock, ret;
-	struct ltt_ust_trace *trace;
+	int ret;
 
-	DBG("Starting trace for pid %d", pid);
+	DBG("Processing client command %d", cmd_ctx->lsm->cmd_type);
 
-	trace = find_session_ust_trace_by_pid(current_session, pid);
-	if (trace == NULL) {
-		ret = LTTCOMM_NO_TRACE;
-		goto error;
+	/* Check command that needs a session */
+	switch (cmd_ctx->lsm->cmd_type) {
+	case LTTNG_CREATE_SESSION:
+	case LTTNG_LIST_SESSIONS:
+	case UST_LIST_APPS:
+		break;
+	default:
+		cmd_ctx->session = find_session_by_uuid(cmd_ctx->lsm->session_uuid);
+		if (cmd_ctx->session == NULL) {
+			ret = LTTCOMM_SELECT_SESS;
+			goto error;
+		}
+		break;
 	}
 
-	/* Connect to app using ustctl API */
-	sock = connect_app(pid);
-	if (sock < 0) {
-		ret = LTTCOMM_NO_TRACEABLE;
-		goto error;
+	/* Check command for kernel tracing */
+	switch (cmd_ctx->lsm->cmd_type) {
+	case KERNEL_CREATE_SESSION:
+	case KERNEL_CREATE_CHANNEL:
+	case KERNEL_DISABLE_EVENT:
+	case KERNEL_ENABLE_EVENT:
+	case KERNEL_OPEN_METADATA:
+	case KERNEL_START_TRACE:
+	case KERNEL_STOP_TRACE:
+		/* TODO: reconnect to kernel tracer to check if
+		 * it's loadded */
+		if (kernel_tracer_fd == 0) {
+			ret = LTTCOMM_KERN_NA;
+			goto error;
+		}
+		break;
 	}
 
-	ret = ustctl_start_trace(sock, "auto");
-	if (ret < 0) {
-		ret = LTTCOMM_START_FAIL;
-		goto error;
+	/* Connect to ust apps if available pid */
+	if (cmd_ctx->lsm->pid > 0) {
+		/* Connect to app using ustctl API */
+		cmd_ctx->ust_sock = ust_connect_app(cmd_ctx->lsm->pid);
+		if (cmd_ctx->ust_sock < 0) {
+			ret = LTTCOMM_NO_TRACEABLE;
+			goto error;
+		}
 	}
 
-error:
-	return ret;
-}
-
-/*
- *  ust_stop_trace
- *
- *  Stop a trace. This trace, identified by the pid, must be
- *  in the current session ust_traces list.
- */
-static int ust_stop_trace(pid_t pid)
-{
-	int sock, ret;
-	struct ltt_ust_trace *trace;
+	/* Process by command type */
+	switch (cmd_ctx->lsm->cmd_type) {
+	case KERNEL_CREATE_SESSION:
+	{
+		ret = setup_lttng_msg(cmd_ctx, 0);
+		if (ret < 0) {
+			goto setup_error;
+		}
 
-	DBG("Stopping trace for pid %d", pid);
+		DBG("Creating kernel session");
 
-	trace = find_session_ust_trace_by_pid(current_session, pid);
-	if (trace == NULL) {
-		ret = LTTCOMM_NO_TRACE;
-		goto error;
-	}
-
-	/* Connect to app using ustctl API */
-	sock = connect_app(pid);
-	if (sock < 0) {
-		ret = LTTCOMM_NO_TRACEABLE;
-		goto error;
-	}
+		ret = kernel_create_session(cmd_ctx, kernel_tracer_fd);
+		if (ret < 0) {
+			ret = LTTCOMM_KERN_SESS_FAIL;
+			goto error;
+		}
 
-	ret = ustctl_stop_trace(sock, trace->name);
-	if (ret < 0) {
-		ret = LTTCOMM_STOP_FAIL;
-		goto error;
+		ret = LTTCOMM_OK;
+		break;
 	}
+	case KERNEL_CREATE_CHANNEL:
+	{
+		ret = setup_lttng_msg(cmd_ctx, 0);
+		if (ret < 0) {
+			goto setup_error;
+		}
 
-error:
-	return ret;
-}
+		DBG("Creating kernel session");
 
-/*
- *  copy_common_data
- *
- *  Copy common data between lttcomm_lttng_msg and lttcomm_session_msg
- */
-static void copy_common_data(struct lttcomm_lttng_msg *llm, struct lttcomm_session_msg *lsm)
-{
-	llm->cmd_type = lsm->cmd_type;
-	llm->pid = lsm->pid;
+		ret = kernel_create_channel(cmd_ctx);
+		if (ret < 0) {
+			ret = LTTCOMM_KERN_CHAN_FAIL;
+			goto error;
+		}
 
-	/* Manage uuid */
-	if (!uuid_is_null(lsm->session_id)) {
-		uuid_copy(llm->session_id, lsm->session_id);
+		ret = LTTCOMM_OK;
+		break;
 	}
+	case KERNEL_ENABLE_EVENT:
+	{
+		/* Setup lttng message with no payload */
+		ret = setup_lttng_msg(cmd_ctx, 0);
+		if (ret < 0) {
+			goto setup_error;
+		}
 
-	strncpy(llm->trace_name, lsm->trace_name, strlen(llm->trace_name));
-	llm->trace_name[strlen(llm->trace_name) - 1] = '\0';
-}
+		DBG("Enabling kernel event %s", cmd_ctx->lsm->u.event.event_name);
 
-/*
- *  setup_data_buffer
- *
- *  Setup the outgoing data buffer for the response
- *  data allocating the right amount of memory.
- *
- *  Return total size of the buffer pointed by buf.
- */
-static int setup_data_buffer(char **buf, size_t s_data, struct lttcomm_lttng_msg *llm)
-{
-	int ret = 0;
-	size_t buf_size;
+		ret = kernel_enable_event(cmd_ctx->session->kernel_session->channel, cmd_ctx->lsm->u.event.event_name);
+		if (ret < 0) {
+			ret = LTTCOMM_KERN_ENABLE_FAIL;
+			goto error;
+		}
 
-	buf_size = sizeof(struct lttcomm_lttng_msg) + s_data;
-	*buf = malloc(buf_size);
-	if (*buf == NULL) {
-		perror("malloc");
-		ret = -1;
-		goto error;
+		ret = LTTCOMM_OK;
+		break;
 	}
-
-	/* Setup lttcomm_lttng_msg data and copy
-	 * it to the newly allocated buffer.
-	 */
-	llm->size_payload = s_data;
-	memcpy(*buf, llm, sizeof(struct lttcomm_lttng_msg));
-
-	return buf_size;
-
-error:
-	return ret;
-}
-
-/*
- * 	process_client_msg
- *
- * 	This takes the lttcomm_session_msg struct and process the command requested
- * 	by the client. It then creates response(s) and send it back to the
- * 	given socket (sock).
- *
- * 	Return any error encountered or 0 for success.
- */
-static int process_client_msg(int sock, struct lttcomm_session_msg *lsm)
-{
-	int ret;
-	int buf_size;
-	size_t header_size;
-	char *send_buf = NULL;
-	struct lttcomm_lttng_msg llm;
-
-	DBG("Processing client message");
-
-	/* Copy common data to identify the response
-	 * on the lttng client side.
-	 */
-	copy_common_data(&llm, lsm);
-
-	/* Check command that needs a session */
-	if (lsm->cmd_type != LTTNG_CREATE_SESSION &&
-		lsm->cmd_type != LTTNG_LIST_SESSIONS &&
-		lsm->cmd_type != UST_LIST_APPS)
+	case KERNEL_OPEN_METADATA:
 	{
-		current_session = find_session_by_uuid(lsm->session_id);
-		if (current_session == NULL) {
-			ret = LTTCOMM_SELECT_SESS;
-			goto end;
+		/* Setup lttng message with no payload */
+		ret = setup_lttng_msg(cmd_ctx, 0);
+		if (ret < 0) {
+			goto setup_error;
 		}
-	}
 
-	/* Default return code.
-	 * In our world, everything is OK... right? ;)
-	 */
-	llm.ret_code = LTTCOMM_OK;
+		DBG("Open kernel metadata");
 
-	header_size = sizeof(struct lttcomm_lttng_msg);
+		ret = kernel_open_metadata(cmd_ctx->session->kernel_session);
+		if (ret < 0) {
+			ret = LTTCOMM_KERN_META_FAIL;
+			goto error;
+		}
 
-	/* Process by command type */
-	switch (lsm->cmd_type) {
-		case LTTNG_CREATE_SESSION:
-		{
-			ret = create_session(lsm->session_name, &llm.session_id);
-			if (ret < 0) {
-				if (ret == -1) {
-					ret = LTTCOMM_EXIST_SESS;
-				} else {
-					ret = LTTCOMM_FATAL;
-				}
-				goto end;
-			}
+		ret = LTTCOMM_OK;
+		break;
+	}
+	case LTTNG_CREATE_SESSION:
+	{
+		/* Setup lttng message with no payload */
+		ret = setup_lttng_msg(cmd_ctx, 0);
+		if (ret < 0) {
+			goto setup_error;
+		}
 
-			buf_size = setup_data_buffer(&send_buf, 0, &llm);
-			if (buf_size < 0) {
+		ret = create_session(cmd_ctx->lsm->session_name, &cmd_ctx->llm->session_uuid);
+		if (ret < 0) {
+			if (ret == -1) {
+				ret = LTTCOMM_EXIST_SESS;
+			} else {
 				ret = LTTCOMM_FATAL;
-				goto end;
 			}
-
-			break;
+			goto error;
 		}
-		case LTTNG_DESTROY_SESSION:
-		{
-			ret = destroy_session(&lsm->session_id);
-			if (ret < 0) {
-				ret = LTTCOMM_NO_SESS;
-			} else {
-				ret = LTTCOMM_OK;
-			}
 
-			/* No auxiliary data so only send the llm struct. */
-			goto end;
+		ret = LTTCOMM_OK;
+		break;
+	}
+	case LTTNG_DESTROY_SESSION:
+	{
+		/* Setup lttng message with no payload */
+		ret = setup_lttng_msg(cmd_ctx, 0);
+		if (ret < 0) {
+			goto setup_error;
 		}
-		case LTTNG_LIST_TRACES:
-		{
-			unsigned int trace_count = get_trace_count_per_session(current_session);
 
-			if (trace_count == 0) {
-				ret = LTTCOMM_NO_TRACE;
-				goto end;
-			}
+		ret = destroy_session(&cmd_ctx->lsm->session_uuid);
+		if (ret < 0) {
+			ret = LTTCOMM_NO_SESS;
+			goto error;
+		}
 
-			buf_size = setup_data_buffer(&send_buf,
-					sizeof(struct lttng_trace) * trace_count, &llm);
-			if (buf_size < 0) {
-				ret = LTTCOMM_FATAL;
-				goto end;
-			}
+		ret = LTTCOMM_OK;
+		break;
+	}
+	case LTTNG_LIST_TRACES:
+	{
+		unsigned int trace_count;
 
-			get_traces_per_session(current_session, (struct lttng_trace *)(send_buf + header_size));
-			break;
+		trace_count = get_trace_count_per_session(cmd_ctx->session);
+		if (trace_count == 0) {
+			ret = LTTCOMM_NO_TRACE;
+			goto error;
 		}
-		case UST_CREATE_TRACE:
-		{
-			ret = ust_create_trace(lsm->pid);
-			if (ret < 0) {
-				/* If -1 is returned from ust_create_trace, malloc
-				 * failed so it's pretty much a fatal error.
-				 */
-				ret = LTTCOMM_FATAL;
-				goto end;
-			}
 
-			/* No auxiliary data so only send the llm struct. */
-			goto end;
+		ret = setup_lttng_msg(cmd_ctx, sizeof(struct lttng_trace) * trace_count);
+		if (ret < 0) {
+			goto setup_error;
 		}
-		case UST_LIST_APPS:
-		{
-			unsigned int app_count = get_app_count();
-			/* Stop right now if no apps */
-			if (app_count == 0) {
-				ret = LTTCOMM_NO_APPS;
-				goto end;
-			}
 
-			/* Setup data buffer and details for transmission */
-			buf_size = setup_data_buffer(&send_buf,
-					sizeof(pid_t) * app_count, &llm);
-			if (buf_size < 0) {
-				ret = LTTCOMM_FATAL;
-				goto end;
-			}
+		get_traces_per_session(cmd_ctx->session,
+				(struct lttng_trace *)(cmd_ctx->llm->payload));
 
-			get_app_list_pids((pid_t *)(send_buf + header_size));
+		ret = LTTCOMM_OK;
+		break;
+	}
+	case UST_CREATE_TRACE:
+	{
+		/* Setup lttng message with no payload */
+		ret = setup_lttng_msg(cmd_ctx, 0);
+		if (ret < 0) {
+			goto setup_error;
+		}
 
-			break;
+		ret = ust_create_trace(cmd_ctx);
+		if (ret < 0) {
+			goto setup_error;
 		}
-		case UST_START_TRACE:
-		{
-			ret = ust_start_trace(lsm->pid);
+		break;
+	}
+	case UST_LIST_APPS:
+	{
+		unsigned int app_count;
 
-			/* No auxiliary data so only send the llm struct. */
-			goto end;
+		app_count = get_app_count();
+		DBG("Traceable application count : %d", app_count);
+		if (app_count == 0) {
+			ret = LTTCOMM_NO_APPS;
+			goto error;
 		}
-		case UST_STOP_TRACE:
-		{
-			ret = ust_stop_trace(lsm->pid);
 
-			/* No auxiliary data so only send the llm struct. */
-			goto end;
+		ret = setup_lttng_msg(cmd_ctx, sizeof(pid_t) * app_count);
+		if (ret < 0) {
+			goto setup_error;
 		}
-		case LTTNG_LIST_SESSIONS:
-		{
-			unsigned int session_count = get_session_count();
-			/* Stop right now if no session */
-			if (session_count == 0) {
-				ret = LTTCOMM_NO_SESS;
-				goto end;
-			}
 
-			/* Setup data buffer and details for transmission */
-			buf_size = setup_data_buffer(&send_buf,
-					(sizeof(struct lttng_session) * session_count), &llm);
-			if (buf_size < 0) {
-				ret = LTTCOMM_FATAL;
-				goto end;
-			}
+		get_app_list_pids((pid_t *)(cmd_ctx->llm->payload));
 
-			get_lttng_session((struct lttng_session *)(send_buf + header_size));
+		ret = LTTCOMM_OK;
+		break;
+	}
+	case UST_START_TRACE:
+	{
+		/* Setup lttng message with no payload */
+		ret = setup_lttng_msg(cmd_ctx, 0);
+		if (ret < 0) {
+			goto setup_error;
+		}
 
-			break;
+		ret = ust_start_trace(cmd_ctx);
+		if (ret < 0) {
+			goto setup_error;
 		}
-		default:
-		{
-			/* Undefined command */
-			ret = LTTCOMM_UND;
-			goto end;
+		break;
+	}
+	case UST_STOP_TRACE:
+	{
+		/* Setup lttng message with no payload */
+		ret = setup_lttng_msg(cmd_ctx, 0);
+		if (ret < 0) {
+			goto setup_error;
 		}
+
+		ret = ust_stop_trace(cmd_ctx);
+		if (ret < 0) {
+			goto setup_error;
+		}
+		break;
 	}
+	case LTTNG_LIST_SESSIONS:
+	{
+		unsigned int session_count;
 
-	ret = send_unix_sock(sock, send_buf, buf_size);
+		session_count = get_session_count();
+		if (session_count == 0) {
+			ret = LTTCOMM_NO_SESS;
+			goto error;
+		}
+
+		ret = setup_lttng_msg(cmd_ctx, sizeof(struct lttng_session) * session_count);
+		if (ret < 0) {
+			goto setup_error;
+		}
+
+		get_lttng_session((struct lttng_session *)(cmd_ctx->llm->payload));
 
-	if (send_buf != NULL) {
-		free(send_buf);
+		ret = LTTCOMM_OK;
+		break;
 	}
+	default:
+		/* Undefined command */
+		ret = setup_lttng_msg(cmd_ctx, 0);
+		if (ret < 0) {
+			goto setup_error;
+		}
+
+		ret = LTTCOMM_UND;
+		break;
+	}
+
+	/* Set return code */
+	cmd_ctx->llm->ret_code = ret;
 
 	return ret;
 
-end:
-	DBG("Return code to client %d", ret);
+error:
+	if (cmd_ctx->llm == NULL) {
+		DBG("Missing llm structure. Allocating one.");
+		if (setup_lttng_msg(cmd_ctx, 0) < 0) {
+			goto setup_error;
+		}
+	}
 	/* Notify client of error */
-	llm.ret_code = ret;
-	llm.size_payload = 0;
-	send_unix_sock(sock, (void*) &llm, sizeof(llm));
+	cmd_ctx->llm->ret_code = ret;
 
+setup_error:
 	return ret;
 }
 
@@ -884,7 +922,10 @@ static const char *get_home_dir(void)
 /*
  *  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
+ *  less permissive (root.root) to more permissive (root.tracing).
  */
 static int set_permissions(void)
 {
@@ -949,6 +990,21 @@ error:
 	return ret;
 }
 
+/*
+ *  init_kernel_tracer
+ *
+ *  Setup necessary data for kernel tracer action.
+ */
+static void init_kernel_tracer(void)
+{
+	/* Set the global kernel tracer fd */
+	kernel_tracer_fd = open(DEFAULT_KERNEL_TRACER_PATH, O_RDWR);
+	if (kernel_tracer_fd < 0) {
+		WARN("No kernel tracer available");
+		kernel_tracer_fd = 0;
+	}
+}
+
 /*
  *  set_kconsumerd_sockets
  *
@@ -1090,6 +1146,9 @@ static void cleanup()
 	if (ret < 0) {
 		ERR("Unable to clean " LTTNG_RUNDIR);
 	}
+
+	// TODO Clean kernel trace fds
+	close(kernel_tracer_fd);
 }
 
 /*
@@ -1141,6 +1200,9 @@ int main(int argc, char **argv)
 		if (ret < 0) {
 			goto error;
 		}
+
+		/* Setup kernel tracer */
+		init_kernel_tracer();
 	} else {
 		if (strlen(apps_unix_sock_path) == 0) {
 			snprintf(apps_unix_sock_path, PATH_MAX,
@@ -1154,6 +1216,9 @@ int main(int argc, char **argv)
 		}
 	}
 
+	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
 	 */
@@ -1162,7 +1227,7 @@ int main(int argc, char **argv)
 		/* We do not goto error because we must not
 		 * cleanup() because a daemon is already running.
 		 */
-		return EXIT_FAILURE;
+		exit(EXIT_FAILURE);
 	}
 
 	if (set_signal_handler() < 0) {
@@ -1209,10 +1274,9 @@ int main(int argc, char **argv)
 	}
 
 	cleanup();
-	return 0;
+	exit(EXIT_SUCCESS);
 
 error:
 	cleanup();
-
-	return EXIT_FAILURE;
+	exit(EXIT_FAILURE);
 }