X-Git-Url: https://git.lttng.org/?p=lttng-tools.git;a=blobdiff_plain;f=ltt-sessiond%2Fmain.c;h=cbd6a3f3f6a7469ddc2be72fb5b313555bf37989;hp=a7c6e5fbf9c44b8a1f4397b997fa6cd7c73830d4;hb=333f285e479a22c99122aa92b988b10c597551e4;hpb=9e78d6ae219789dee9c96f35f190d6166ef389c3

diff --git a/ltt-sessiond/main.c b/ltt-sessiond/main.c
index a7c6e5fbf..cbd6a3f3f 100644
--- a/ltt-sessiond/main.c
+++ b/ltt-sessiond/main.c
@@ -45,6 +45,7 @@
 #include "ust-ctl.h"
 #include "session.h"
 #include "traceable-app.h"
+#include "lttng-kconsumerd.h"
 
 /*
  * TODO:
@@ -55,261 +56,110 @@
 
 /* Const values */
 const char default_home_dir[] = DEFAULT_HOME_DIR;
-const char default_tracing_group[] = DEFAULT_TRACING_GROUP;
+const char default_tracing_group[] = LTTNG_DEFAULT_TRACING_GROUP;
 const char default_ust_sock_dir[] = DEFAULT_UST_SOCK_DIR;
 const char default_global_apps_pipe[] = DEFAULT_GLOBAL_APPS_PIPE;
 
-/* Static functions */
-static int check_existing_daemon(void);
-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(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_lttng_msg(struct command_ctx *cmd_ctx, size_t size);
-static int create_lttng_rundir(void);
-static int create_trace_dir(struct ltt_kernel_session *session);
-static int set_kconsumerd_sockets(void);
-static void cleanup(void);
-static void sighandler(int sig);
-static void clean_command_ctx(struct command_ctx *cmd_ctx);
-static void teardown_kernel_session(struct ltt_session *session);
-
-static void *thread_manage_clients(void *data);
-static void *thread_manage_apps(void *data);
-static void *thread_manage_kconsumerd(void *data);
-
 /* Variables */
-int opt_verbose;
-int opt_quiet;
+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 opt_daemon;
 static int is_root;			/* Set to 1 if the daemon is running as root */
-static pid_t ppid;
+static pid_t ppid;          /* Parent PID for --sig-parent option */
+static pid_t kconsumerd_pid;
 
 static char apps_unix_sock_path[PATH_MAX];				/* Global application Unix socket path */
 static char client_unix_sock_path[PATH_MAX];			/* Global client Unix socket path */
 static char kconsumerd_err_unix_sock_path[PATH_MAX];	/* kconsumerd error Unix socket path */
 static char kconsumerd_cmd_unix_sock_path[PATH_MAX];	/* kconsumerd command Unix socket path */
 
+/* Sockets and FDs */
 static int client_sock;
 static int apps_sock;
 static int kconsumerd_err_sock;
 static int kconsumerd_cmd_sock;
 static int kernel_tracer_fd;
+
+/* Pthread, Mutexes and Semaphores */
 static pthread_t kconsumerd_thread;
+static pthread_t apps_thread;
+static pthread_t client_thread;
 static sem_t kconsumerd_sem;
 
-static pthread_mutex_t kconsumerd_pid_mutex;
-static pid_t kconsumerd_pid;
+static pthread_mutex_t kconsumerd_pid_mutex;	/* Mutex to control kconsumerd pid assignation */
 
 /*
- *  thread_manage_kconsumerd
+ *  teardown_kernel_session
  *
- *  This thread manage the kconsumerd error sent
- *  back to the session daemon.
+ *  Complete teardown of a kernel session. This free all data structure
+ *  related to a kernel session and update counter.
  */
-static void *thread_manage_kconsumerd(void *data)
+static void teardown_kernel_session(struct ltt_session *session)
 {
-	int sock, ret;
-	enum lttcomm_return_code code;
-
-	DBG("[thread] Manage kconsumerd started");
-
-	ret = lttcomm_listen_unix_sock(kconsumerd_err_sock);
-	if (ret < 0) {
-		goto error;
-	}
-
-	sock = lttcomm_accept_unix_sock(kconsumerd_err_sock);
-	if (sock < 0) {
-		goto error;
-	}
-
-	ret = lttcomm_recv_unix_sock(sock, &code, sizeof(enum lttcomm_return_code));
-	if (ret <= 0) {
-		goto error;
-	}
-
-	if (code == KCONSUMERD_COMMAND_SOCK_READY) {
-		kconsumerd_cmd_sock = lttcomm_connect_unix_sock(kconsumerd_cmd_unix_sock_path);
-		if (kconsumerd_cmd_sock < 0) {
-			perror("kconsumerd connect");
-			goto error;
-		}
-		/* Signal condition to tell that the kconsumerd is ready */
-		sem_post(&kconsumerd_sem);
-		DBG("Kconsumerd command socket ready");
-	} else {
-		DBG("[sessiond] Kconsumerd error when waiting for SOCK_READY : %s",
-				lttcomm_get_readable_code(-code));
-		goto error;
-	}
-
-	/* Wait for any kconsumerd error */
-	ret = lttcomm_recv_unix_sock(sock, &code, sizeof(enum lttcomm_return_code));
-	if (ret <= 0) {
-		ERR("[sessiond] Kconsumerd closed the command socket");
-		goto error;
+	if (session->kernel_session != NULL) {
+		DBG("Tearing down kernel session");
+		trace_destroy_kernel_session(session->kernel_session);
+		/* Extra precaution */
+		session->kernel_session = NULL;
+		/* Decrement session count */
+		session->kern_session_count--;
 	}
-
-	ERR("Kconsumerd return code : %s", lttcomm_get_readable_code(-code));
-
-error:
-	teardown_kernel_session((struct ltt_session *) data);
-	return NULL;
 }
 
 /*
- * 	thread_manage_apps
+ *  cleanup
  *
- * 	This thread manage the application socket communication
+ *  Cleanup the daemon on exit
  */
-static void *thread_manage_apps(void *data)
+static void cleanup()
 {
-	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;
-		uid_t uid;
-	} reg_msg;
-
-	DBG("[thread] Manage apps started");
-
-	ret = lttcomm_listen_unix_sock(apps_sock);
-	if (ret < 0) {
-		goto error;
-	}
-
-	/* Notify all applications to register */
-	notify_apps(default_global_apps_pipe);
+	int ret;
+	char *cmd;
+	struct ltt_session *sess;
 
-	while (1) {
-		DBG("Accepting application registration");
-		/* Blocking call, waiting for transmission */
-		sock = lttcomm_accept_unix_sock(apps_sock);
-		if (sock < 0) {
-			goto error;
-		}
+	DBG("Cleaning up");
 
-		/* Basic recv here to handle the very simple data
-		 * that the libust send to register (reg_msg).
-		 */
-		ret = recv(sock, &reg_msg, sizeof(reg_msg), 0);
-		if (ret < 0) {
-			perror("recv");
-			continue;
-		}
+	/* <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);
+	/* </fun> */
 
-		/* Add application to the global traceable list */
-		if (reg_msg.reg == 1) {
-			/* Registering */
-			ret = register_traceable_app(reg_msg.pid, reg_msg.uid);
-			if (ret < 0) {
-				/* register_traceable_app only return an error with
-				 * ENOMEM. At this point, we better stop everything.
-				 */
-				goto error;
-			}
-		} else {
-			/* Unregistering */
-			unregister_traceable_app(reg_msg.pid);
-		}
+	/* Stopping all threads */
+	DBG("Terminating all threads");
+	pthread_cancel(client_thread);
+	pthread_cancel(apps_thread);
+	if (kconsumerd_pid != 0) {
+		pthread_cancel(kconsumerd_thread);
 	}
 
-error:
-
-	return NULL;
-}
-
-/*
- * 	thread_manage_clients
- *
- * 	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;
-
-	DBG("[thread] Manage client started");
+	DBG("Unlinking all unix socket");
+	unlink(client_unix_sock_path);
+	unlink(apps_unix_sock_path);
+	unlink(kconsumerd_err_unix_sock_path);
 
-	ret = lttcomm_listen_unix_sock(client_sock);
+	DBG("Removing %s directory", LTTNG_RUNDIR);
+	ret = asprintf(&cmd, "rm -rf " LTTNG_RUNDIR);
 	if (ret < 0) {
-		goto error;
+		ERR("asprintf failed. Something is really wrong!");
 	}
 
-	/* Notify parent pid that we are ready
-	 * to accept command for client side.
-	 */
-	if (opt_sig_parent) {
-		kill(ppid, SIGCHLD);
+	/* Remove lttng run directory */
+	ret = system(cmd);
+	if (ret < 0) {
+		ERR("Unable to clean " LTTNG_RUNDIR);
 	}
 
-	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.
-		 */
-		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 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(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);
+	DBG("Cleaning up all session");
+	/* Cleanup ALL session */
+	cds_list_for_each_entry(sess, &ltt_session_list.head, list) {
+		teardown_kernel_session(sess);
+		// TODO complete session cleanup (including UST)
 	}
 
-error:
-	return NULL;
+	close(kernel_tracer_fd);
 }
 
 /*
@@ -460,50 +310,190 @@ error:
 }
 
 /*
- *  start_kconsumerd_thread
+ *  thread_manage_kconsumerd
+ *
+ *  This thread manage the kconsumerd error sent
+ *  back to the session daemon.
+ */
+static void *thread_manage_kconsumerd(void *data)
+{
+	int sock, ret;
+	enum lttcomm_return_code code;
+
+	DBG("[thread] Manage kconsumerd started");
+
+	ret = lttcomm_listen_unix_sock(kconsumerd_err_sock);
+	if (ret < 0) {
+		goto error;
+	}
+
+	sock = lttcomm_accept_unix_sock(kconsumerd_err_sock);
+	if (sock < 0) {
+		goto error;
+	}
+
+	/* Getting status code from kconsumerd */
+	ret = lttcomm_recv_unix_sock(sock, &code, sizeof(enum lttcomm_return_code));
+	if (ret <= 0) {
+		goto error;
+	}
+
+	if (code == KCONSUMERD_COMMAND_SOCK_READY) {
+		kconsumerd_cmd_sock = lttcomm_connect_unix_sock(kconsumerd_cmd_unix_sock_path);
+		if (kconsumerd_cmd_sock < 0) {
+			sem_post(&kconsumerd_sem);
+			perror("kconsumerd connect");
+			goto error;
+		}
+		/* Signal condition to tell that the kconsumerd is ready */
+		sem_post(&kconsumerd_sem);
+		DBG("Kconsumerd command socket ready");
+	} else {
+		DBG("Kconsumerd error when waiting for SOCK_READY : %s",
+				lttcomm_get_readable_code(-code));
+		goto error;
+	}
+
+	/* Wait for any kconsumerd error */
+	ret = lttcomm_recv_unix_sock(sock, &code, sizeof(enum lttcomm_return_code));
+	if (ret <= 0) {
+		ERR("Kconsumerd closed the command socket");
+		goto error;
+	}
+
+	ERR("Kconsumerd return code : %s", lttcomm_get_readable_code(-code));
+
+error:
+	kconsumerd_pid = 0;
+	DBG("Kconsumerd thread dying");
+	return NULL;
+}
+
+/*
+ * 	thread_manage_apps
+ *
+ * 	This thread manage the application socket communication
+ */
+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;
+		uid_t uid;
+	} reg_msg;
+
+	DBG("[thread] Manage apps started");
+
+	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) {
+			goto error;
+		}
+
+		/* Basic recv here to handle the very simple data
+		 * that the libust send to register (reg_msg).
+		 */
+		ret = recv(sock, &reg_msg, sizeof(reg_msg), 0);
+		if (ret < 0) {
+			perror("recv");
+			continue;
+		}
+
+		/* Add application to the global traceable list */
+		if (reg_msg.reg == 1) {
+			/* Registering */
+			ret = register_traceable_app(reg_msg.pid, reg_msg.uid);
+			if (ret < 0) {
+				/* register_traceable_app only return an error with
+				 * ENOMEM. At this point, we better stop everything.
+				 */
+				goto error;
+			}
+		} else {
+			/* Unregistering */
+			unregister_traceable_app(reg_msg.pid);
+		}
+	}
+
+error:
+
+	return NULL;
+}
+
+/*
+ *  spawn_kconsumerd_thread
  *
  *  Start the thread_manage_kconsumerd. This must be done after a kconsumerd
  *  exec or it will fails.
  */
-static int start_kconsumerd_thread(struct ltt_session *session)
+static int spawn_kconsumerd_thread(void)
 {
 	int ret;
 
 	/* Setup semaphore */
 	sem_init(&kconsumerd_sem, 0, 0);
 
-	ret = pthread_create(&kconsumerd_thread, NULL, thread_manage_kconsumerd, (void *) session);
+	ret = pthread_create(&kconsumerd_thread, NULL, thread_manage_kconsumerd, (void *) NULL);
 	if (ret != 0) {
 		perror("pthread_create kconsumerd");
 		goto error;
 	}
 
+	/* Wait for the kconsumerd thread to be ready */
 	sem_wait(&kconsumerd_sem);
 
+	if (kconsumerd_pid == 0) {
+		ERR("Kconsumerd did not start");
+		goto error;
+	}
+
 	return 0;
 
 error:
+	ret = LTTCOMM_KERN_CONSUMER_FAIL;
 	return ret;
 }
 
 /*
- *  kernel_start_consumer
+ *  spawn_kconsumerd
+ *
+ *  Fork and exec a kernel consumer daemon (kconsumerd).
  *
- *  Start 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.
  */
-pid_t kernel_start_consumer(void)
+static pid_t spawn_kconsumerd(void)
 {
 	int ret;
 	pid_t pid;
 
+	DBG("Spawning kconsumerd");
+
 	pid = fork();
 	if (pid == 0) {
 		/*
 		 * Exec kconsumerd.
 		 */
-		execlp("kconsumerd", "kconsumerd", "--daemonize", NULL);
+		execlp("kconsumerd", "kconsumerd", "--verbose", NULL);
 		if (errno != 0) {
 			perror("kernel start consumer exec");
 		}
@@ -521,6 +511,49 @@ error:
 	return ret;
 }
 
+/*
+ *  start_kconsumerd
+ *
+ *  Spawn the kconsumerd daemon and session daemon thread.
+ */
+static int start_kconsumerd(void)
+{
+	int ret;
+
+	pthread_mutex_lock(&kconsumerd_pid_mutex);
+	if (kconsumerd_pid != 0) {
+		goto end;
+	}
+
+	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);
+
+	DBG("Spawning kconsumerd thread");
+	ret = spawn_kconsumerd_thread();
+	if (ret < 0) {
+		ERR("Fatal error spawning kconsumerd thread");
+		goto error;
+	}
+
+end:
+	pthread_mutex_unlock(&kconsumerd_pid_mutex);
+	return 0;
+
+error:
+	return ret;
+}
+
 /*
  *  send_kconsumerd_fds
  *
@@ -528,36 +561,18 @@ error:
  */
 static int send_kconsumerd_fds(int sock, struct ltt_kernel_session *session)
 {
-	int ret, i = 0;
-	/* Plus one here for the metadata fd */
-	size_t nb_fd = session->stream_count_global + 1;
-	int fds[nb_fd];
+	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 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);
+	struct lttcomm_kconsumerd_msg lkm;
 
-	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);
-		}
-	}
+	nb_fd = session->stream_count_global;
 
 	/* Setup header */
-	lkh.payload_size = nb_fd * sizeof(struct lttcomm_kconsumerd_msg);
-	lkh.cmd_type = LTTCOMM_ADD_STREAM;
+	lkh.payload_size = (nb_fd + 1) * sizeof(struct lttcomm_kconsumerd_msg);
+	lkh.cmd_type = ADD_STREAM;
 
 	DBG("Sending kconsumerd header");
 
@@ -567,14 +582,37 @@ static int send_kconsumerd_fds(int sock, struct ltt_kernel_session *session)
 		goto error;
 	}
 
-	DBG("Sending all fds to kconsumerd");
+	DBG("Sending metadata stream fd");
 
-	ret = lttcomm_send_fds_unix_sock(sock, buf, fds, nb_fd, lkh.payload_size);
+	/* Send metadata stream fd first */
+	lkm.fd = session->metadata_stream_fd;
+	lkm.state = ACTIVE_FD;
+	lkm.max_sb_size = session->metadata->conf->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 fds");
+		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->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;
@@ -584,67 +622,47 @@ error:
 }
 
 /*
- *  free_kernel_session
+ *  create_trace_dir
  *
- *  Free all data structure inside a kernel session and the session pointer.
+ *  Create the trace output directory.
  */
-static void free_kernel_session(struct ltt_kernel_session *session)
+static int create_trace_dir(struct ltt_kernel_session *session)
 {
+	int ret;
 	struct ltt_kernel_channel *chan;
-	struct ltt_kernel_stream *stream;
-	struct ltt_kernel_event *event;
-
-	/* Clean metadata */
-	close(session->metadata_stream_fd);
-	close(session->metadata->fd);
-	free(session->metadata->conf);
-	free(session->metadata);
 
+	/* Create all channel directories */
 	cds_list_for_each_entry(chan, &session->channel_list.head, list) {
-		/* Clean all event(s) */
-		cds_list_for_each_entry(event, &chan->events_list.head, list) {
-			close(event->fd);
-			free(event->event);
-			free(event);
-		}
-
-		/* Clean streams */
-		cds_list_for_each_entry(stream, &chan->stream_list.head, list) {
-			close(stream->fd);
-			free(stream->pathname);
-			free(stream);
+		DBG("Creating trace directory at %s", chan->pathname);
+		ret = mkdir(chan->pathname, S_IRWXU | S_IRWXG );
+		if (ret < 0) {
+			perror("mkdir trace path");
+			ret = -errno;
+			goto error;
 		}
-		/* Clean channel */
-		close(chan->fd);
-		free(chan->channel);
-		free(chan->pathname);
-		free(chan);
 	}
 
-	close(session->fd);
-	free(session);
+	return 0;
 
-	DBG("All kernel session data structures freed");
+error:
+	return ret;
 }
 
 /*
- *  teardown_kernel_session
+ *  init_kernel_tracer
  *
- *  Complete teardown of a kernel session. This free all data structure
- *  related to a kernel session and update counter.
+ *  Setup necessary data for kernel tracer action.
  */
-static void teardown_kernel_session(struct ltt_session *session)
+static void init_kernel_tracer(void)
 {
-	if (session->kernel_session != NULL) {
-		DBG("Tearing down kernel session");
-		free_kernel_session(session->kernel_session);
-		/* Extra precaution */
-		session->kernel_session = NULL;
-		/* Decrement session count */
-		session->kern_session_count--;
-		/* Set kconsumerd pid to 0 (inactive) */
-		session->kernel_consumer = 0;
+	/* 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);
 }
 
 /*
@@ -666,6 +684,7 @@ static int process_client_msg(struct command_ctx *cmd_ctx)
 	switch (cmd_ctx->lsm->cmd_type) {
 	case LTTNG_CREATE_SESSION:
 	case LTTNG_LIST_SESSIONS:
+	case KERNEL_LIST_EVENTS:
 	case UST_LIST_APPS:
 		break;
 	default:
@@ -684,14 +703,17 @@ static int process_client_msg(struct command_ctx *cmd_ctx)
 	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 */
+		/* 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;
+			}
 		}
 		break;
 	}
@@ -715,26 +737,8 @@ static int process_client_msg(struct command_ctx *cmd_ctx)
 			goto setup_error;
 		}
 
-		DBG("Checking if kconsumerd is alive");
-		pthread_mutex_lock(&kconsumerd_pid_mutex);
-		if (kconsumerd_pid == 0) {
-			ret = kernel_start_consumer();
-			if (ret < 0) {
-				ERR("Kernel start 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);
-
-		ret = start_kconsumerd_thread(cmd_ctx->session);
+		ret = start_kconsumerd();
 		if (ret < 0) {
-			ERR("Fatal error : start_kconsumerd_thread()");
-			ret = LTTCOMM_FATAL;
 			goto error;
 		}
 
@@ -756,33 +760,98 @@ static int process_client_msg(struct command_ctx *cmd_ctx)
 			goto setup_error;
 		}
 
-		DBG("Creating kernel channel");
-
-		ret = kernel_create_channel(cmd_ctx->session->kernel_session);
+		DBG("Creating kernel channel");
+
+		ret = kernel_create_channel(cmd_ctx->session->kernel_session);
+
+		if (ret < 0) {
+			ret = LTTCOMM_KERN_CHAN_FAIL;
+			goto error;
+		}
+
+		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;
+		}
+
+		DBG("Enabling kernel event %s", cmd_ctx->lsm->u.event.event_name);
+
+		ret = kernel_enable_event(cmd_ctx->session->kernel_session, cmd_ctx->lsm->u.event.event_name);
+		if (ret < 0) {
+			ret = LTTCOMM_KERN_ENABLE_FAIL;
+			goto error;
+		}
+
+		ret = LTTCOMM_OK;
+		break;
+	}
+	case KERNEL_ENABLE_ALL_EVENT:
+	{
+		int pos, size;
+		char *event_list, *event, *ptr;
+
+		/* Setup lttng message with no payload */
+		ret = setup_lttng_msg(cmd_ctx, 0);
+		if (ret < 0) {
+			goto setup_error;
+		}
+
+		DBG("Enabling all kernel event");
 
-		if (ret < 0) {
-			ret = LTTCOMM_KERN_CHAN_FAIL;
+		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) {
+			/* Enable each single event */
+			ret = kernel_enable_event(cmd_ctx->session->kernel_session, event);
+			if (ret < 0) {
+				ret = LTTCOMM_KERN_ENABLE_FAIL;
+				goto error;
+			}
+			/* Move pointer to the next line */
+			ptr += pos + 1;
+			free(event);
+		}
+
+		free(event_list);
+
 		ret = LTTCOMM_OK;
 		break;
 	}
-	case KERNEL_ENABLE_EVENT:
+	case KERNEL_LIST_EVENTS:
 	{
-		/* Setup lttng message with no payload */
-		ret = setup_lttng_msg(cmd_ctx, 0);
+		char *event_list;
+		ssize_t size;
+
+		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;
 		}
 
-		DBG("Enabling kernel event %s", cmd_ctx->lsm->u.event.event_name);
+		/* Copy event list into message payload */
+		memcpy(cmd_ctx->llm->payload, event_list, size);
 
-		ret = kernel_enable_event(cmd_ctx->session->kernel_session, cmd_ctx->lsm->u.event.event_name);
-		if (ret < 0) {
-			ret = LTTCOMM_KERN_ENABLE_FAIL;
-			goto error;
-		}
+		free(event_list);
 
 		ret = LTTCOMM_OK;
 		break;
@@ -884,6 +953,11 @@ static int process_client_msg(struct command_ctx *cmd_ctx)
 			goto setup_error;
 		}
 
+		if (cmd_ctx->session->kernel_session == NULL) {
+			ret = LTTCOMM_KERN_NO_SESSION;
+			goto error;
+		}
+
 		DBG("Stop kernel tracing");
 
 		ret = kernel_stop_session(cmd_ctx->session->kernel_session);
@@ -1071,6 +1145,91 @@ setup_error:
 	return ret;
 }
 
+/*
+ * 	thread_manage_clients
+ *
+ * 	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;
+
+	DBG("[thread] Manage client started");
+
+	ret = lttcomm_listen_unix_sock(client_sock);
+	if (ret < 0) {
+		goto error;
+	}
+
+	/* Notify parent pid that we are ready
+	 * to accept command for client side.
+	 */
+	if (opt_sig_parent) {
+		kill(ppid, SIGCHLD);
+	}
+
+	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.
+		 */
+		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 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(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);
+
+		/* End of transmission */
+		close(sock);
+	}
+
+error:
+	return NULL;
+}
+
+
 /*
  * usage function on stderr
  */
@@ -1308,32 +1467,6 @@ end:
 	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) {
-		ret = mkdir(chan->pathname, S_IRWXU | S_IRWXG );
-		if (ret < 0) {
-			perror("mkdir trace path");
-			ret = -errno;
-			goto error;
-		}
-	}
-
-	return 0;
-
-error:
-	return ret;
-}
-
 /*
  *  create_lttng_rundir
  *
@@ -1346,31 +1479,18 @@ static int create_lttng_rundir(void)
 
 	ret = mkdir(LTTNG_RUNDIR, S_IRWXU | S_IRWXG );
 	if (ret < 0) {
-		ERR("Unable to create " LTTNG_RUNDIR);
-		goto error;
+		if (errno != EEXIST) {
+			ERR("Unable to create " LTTNG_RUNDIR);
+			goto error;
+		} else {
+			ret = 0;
+		}
 	}
 
 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
  *
@@ -1416,46 +1536,6 @@ error:
 }
 
 /*
- *  set_signal_handler
- *
- *  Setup signal handler for :
- *		SIGINT, SIGTERM, SIGPIPE
- */
-static int set_signal_handler(void)
-{
-	int ret = 0;
-	struct sigaction sa;
-	sigset_t sigset;
-
-	if ((ret = sigemptyset(&sigset)) < 0) {
-		perror("sigemptyset");
-		return ret;
-	}
-
-	sa.sa_handler = sighandler;
-	sa.sa_mask = sigset;
-	sa.sa_flags = 0;
-	if ((ret = sigaction(SIGTERM, &sa, NULL)) < 0) {
-		perror("sigaction");
-		return ret;
-	}
-
-	if ((ret = sigaction(SIGINT, &sa, NULL)) < 0) {
-		perror("sigaction");
-		return ret;
-	}
-
-	if ((ret = sigaction(SIGPIPE, &sa, NULL)) < 0) {
-		perror("sigaction");
-		return ret;
-	}
-
-	DBG("Signal handler set for SIGTERM, SIGPIPE and SIGINT");
-
-	return ret;
-}
-
-/**
  *  sighandler
  *
  *  Signal handler for the daemon
@@ -1482,46 +1562,43 @@ static void sighandler(int sig)
 }
 
 /*
- *  cleanup
+ *  set_signal_handler
  *
- *  Cleanup the daemon on exit
+ *  Setup signal handler for :
+ *		SIGINT, SIGTERM, SIGPIPE
  */
-static void cleanup()
+static int set_signal_handler(void)
 {
-	int ret;
-	char *cmd;
-	struct ltt_session *sess;
-	struct ltt_session_list *session_list = get_session_list();
-
-	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);
-	/* </fun> */
+	int ret = 0;
+	struct sigaction sa;
+	sigset_t sigset;
 
-	unlink(client_unix_sock_path);
-	unlink(apps_unix_sock_path);
-	unlink(kconsumerd_err_unix_sock_path);
+	if ((ret = sigemptyset(&sigset)) < 0) {
+		perror("sigemptyset");
+		return ret;
+	}
 
-	ret = asprintf(&cmd, "rm -rf " LTTNG_RUNDIR);
-	if (ret < 0) {
-		ERR("asprintf failed. Something is really wrong!");
+	sa.sa_handler = sighandler;
+	sa.sa_mask = sigset;
+	sa.sa_flags = 0;
+	if ((ret = sigaction(SIGTERM, &sa, NULL)) < 0) {
+		perror("sigaction");
+		return ret;
 	}
 
-	/* Remove lttng run directory */
-	ret = system(cmd);
-	if (ret < 0) {
-		ERR("Unable to clean " LTTNG_RUNDIR);
+	if ((ret = sigaction(SIGINT, &sa, NULL)) < 0) {
+		perror("sigaction");
+		return ret;
 	}
 
-	/* Cleanup ALL session */
-	cds_list_for_each_entry(sess, &session_list->head, list) {
-		teardown_kernel_session(sess);
-		// TODO complete session cleanup (including UST)
+	if ((ret = sigaction(SIGPIPE, &sa, NULL)) < 0) {
+		perror("sigaction");
+		return ret;
 	}
 
-	close(kernel_tracer_fd);
+	DBG("Signal handler set for SIGTERM, SIGPIPE and SIGINT");
+
+	return ret;
 }
 
 /*
@@ -1529,10 +1606,8 @@ static void cleanup()
  */
 int main(int argc, char **argv)
 {
-	int i;
 	int ret = 0;
 	void *status;
-	pthread_t threads[2];
 
 	/* Parse arguments */
 	progname = argv[0];
@@ -1624,25 +1699,23 @@ int main(int argc, char **argv)
 
 	while (1) {
 		/* Create thread to manage the client socket */
-		ret = pthread_create(&threads[0], NULL, thread_manage_clients, (void *) NULL);
+		ret = pthread_create(&client_thread, NULL, thread_manage_clients, (void *) NULL);
 		if (ret != 0) {
 			perror("pthread_create");
 			goto error;
 		}
 
 		/* Create thread to manage application socket */
-		ret = pthread_create(&threads[1], NULL, thread_manage_apps, (void *) NULL);
+		ret = pthread_create(&apps_thread, NULL, thread_manage_apps, (void *) NULL);
 		if (ret != 0) {
 			perror("pthread_create");
 			goto error;
 		}
 
-		for (i = 0; i < 2; i++) {
-			ret = pthread_join(threads[i], &status);
-			if (ret != 0) {
-				perror("pthread_join");
-				goto error;
-			}
+		ret = pthread_join(client_thread, &status);
+		if (ret != 0) {
+			perror("pthread_join");
+			goto error;
 		}
 	}