X-Git-Url: https://git.lttng.org/?p=lttng-tools.git;a=blobdiff_plain;f=ltt-sessiond%2Fmain.c;h=0effeb1f5ab51a0c91973505c7efd9629dee5a3c;hp=30b0edd0e75f6d6e46272fa9b98b807495c6c2ac;hb=2b1173d8cb43cb5d7c9ce3772dbdbef3436c407e;hpb=b1f11e69d7782029847845f0a5d018733c15a2f0

diff --git a/ltt-sessiond/main.c b/ltt-sessiond/main.c
index 30b0edd0e..0effeb1f5 100644
--- a/ltt-sessiond/main.c
+++ b/ltt-sessiond/main.c
@@ -28,14 +28,16 @@
 #include <stdlib.h>
 #include <string.h>
 #include <sys/ipc.h>
+#include <sys/mount.h>
 #include <sys/shm.h>
 #include <sys/socket.h>
 #include <sys/stat.h>
 #include <sys/types.h>
+#include <sys/time.h>
+#include <sys/resource.h>
 #include <unistd.h>
 
 #include <urcu/list.h>		/* URCU list library (-lurcu) */
-#include <ust/ustctl.h>		/* UST control lib (-lust) */
 #include <lttng/lttng.h>
 
 #include "liblttsessiondcomm.h"
@@ -46,6 +48,8 @@
 #include "session.h"
 #include "traceable-app.h"
 #include "lttng-kconsumerd.h"
+#include "libustctl.h"
+#include "utils.h"
 
 /*
  * TODO:
@@ -159,6 +163,7 @@ static void cleanup()
 		// TODO complete session cleanup (including UST)
 	}
 
+	DBG("Closing kernel fd");
 	close(kernel_tracer_fd);
 }
 
@@ -199,6 +204,101 @@ static void clean_command_ctx(struct command_ctx *cmd_ctx)
 	}
 }
 
+/*
+ *  send_kconsumerd_fds
+ *
+ *  Send all stream fds of the kernel session to the consumer.
+ */
+static int send_kconsumerd_fds(int sock, struct ltt_kernel_session *session)
+{
+	int ret;
+	size_t nb_fd;
+	struct ltt_kernel_stream *stream;
+	struct ltt_kernel_channel *chan;
+	struct lttcomm_kconsumerd_header lkh;
+	struct lttcomm_kconsumerd_msg lkm;
+
+	nb_fd = session->stream_count_global;
+
+	/* Setup header */
+	lkh.payload_size = (nb_fd + 1) * sizeof(struct lttcomm_kconsumerd_msg);
+	lkh.cmd_type = ADD_STREAM;
+
+	DBG("Sending kconsumerd header");
+
+	ret = lttcomm_send_unix_sock(sock, &lkh, sizeof(struct lttcomm_kconsumerd_header));
+	if (ret < 0) {
+		perror("send kconsumerd header");
+		goto error;
+	}
+
+	DBG("Sending metadata stream fd");
+
+	/* Send metadata stream fd first */
+	lkm.fd = session->metadata_stream_fd;
+	lkm.state = ACTIVE_FD;
+	lkm.max_sb_size = session->metadata->conf->attr.subbuf_size;
+	strncpy(lkm.path_name, session->metadata->pathname, PATH_MAX);
+
+	ret = lttcomm_send_fds_unix_sock(sock, &lkm, &lkm.fd, 1, sizeof(lkm));
+	if (ret < 0) {
+		perror("send kconsumerd fd");
+		goto error;
+	}
+
+	cds_list_for_each_entry(chan, &session->channel_list.head, list) {
+		cds_list_for_each_entry(stream, &chan->stream_list.head, list) {
+			lkm.fd = stream->fd;
+			lkm.state = stream->state;
+			lkm.max_sb_size = chan->channel->attr.subbuf_size;
+			strncpy(lkm.path_name, stream->pathname, PATH_MAX);
+
+			DBG("Sending fd %d to kconsumerd", lkm.fd);
+
+			ret = lttcomm_send_fds_unix_sock(sock, &lkm, &lkm.fd, 1, sizeof(lkm));
+			if (ret < 0) {
+				perror("send kconsumerd fd");
+				goto error;
+			}
+		}
+	}
+
+	DBG("Kconsumerd fds sent");
+
+	return 0;
+
+error:
+	return ret;
+}
+
+/*
+ *  create_trace_dir
+ *
+ *  Create the trace output directory.
+ */
+static int create_trace_dir(struct ltt_kernel_session *session)
+{
+	int ret;
+	struct ltt_kernel_channel *chan;
+
+	/* Create all channel directories */
+	cds_list_for_each_entry(chan, &session->channel_list.head, list) {
+		DBG("Creating trace directory at %s", chan->pathname);
+		ret = mkdir_recursive(chan->pathname, S_IRWXU | S_IRWXG );
+		if (ret < 0) {
+			if (ret != EEXIST) {
+				ERR("Trace directory creation error");
+				goto error;
+			}
+		}
+	}
+
+	return 0;
+
+error:
+	return ret;
+}
+
 /*
  * 	ust_connect_app
  *
@@ -224,7 +324,7 @@ static int ust_connect_app(pid_t pid)
 
 	sock = ustctl_connect_pid(lta->pid);
 	if (sock < 0) {
-		ERR("Fail connecting to the PID %d\n", pid);
+		ERR("Fail connecting to the PID %d", pid);
 	}
 
 	return sock;
@@ -273,14 +373,9 @@ error:
  */
 static int setup_lttng_msg(struct command_ctx *cmd_ctx, size_t size)
 {
-	int ret, buf_size, trace_name_size;
+	int ret, buf_size;
 
-	/*
-	 * 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;
+	buf_size = size;
 
 	cmd_ctx->llm = malloc(sizeof(struct lttcomm_lttng_msg) + buf_size);
 	if (cmd_ctx->llm == NULL) {
@@ -292,17 +387,10 @@ static int setup_lttng_msg(struct command_ctx *cmd_ctx, size_t size)
 	/* 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);
-	}
 
-	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;
 
-	/* 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:
@@ -486,12 +574,14 @@ static pid_t spawn_kconsumerd(void)
 	int ret;
 	pid_t pid;
 
+	DBG("Spawning kconsumerd");
+
 	pid = fork();
 	if (pid == 0) {
 		/*
 		 * Exec kconsumerd.
 		 */
-		execlp("kconsumerd", "kconsumerd", "--quiet", NULL);
+		execlp("ltt-kconsumerd", "ltt-kconsumerd", "--verbose", NULL);
 		if (errno != 0) {
 			perror("kernel start consumer exec");
 		}
@@ -518,21 +608,21 @@ static int start_kconsumerd(void)
 {
 	int ret;
 
-	DBG("Spawning kconsumerd");
-
 	pthread_mutex_lock(&kconsumerd_pid_mutex);
-	if (kconsumerd_pid == 0) {
-		ret = spawn_kconsumerd();
-		if (ret < 0) {
-			ERR("Spawning kconsumerd failed");
-			ret = LTTCOMM_KERN_CONSUMER_FAIL;
-			pthread_mutex_unlock(&kconsumerd_pid_mutex);
-			goto error;
-		}
+	if (kconsumerd_pid != 0) {
+		goto end;
+	}
 
-		/* Setting up the global kconsumerd_pid */
-		kconsumerd_pid = ret;
+	ret = spawn_kconsumerd();
+	if (ret < 0) {
+		ERR("Spawning kconsumerd failed");
+		ret = LTTCOMM_KERN_CONSUMER_FAIL;
+		pthread_mutex_unlock(&kconsumerd_pid_mutex);
+		goto error;
 	}
+
+	/* Setting up the global kconsumerd_pid */
+	kconsumerd_pid = ret;
 	pthread_mutex_unlock(&kconsumerd_pid_mutex);
 
 	DBG("Kconsumerd pid %d", ret);
@@ -544,6 +634,8 @@ static int start_kconsumerd(void)
 		goto error;
 	}
 
+end:
+	pthread_mutex_unlock(&kconsumerd_pid_mutex);
 	return 0;
 
 error:
@@ -551,89 +643,238 @@ error:
 }
 
 /*
- *  send_kconsumerd_fds
- *
- *  Send all stream fds of the kernel session to the consumer.
+ *  modprobe_kernel_modules
  */
-static int send_kconsumerd_fds(int sock, struct ltt_kernel_session *session)
+static int modprobe_kernel_modules(void)
 {
-	int ret, i = 0;
-	/* Plus one here for the metadata fd */
-	size_t nb_fd = session->stream_count_global + 1;
-	int fds[nb_fd];
-	struct ltt_kernel_stream *stream;
-	struct ltt_kernel_channel *chan;
-	struct lttcomm_kconsumerd_header lkh;
-	struct lttcomm_kconsumerd_msg buf[nb_fd];
-
-	/* Add metadata data */
-	fds[i] = session->metadata_stream_fd;
-	buf[i].fd = fds[i];
-	buf[i].state = ACTIVE_FD;
-	buf[i].max_sb_size = session->metadata->conf->subbuf_size;
-	strncpy(buf[i].path_name, session->metadata->pathname, PATH_MAX);
+	int ret = 0, i = 0;
+	char modprobe[256];
 
-	cds_list_for_each_entry(chan, &session->channel_list.head, list) {
-		cds_list_for_each_entry(stream, &chan->stream_list.head, list) {
-			i++;
-			fds[i] = stream->fd;
-			buf[i].fd = stream->fd;
-			buf[i].state = stream->state;
-			buf[i].max_sb_size = chan->channel->subbuf_size;
-			strncpy(buf[i].path_name, stream->pathname, PATH_MAX);
+	while (kernel_modules_list[i] != NULL) {
+		ret = snprintf(modprobe, sizeof(modprobe), "/sbin/modprobe %s",
+				kernel_modules_list[i]);
+		if (ret < 0) {
+			perror("snprintf modprobe");
+			goto error;
 		}
+		ret = system(modprobe);
+		if (ret < 0) {
+			ERR("Unable to load module %s", kernel_modules_list[i]);
+		}
+		DBG("Modprobe successfully %s", kernel_modules_list[i]);
+		i++;
 	}
 
-	/* Setup header */
-	lkh.payload_size = nb_fd * sizeof(struct lttcomm_kconsumerd_msg);
-	lkh.cmd_type = ADD_STREAM;
+error:
+	return ret;
+}
 
-	DBG("Sending kconsumerd header");
+/*
+ *  mount_debugfs
+ */
+static int mount_debugfs(char *path)
+{
+	int ret;
+	char *type = "debugfs";
 
-	ret = lttcomm_send_unix_sock(sock, &lkh, sizeof(struct lttcomm_kconsumerd_header));
+	ret = mkdir_recursive(path, S_IRWXU | S_IRWXG);
 	if (ret < 0) {
-		perror("send kconsumerd header");
 		goto error;
 	}
 
-	DBG("Sending all fds to kconsumerd");
+	ret = mount(type, path, type, 0, NULL);
+	if (ret < 0) {
+		perror("mount debugfs");
+		goto error;
+	}
+
+	DBG("Mounted debugfs successfully at %s", path);
+
+error:
+	return ret;
+}
+
+/*
+ *  init_kernel_tracer
+ *
+ *  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;
+	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;
+		}
+	}
+
+	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) {
+			goto error;
+		}
+	}
+
+	/* Modprobe lttng kernel modules */
+	ret = modprobe_kernel_modules();
+	if (ret < 0) {
+		goto error;
+	}
 
-	ret = lttcomm_send_fds_unix_sock(sock, buf, fds, nb_fd, lkh.payload_size);
+	/* Setup lttng kernel path */
+	ret = asprintf(&lttng_path, "%s/lttng", debugfs_path);
 	if (ret < 0) {
-		perror("send kconsumerd fds");
+		perror("asprintf lttng path");
 		goto error;
 	}
 
-	DBG("Kconsumerd fds sent");
+	/* 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;
+	}
 
-	return 0;
+	free(lttng_path);
+	free(debugfs_path);
+	DBG("Kernel tracer fd %d", kernel_tracer_fd);
+	return;
 
 error:
-	return ret;
+	if (lttng_path) {
+		free(lttng_path);
+	}
+	if (debugfs_path) {
+		free(debugfs_path);
+	}
+	WARN("No kernel tracer available");
+	kernel_tracer_fd = 0;
+	return;
 }
 
 /*
- *  create_trace_dir
+ *  start_kernel_trace
  *
- *  Create the trace output directory.
+ *  Start tracing by creating trace directory and sending FDs to the kernel
+ *  consumer.
  */
-static int create_trace_dir(struct ltt_kernel_session *session)
+static int start_kernel_trace(struct ltt_kernel_session *session)
 {
 	int ret;
-	struct ltt_kernel_channel *chan;
 
-	/* Create all channel directories */
-	cds_list_for_each_entry(chan, &session->channel_list.head, list) {
-		DBG("Creating trace directory at %s", chan->pathname);
-		ret = mkdir(chan->pathname, S_IRWXU | S_IRWXG );
+	/* Create trace directory */
+	ret = create_trace_dir(session);
+	if (ret < 0) {
+		if (ret == -EEXIST) {
+			ret = LTTCOMM_KERN_DIR_EXIST;
+		} else {
+			ret = LTTCOMM_KERN_DIR_FAIL;
+			goto error;
+		}
+	}
+
+	if (session->kconsumer_fds_sent == 0) {
+		ret = send_kconsumerd_fds(kconsumerd_cmd_sock, session);
 		if (ret < 0) {
-			perror("mkdir trace path");
-			ret = -errno;
+			ERR("Send kconsumerd fds failed");
+			ret = LTTCOMM_KERN_CONSUMER_FAIL;
 			goto error;
 		}
+
+		session->kconsumer_fds_sent = 1;
 	}
 
-	return 0;
+error:
+	return ret;
+}
+
+/*
+ *  init_default_channel
+ *
+ *  Allocate a channel structure and fill it.
+ */
+static struct lttng_channel *init_default_channel(void)
+{
+	struct lttng_channel *chan;
+
+	chan = malloc(sizeof(struct lttng_channel));
+	if (chan == NULL) {
+		perror("init channel malloc");
+		goto error;
+	}
+
+	if (snprintf(chan->name, NAME_MAX, DEFAULT_CHANNEL_NAME) < 0) {
+		perror("snprintf defautl channel name");
+		return NULL;
+	}
+
+	chan->attr.overwrite = DEFAULT_CHANNEL_OVERWRITE;
+	chan->attr.subbuf_size = DEFAULT_CHANNEL_SUBBUF_SIZE;
+	chan->attr.num_subbuf = DEFAULT_CHANNEL_SUBBUF_NUM;
+	chan->attr.switch_timer_interval = DEFAULT_CHANNEL_SWITCH_TIMER;
+	chan->attr.read_timer_interval = DEFAULT_CHANNEL_READ_TIMER;
+	chan->attr.output = DEFAULT_KERNEL_CHANNEL_OUTPUT;
+
+error:
+	return chan;
+}
+
+/*
+ *  create_kernel_session
+ *
+ *  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");
+
+	ret = kernel_create_session(session, kernel_tracer_fd);
+	if (ret < 0) {
+		ret = LTTCOMM_KERN_SESS_FAIL;
+		goto error;
+	}
+
+	chan = init_default_channel();
+	if (chan == NULL) {
+		ret = LTTCOMM_FATAL;
+		goto error;
+	}
+
+	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;
+	}
 
 error:
 	return ret;
@@ -654,40 +895,69 @@ static int process_client_msg(struct command_ctx *cmd_ctx)
 
 	DBG("Processing client command %d", cmd_ctx->lsm->cmd_type);
 
-	/* Check command that needs a session */
+	/* Listing commands don't need a session */
 	switch (cmd_ctx->lsm->cmd_type) {
 	case LTTNG_CREATE_SESSION:
 	case LTTNG_LIST_SESSIONS:
-	case KERNEL_LIST_EVENTS:
-	case UST_LIST_APPS:
+	case LTTNG_LIST_EVENTS:
+	case LTTNG_KERNEL_LIST_EVENTS:
+	case LTTNG_LIST_TRACEABLE_APPS:
 		break;
 	default:
-		cmd_ctx->session = find_session_by_uuid(cmd_ctx->lsm->session_uuid);
+		DBG("Getting session %s by name", cmd_ctx->lsm->session_name);
+		cmd_ctx->session = find_session_by_name(cmd_ctx->lsm->session_name);
 		if (cmd_ctx->session == NULL) {
-			ret = LTTCOMM_SELECT_SESS;
+			/* If session name not found */
+			if (cmd_ctx->lsm->session_name != NULL) {
+				ret = LTTCOMM_SESS_NOT_FOUND;
+			} else {	/* If no session name specified */
+				ret = LTTCOMM_SELECT_SESS;
+			}
 			goto error;
 		}
 		break;
 	}
 
-	/* Check command for kernel tracing */
+	/*
+	 * Check kernel command for kernel session.
+	 */
 	switch (cmd_ctx->lsm->cmd_type) {
-	case KERNEL_CREATE_SESSION:
-	case KERNEL_CREATE_CHANNEL:
-	case KERNEL_CREATE_STREAM:
-	case KERNEL_DISABLE_EVENT:
-	case KERNEL_ENABLE_EVENT:
-	case KERNEL_LIST_EVENTS:
-	case KERNEL_OPEN_METADATA:
-	case KERNEL_START_TRACE:
-	case KERNEL_STOP_TRACE:
-		/* TODO: reconnect to kernel tracer to check if
-		 * it's loadded */
+	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:
+	case LTTNG_KERNEL_ENABLE_ALL_EVENT:
+	case LTTNG_KERNEL_ENABLE_CHANNEL:
+	case LTTNG_KERNEL_ENABLE_EVENT:
+	case LTTNG_KERNEL_LIST_EVENTS:
+		/* Kernel tracer check */
 		if (kernel_tracer_fd == 0) {
-			ret = LTTCOMM_KERN_NA;
-			goto error;
+			init_kernel_tracer();
+			if (kernel_tracer_fd == 0) {
+				ret = LTTCOMM_KERN_NA;
+				goto error;
+			}
+		}
+
+		/* Need a session for kernel command */
+		if (cmd_ctx->lsm->cmd_type != LTTNG_KERNEL_LIST_EVENTS &&
+				cmd_ctx->session->kernel_session == NULL) {
+
+			ret = create_kernel_session(cmd_ctx->session);
+			if (ret < 0) {
+				ret = LTTCOMM_KERN_SESS_FAIL;
+				goto error;
+			}
+
+			/* Start the kernel consumer daemon */
+			if (kconsumerd_pid == 0) {
+				ret = start_kconsumerd();
+				if (ret < 0) {
+					goto error;
+				}
+			}
 		}
-		break;
 	}
 
 	/* Connect to ust apps if available pid */
@@ -702,40 +972,97 @@ static int process_client_msg(struct command_ctx *cmd_ctx)
 
 	/* Process by command type */
 	switch (cmd_ctx->lsm->cmd_type) {
-	case KERNEL_CREATE_SESSION:
+	case LTTNG_KERNEL_ADD_CONTEXT:
 	{
+		int found = 0, no_event = 0;
+		struct ltt_kernel_channel *chan;
+		struct ltt_kernel_event *event;
+
+		/* Setup lttng message with no payload */
 		ret = setup_lttng_msg(cmd_ctx, 0);
 		if (ret < 0) {
 			goto setup_error;
 		}
 
-		ret = start_kconsumerd();
-		if (ret < 0) {
-			goto error;
-		}
+		/* Check if event name is given */
+		if (strlen(cmd_ctx->lsm->u.context.event_name) == 0) {
+			no_event = 1;
+		}
+
+		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);
+					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);
+						if (ret < 0) {
+							ret = LTTCOMM_KERN_CONTEXT_FAIL;
+							goto error;
+						}
+						found = 1;
+						break;
+					}
+				}
+			}
+		} else {
+			chan = get_kernel_channel_by_name(cmd_ctx->lsm->u.context.channel_name,
+					cmd_ctx->session->kernel_session);
+			if (chan == NULL) {
+				ret = LTTCOMM_KERN_CHAN_NOT_FOUND;
+				goto error;
+			}
 
-		DBG("Creating kernel session");
+			if (no_event) {
+				ret = kernel_add_channel_context(chan,
+						&cmd_ctx->lsm->u.context.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);
+					if (ret < 0) {
+						ret = LTTCOMM_KERN_CONTEXT_FAIL;
+						goto error;
+					}
+				}
+			}
+		}
 
-		ret = kernel_create_session(cmd_ctx->session, kernel_tracer_fd);
-		if (ret < 0) {
-			ret = LTTCOMM_KERN_SESS_FAIL;
+		if (!found && !no_event) {
+			ret = LTTCOMM_NO_EVENT;
 			goto error;
 		}
 
 		ret = LTTCOMM_OK;
 		break;
 	}
-	case KERNEL_CREATE_CHANNEL:
+	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);
-
+		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;
@@ -744,166 +1071,373 @@ static int process_client_msg(struct command_ctx *cmd_ctx)
 		ret = LTTCOMM_OK;
 		break;
 	}
-	case KERNEL_ENABLE_EVENT:
+	case LTTNG_KERNEL_DISABLE_CHANNEL:
 	{
+		struct ltt_kernel_channel *chan;
+
 		/* Setup lttng message with no payload */
 		ret = setup_lttng_msg(cmd_ctx, 0);
 		if (ret < 0) {
 			goto setup_error;
 		}
 
-		DBG("Enabling kernel event %s", cmd_ctx->lsm->u.event.event_name);
+		chan = get_kernel_channel_by_name(cmd_ctx->lsm->u.disable.channel_name,
+				cmd_ctx->session->kernel_session);
+		if (chan == NULL) {
+			ret = LTTCOMM_KERN_CHAN_NOT_FOUND;
+			goto error;
+		} else if (chan->enabled == 1) {
+			ret = kernel_disable_channel(chan);
+			if (ret < 0) {
+				if (ret != EEXIST) {
+					ret = LTTCOMM_KERN_CHAN_DISABLE_FAIL;
+				}
+				goto error;
+			}
+		}
+
+		kernel_wait_quiescent(kernel_tracer_fd);
+		ret = LTTCOMM_OK;
+		break;
+	}
+	case LTTNG_KERNEL_DISABLE_EVENT:
+	{
+		struct ltt_kernel_channel *chan;
+		struct ltt_kernel_event *ev;
 
-		ret = kernel_enable_event(cmd_ctx->session->kernel_session, cmd_ctx->lsm->u.event.event_name);
+		/* Setup lttng message with no payload */
+		ret = setup_lttng_msg(cmd_ctx, 0);
 		if (ret < 0) {
-			ret = LTTCOMM_KERN_ENABLE_FAIL;
+			goto setup_error;
+		}
+
+		chan = get_kernel_channel_by_name(cmd_ctx->lsm->u.disable.channel_name,
+				cmd_ctx->session->kernel_session);
+		if (chan == NULL) {
+			ret = LTTCOMM_KERN_CHAN_NOT_FOUND;
 			goto error;
 		}
 
+		ev = get_kernel_event_by_name(cmd_ctx->lsm->u.disable.name, chan);
+		if (ev != NULL) {
+			DBG("Disabling kernel event %s for channel %s.",
+					cmd_ctx->lsm->u.disable.name, cmd_ctx->lsm->u.disable.channel_name);
+			ret = kernel_disable_event(ev);
+			if (ret < 0) {
+				ret = LTTCOMM_KERN_ENABLE_FAIL;
+				goto error;
+			}
+		}
+
+		kernel_wait_quiescent(kernel_tracer_fd);
 		ret = LTTCOMM_OK;
 		break;
 	}
-	case KERNEL_LIST_EVENTS:
+	case LTTNG_KERNEL_DISABLE_ALL_EVENT:
 	{
-		char *event_list;
-		ssize_t size;
+		struct ltt_kernel_channel *chan;
+		struct ltt_kernel_event *ev;
 
-		size = kernel_list_events(kernel_tracer_fd, &event_list);
-		if (size < 0) {
-			ret = LTTCOMM_KERN_LIST_FAIL;
+		/* Setup lttng message with no payload */
+		ret = setup_lttng_msg(cmd_ctx, 0);
+		if (ret < 0) {
+			goto setup_error;
+		}
+
+		DBG("Disabling all enabled kernel events");
+
+		chan = get_kernel_channel_by_name(cmd_ctx->lsm->u.disable.channel_name,
+				cmd_ctx->session->kernel_session);
+		if (chan == NULL) {
+			ret = LTTCOMM_KERN_CHAN_NOT_FOUND;
 			goto error;
 		}
 
-		/*
-		 * Setup lttng message with payload size set to the event list size in
-		 * bytes and then copy list into the llm payload.
-		 */
-		ret = setup_lttng_msg(cmd_ctx, size);
+		/* For each event in the kernel session */
+		cds_list_for_each_entry(ev, &chan->events_list.head, list) {
+			DBG("Disabling kernel event %s for channel %s.",
+					ev->event->name, cmd_ctx->lsm->u.disable.channel_name);
+			ret = kernel_disable_event(ev);
+			if (ret < 0) {
+				continue;
+			}
+		}
+
+		/* Quiescent wait after event disable */
+		kernel_wait_quiescent(kernel_tracer_fd);
+		ret = LTTCOMM_OK;
+		break;
+	}
+	case LTTNG_KERNEL_ENABLE_CHANNEL:
+	{
+		struct ltt_kernel_channel *chan;
+
+		/* Setup lttng message with no payload */
+		ret = setup_lttng_msg(cmd_ctx, 0);
 		if (ret < 0) {
 			goto setup_error;
 		}
 
-		/* Copy event list into message payload */
-		memcpy(cmd_ctx->llm->payload, event_list, size);
-
-		free(event_list);
+		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;
+		} else if (chan->enabled == 0) {
+			ret = kernel_enable_channel(chan);
+			if (ret < 0) {
+				if (ret != EEXIST) {
+					ret = LTTCOMM_KERN_CHAN_ENABLE_FAIL;
+				}
+				goto error;
+			}
+		}
 
+		kernel_wait_quiescent(kernel_tracer_fd);
 		ret = LTTCOMM_OK;
 		break;
 	}
-	case KERNEL_OPEN_METADATA:
+	case LTTNG_KERNEL_ENABLE_EVENT:
 	{
+		struct ltt_kernel_channel *chan;
+		struct ltt_kernel_event *ev;
+
 		/* Setup lttng message with no payload */
 		ret = setup_lttng_msg(cmd_ctx, 0);
 		if (ret < 0) {
 			goto setup_error;
 		}
 
-		DBG("Open kernel metadata");
+		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;
+		}
+
+		ev = get_kernel_event_by_name(cmd_ctx->lsm->u.enable.event.name, chan);
+		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);
+		} else {
+			DBG("Enabling kernel event %s for channel %s.",
+					cmd_ctx->lsm->u.enable.event.name, chan->channel->name);
+			ret = kernel_enable_event(ev);
+		}
 
-		ret = kernel_open_metadata(cmd_ctx->session->kernel_session);
 		if (ret < 0) {
-			ret = LTTCOMM_KERN_META_FAIL;
+			ret = LTTCOMM_KERN_ENABLE_FAIL;
 			goto error;
 		}
 
+		kernel_wait_quiescent(kernel_tracer_fd);
 		ret = LTTCOMM_OK;
 		break;
 	}
-	case KERNEL_CREATE_STREAM:
+	case LTTNG_KERNEL_ENABLE_ALL_EVENT:
 	{
+		int pos, size;
+		char *event_list, *event, *ptr;
 		struct ltt_kernel_channel *chan;
+		struct ltt_kernel_event *ev;
+		struct lttng_event ev_attr;
+
 		/* Setup lttng message with no payload */
 		ret = setup_lttng_msg(cmd_ctx, 0);
 		if (ret < 0) {
 			goto setup_error;
 		}
 
-		DBG("Creating kernel stream");
+		DBG("Enabling all kernel event");
 
-		ret = kernel_create_metadata_stream(cmd_ctx->session->kernel_session);
-		if (ret < 0) {
-			ERR("Kernel create metadata stream failed");
-			ret = LTTCOMM_KERN_STREAM_FAIL;
+		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;
 		}
 
-		/* For each channel */
-		cds_list_for_each_entry(chan, &cmd_ctx->session->kernel_session->channel_list.head, list) {
-			ret = kernel_create_channel_stream(chan);
+		/* For each event in the kernel session */
+		cds_list_for_each_entry(ev, &chan->events_list.head, list) {
+			DBG("Enabling kernel event %s for channel %s.",
+					ev->event->name, chan->channel->name);
+			ret = kernel_enable_event(ev);
 			if (ret < 0) {
-				ERR("Kernel create channel stream failed");
-				ret = LTTCOMM_KERN_STREAM_FAIL;
-				goto error;
+				continue;
+			}
+		}
+
+		size = kernel_list_events(kernel_tracer_fd, &event_list);
+		if (size < 0) {
+			ret = LTTCOMM_KERN_LIST_FAIL;
+			goto error;
+		}
+
+		ptr = event_list;
+		while ((size = sscanf(ptr, "event { name = %m[^;]; };%n\n", &event, &pos)) == 1) {
+			ev = get_kernel_event_by_name(event, chan);
+			if (ev == NULL) {
+				strncpy(ev_attr.name, event, LTTNG_SYM_NAME_LEN);
+				/* Default event type for enable all */
+				ev_attr.type = LTTNG_EVENT_TRACEPOINTS;
+				/* Enable each single tracepoint event */
+				ret = kernel_create_event(&ev_attr, chan);
+				if (ret < 0) {
+					/* Ignore error here and continue */
+				}
 			}
-			/* Update the stream global counter */
-			cmd_ctx->session->kernel_session->stream_count_global += ret;
+
+			/* Move pointer to the next line */
+			ptr += pos + 1;
+			free(event);
+		}
+
+		free(event_list);
+
+		/* Quiescent wait after event enable */
+		kernel_wait_quiescent(kernel_tracer_fd);
+		ret = LTTCOMM_OK;
+		break;
+	}
+	case LTTNG_KERNEL_LIST_EVENTS:
+	{
+		char *event_list;
+		ssize_t size = 0;
+
+		DBG("Listing kernel events");
+
+		size = kernel_list_events(kernel_tracer_fd, &event_list);
+		if (size < 0) {
+			ret = LTTCOMM_KERN_LIST_FAIL;
+			goto error;
 		}
 
+		/*
+		 * Setup lttng message with payload size set to the event list size in
+		 * bytes and then copy list into the llm payload.
+		 */
+		ret = setup_lttng_msg(cmd_ctx, size);
+		if (ret < 0) {
+			goto setup_error;
+		}
+
+		/* Copy event list into message payload */
+		memcpy(cmd_ctx->llm->payload, event_list, size);
+
+		free(event_list);
+
 		ret = LTTCOMM_OK;
 		break;
 	}
-	case KERNEL_START_TRACE:
+	case LTTNG_START_TRACE:
 	{
+		struct ltt_kernel_channel *chan;
+
 		/* Setup lttng message with no payload */
 		ret = setup_lttng_msg(cmd_ctx, 0);
 		if (ret < 0) {
 			goto setup_error;
 		}
 
-		DBG("Start kernel tracing");
+		/* Kernel tracing */
+		if (cmd_ctx->session->kernel_session != NULL) {
+			if (cmd_ctx->session->kernel_session->metadata == NULL) {
+				DBG("Open kernel metadata");
+				ret = kernel_open_metadata(cmd_ctx->session->kernel_session,
+						cmd_ctx->session->path);
+				if (ret < 0) {
+					ret = LTTCOMM_KERN_META_FAIL;
+					goto error;
+				}
+			}
 
-		ret = create_trace_dir(cmd_ctx->session->kernel_session);
-		if (ret < 0) {
-			if (ret == -EEXIST) {
-				ret = LTTCOMM_KERN_DIR_EXIST;
-			} else {
-				ret = LTTCOMM_KERN_DIR_FAIL;
+			if (cmd_ctx->session->kernel_session->metadata_stream_fd == 0) {
+				DBG("Opening kernel metadata stream");
+				if (cmd_ctx->session->kernel_session->metadata_stream_fd == 0) {
+					ret = kernel_open_metadata_stream(cmd_ctx->session->kernel_session);
+					if (ret < 0) {
+						ERR("Kernel create metadata stream failed");
+						ret = LTTCOMM_KERN_STREAM_FAIL;
+						goto error;
+					}
+				}
+			}
+
+			/* For each channel */
+			cds_list_for_each_entry(chan, &cmd_ctx->session->kernel_session->channel_list.head, list) {
+				if (chan->stream_count == 0) {
+					ret = kernel_open_channel_stream(chan);
+					if (ret < 0) {
+						ERR("Kernel create channel stream failed");
+						ret = LTTCOMM_KERN_STREAM_FAIL;
+						goto error;
+					}
+					/* Update the stream global counter */
+					cmd_ctx->session->kernel_session->stream_count_global += ret;
+				}
+			}
+
+			DBG("Start kernel tracing");
+			ret = kernel_start_session(cmd_ctx->session->kernel_session);
+			if (ret < 0) {
+				ERR("Kernel start session failed");
+				ret = LTTCOMM_KERN_START_FAIL;
 				goto error;
 			}
-		}
 
-		ret = kernel_start_session(cmd_ctx->session->kernel_session);
-		if (ret < 0) {
-			ERR("Kernel start session failed");
-			ret = LTTCOMM_KERN_START_FAIL;
-			goto error;
-		}
+			ret = start_kernel_trace(cmd_ctx->session->kernel_session);
+			if (ret < 0) {
+				ret = LTTCOMM_KERN_START_FAIL;
+				goto error;
+			}
 
-		ret = send_kconsumerd_fds(kconsumerd_cmd_sock, cmd_ctx->session->kernel_session);
-		if (ret < 0) {
-			ERR("Send kconsumerd fds failed");
-			ret = LTTCOMM_KERN_CONSUMER_FAIL;
-			goto error;
+			/* Quiescent wait after starting trace */
+			kernel_wait_quiescent(kernel_tracer_fd);
 		}
 
+		/* TODO: Start all UST traces */
+
 		ret = LTTCOMM_OK;
 		break;
 	}
-	case KERNEL_STOP_TRACE:
+	case LTTNG_STOP_TRACE:
 	{
+		struct ltt_kernel_channel *chan;
 		/* Setup lttng message with no payload */
 		ret = setup_lttng_msg(cmd_ctx, 0);
 		if (ret < 0) {
 			goto setup_error;
 		}
 
-		if (cmd_ctx->session->kernel_session == NULL) {
-			ret = LTTCOMM_KERN_NO_SESSION;
-			goto error;
-		}
+		/* Kernel tracer */
+		if (cmd_ctx->session->kernel_session != NULL) {
+			DBG("Stop kernel tracing");
 
-		DBG("Stop kernel tracing");
+			ret = kernel_metadata_flush_buffer(cmd_ctx->session->kernel_session->metadata_stream_fd);
+			if (ret < 0) {
+				ERR("Kernel metadata flush failed");
+			}
 
-		ret = kernel_stop_session(cmd_ctx->session->kernel_session);
-		if (ret < 0) {
-			ERR("Kernel stop session failed");
-			ret = LTTCOMM_KERN_STOP_FAIL;
-			goto error;
+			cds_list_for_each_entry(chan, &cmd_ctx->session->kernel_session->channel_list.head, list) {
+				ret = kernel_flush_buffer(chan);
+				if (ret < 0) {
+					ERR("Kernel flush buffer error");
+				}
+			}
+
+			ret = kernel_stop_session(cmd_ctx->session->kernel_session);
+			if (ret < 0) {
+				ERR("Kernel stop session failed");
+				ret = LTTCOMM_KERN_STOP_FAIL;
+				goto error;
+			}
+
+			/* Quiescent wait after stopping trace */
+			kernel_wait_quiescent(kernel_tracer_fd);
 		}
 
-		/* Clean kernel session teardown */
-		teardown_kernel_session(cmd_ctx->session);
+		/* TODO : User-space tracer */
 
 		ret = LTTCOMM_OK;
 		break;
@@ -916,9 +1450,9 @@ static int process_client_msg(struct command_ctx *cmd_ctx)
 			goto setup_error;
 		}
 
-		ret = create_session(cmd_ctx->lsm->session_name, &cmd_ctx->llm->session_uuid);
+		ret = create_session(cmd_ctx->lsm->session_name, cmd_ctx->lsm->path);
 		if (ret < 0) {
-			if (ret == -1) {
+			if (ret == -EEXIST) {
 				ret = LTTCOMM_EXIST_SESS;
 			} else {
 				ret = LTTCOMM_FATAL;
@@ -937,15 +1471,19 @@ static int process_client_msg(struct command_ctx *cmd_ctx)
 			goto setup_error;
 		}
 
-		ret = destroy_session(&cmd_ctx->lsm->session_uuid);
+		/* Clean kernel session teardown */
+		teardown_kernel_session(cmd_ctx->session);
+
+		ret = destroy_session(cmd_ctx->lsm->session_name);
 		if (ret < 0) {
-			ret = LTTCOMM_NO_SESS;
+			ret = LTTCOMM_FATAL;
 			goto error;
 		}
 
 		ret = LTTCOMM_OK;
 		break;
 	}
+	/*
 	case LTTNG_LIST_TRACES:
 	{
 		unsigned int trace_count;
@@ -967,9 +1505,10 @@ static int process_client_msg(struct command_ctx *cmd_ctx)
 		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;
@@ -977,11 +1516,12 @@ static int process_client_msg(struct command_ctx *cmd_ctx)
 
 		ret = ust_create_trace(cmd_ctx);
 		if (ret < 0) {
-			goto setup_error;
+			goto error;
 		}
 		break;
 	}
-	case UST_LIST_APPS:
+	*/
+	case LTTNG_LIST_TRACEABLE_APPS:
 	{
 		unsigned int app_count;
 
@@ -1002,9 +1542,9 @@ static int process_client_msg(struct command_ctx *cmd_ctx)
 		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;
@@ -1018,7 +1558,6 @@ static int process_client_msg(struct command_ctx *cmd_ctx)
 	}
 	case UST_STOP_TRACE:
 	{
-		/* Setup lttng message with no payload */
 		ret = setup_lttng_msg(cmd_ctx, 0);
 		if (ret < 0) {
 			goto setup_error;
@@ -1030,13 +1569,14 @@ static int process_client_msg(struct command_ctx *cmd_ctx)
 		}
 		break;
 	}
+	*/
 	case LTTNG_LIST_SESSIONS:
 	{
 		unsigned int session_count;
 
 		session_count = get_session_count();
 		if (session_count == 0) {
-			ret = LTTCOMM_NO_SESS;
+			ret = LTTCOMM_NO_SESSION;
 			goto error;
 		}
 
@@ -1132,6 +1672,8 @@ static void *thread_manage_clients(void *data)
 			continue;
 		}
 
+		// TODO: Validate cmd_ctx including sanity check for security purpose.
+
 		/*
 		 * This function dispatch the work to the kernel or userspace tracer
 		 * libs and fill the lttcomm_lttng_msg data structure of all the needed
@@ -1155,6 +1697,9 @@ static void *thread_manage_clients(void *data)
 		}
 
 		clean_command_ctx(cmd_ctx);
+
+		/* End of transmission */
+		close(sock);
 	}
 
 error:
@@ -1329,32 +1874,13 @@ static int check_existing_daemon()
 	return ret;
 }
 
-/*
- *  get_home_dir
- *
- *  Return pointer to home directory path using
- *  the env variable HOME.
- *
- *  Default : /tmp
- */
-static const char *get_home_dir(void)
-{
-	const char *home_path;
-
-	if ((home_path = (const char *) getenv("HOME")) == NULL) {
-		home_path = default_home_dir;
-	}
-
-	return home_path;
-}
-
 /*
  *  set_permissions
  *
  *  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).
+ *  more permissive (root.root) to les permissive (root.tracing).
  */
 static int set_permissions(void)
 {
@@ -1367,8 +1893,13 @@ static int set_permissions(void)
 		(grp = getgrnam(default_tracing_group));
 
 	if (grp == NULL) {
-		ERR("Missing tracing group. Aborting execution.\n");
-		ret = -1;
+		if (is_root) {
+			WARN("No tracing group detected");
+			ret = 0;
+		} else {
+			ERR("Missing tracing group. Aborting execution.");
+			ret = -1;
+		}
 		goto end;
 	}
 
@@ -1423,23 +1954,6 @@ 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;
-	}
-
-	DBG("Kernel tracer fd %d", kernel_tracer_fd);
-}
-
 /*
  *  set_kconsumerd_sockets
  *
@@ -1460,8 +1974,11 @@ static int set_kconsumerd_sockets(void)
 
 	ret = mkdir(KCONSUMERD_PATH, S_IRWXU | S_IRWXG);
 	if (ret < 0) {
-		ERR("Failed to create " KCONSUMERD_PATH);
-		goto error;
+		if (errno != EEXIST) {
+			ERR("Failed to create " KCONSUMERD_PATH);
+			goto error;
+		}
+		ret = 0;
 	}
 
 	/* Create the kconsumerd error unix socket */
@@ -1550,6 +2067,26 @@ static int set_signal_handler(void)
 	return ret;
 }
 
+/*
+ *  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.
+ */
+static void set_ulimit(void)
+{
+	int ret;
+	struct rlimit lim;
+
+	lim.rlim_cur = 65535;
+	lim.rlim_max = 65535;
+
+	ret = setrlimit(RLIMIT_NOFILE, &lim);
+	if (ret < 0) {
+		perror("failed to set open files limit");
+	}
+}
+
 /*
  * main
  */
@@ -1557,6 +2094,7 @@ int main(int argc, char **argv)
 {
 	int ret = 0;
 	void *status;
+	const char *home_path;
 
 	/* Parse arguments */
 	progname = argv[0];
@@ -1576,7 +2114,6 @@ int main(int argc, char **argv)
 	/* Check if daemon is UID = 0 */
 	is_root = !getuid();
 
-	/* Set all sockets path */
 	if (is_root) {
 		ret = create_lttng_rundir();
 		if (ret < 0) {
@@ -1600,16 +2137,26 @@ int main(int argc, char **argv)
 
 		/* 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;
+		}
+
 		if (strlen(apps_unix_sock_path) == 0) {
 			snprintf(apps_unix_sock_path, PATH_MAX,
-					DEFAULT_HOME_APPS_UNIX_SOCK, get_home_dir());
+					DEFAULT_HOME_APPS_UNIX_SOCK, home_path);
 		}
 
 		/* Set the cli tool unix socket path */
 		if (strlen(client_unix_sock_path) == 0) {
 			snprintf(client_unix_sock_path, PATH_MAX,
-					DEFAULT_HOME_CLIENT_UNIX_SOCK, get_home_dir());
+					DEFAULT_HOME_CLIENT_UNIX_SOCK, home_path);
 		}
 	}