X-Git-Url: http://git.lttng.org./?a=blobdiff_plain;f=ltt-sessiond%2Fmain.c;h=c6913fa0a5fd41888507f576e6f8387b824e0f92;hb=8d5bb86ea2e1a863a5d0dd91249f32e1fcd29fd6;hp=eb02b69fa090659df8dfe33171e193f26a4cb1f7;hpb=2c58cc2eccbb85063cc547c0259d276a2be5c0a4;p=lttng-tools.git

diff --git a/ltt-sessiond/main.c b/ltt-sessiond/main.c
index eb02b69fa..c6913fa0a 100644
--- a/ltt-sessiond/main.c
+++ b/ltt-sessiond/main.c
@@ -370,6 +370,7 @@ static void cleanup(void)
 
 	if (getenv("BENCH_UST_REGISTER")) {
 		bench_print_ust_register();
+		bench_print_ust_unregister();
 	}
 
 	if (getenv("BENCH_BOOT_PROCESS")) {
@@ -727,6 +728,12 @@ static void *thread_manage_kernel(void *data)
 
 	while (1) {
 		if (update_poll_flag == 1) {
+			/*
+			 * Reset number of fd in the poll set. Always 2 since there is the thread
+			 * quit pipe and the kernel pipe.
+			 */
+			events.nb_fd = 2;
+
 			ret = update_kernel_poll(&events);
 			if (ret < 0) {
 				goto error;
@@ -868,6 +875,8 @@ static void *thread_manage_kconsumerd(void *data)
 		goto error;
 	}
 
+	DBG2("Receiving code from kconsumerd_err_sock");
+
 	/* Getting status code from kconsumerd */
 	ret = lttcomm_recv_unix_sock(sock, &code,
 			sizeof(enum lttcomm_return_code));
@@ -887,7 +896,7 @@ static void *thread_manage_kconsumerd(void *data)
 		sem_post(&kconsumerd_sem);
 		DBG("Kconsumerd command socket ready");
 	} else {
-		DBG("Kconsumerd error when waiting for SOCK_READY : %s",
+		ERR("Kconsumerd error when waiting for SOCK_READY : %s",
 				lttcomm_get_readable_code(-code));
 		goto error;
 	}
@@ -1316,29 +1325,66 @@ error:
 static int spawn_kconsumerd_thread(void)
 {
 	int ret;
+	struct timespec timeout;
+
+	timeout.tv_sec = DEFAULT_SEM_WAIT_TIMEOUT;
+	timeout.tv_nsec = 0;
 
 	/* Setup semaphore */
-	sem_init(&kconsumerd_sem, 0, 0);
+	ret = sem_init(&kconsumerd_sem, 0, 0);
+	if (ret < 0) {
+		PERROR("sem_init kconsumerd_sem");
+		goto error;
+	}
 
 	ret = pthread_create(&kconsumerd_thread, NULL,
 			thread_manage_kconsumerd, (void *) NULL);
 	if (ret != 0) {
-		perror("pthread_create kconsumerd");
+		PERROR("pthread_create kconsumerd");
+		ret = -1;
 		goto error;
 	}
 
-	/* Wait for the kconsumerd thread to be ready */
-	sem_wait(&kconsumerd_sem);
+	/* Get time for sem_timedwait absolute timeout */
+	ret = clock_gettime(CLOCK_REALTIME, &timeout);
+	if (ret < 0) {
+		PERROR("clock_gettime spawn kconsumerd");
+		/* Infinite wait for the kconsumerd thread to be ready */
+		ret = sem_wait(&kconsumerd_sem);
+	} else {
+		/* Normal timeout if the gettime was successful */
+		timeout.tv_sec += DEFAULT_SEM_WAIT_TIMEOUT;
+		ret = sem_timedwait(&kconsumerd_sem, &timeout);
+	}
 
+	if (ret < 0) {
+		if (errno == ETIMEDOUT) {
+			/*
+			 * Call has timed out so we kill the kconsumerd_thread and return
+			 * an error.
+			 */
+			ERR("The kconsumerd thread was never ready. Killing it");
+			ret = pthread_cancel(kconsumerd_thread);
+			if (ret < 0) {
+				PERROR("pthread_cancel kconsumerd_thread");
+			}
+		} else {
+			PERROR("semaphore wait failed kconsumerd thread");
+		}
+		goto error;
+	}
+
+	pthread_mutex_lock(&kconsumerd_pid_mutex);
 	if (kconsumerd_pid == 0) {
 		ERR("Kconsumerd did not start");
+		pthread_mutex_unlock(&kconsumerd_pid_mutex);
 		goto error;
 	}
+	pthread_mutex_unlock(&kconsumerd_pid_mutex);
 
 	return 0;
 
 error:
-	ret = LTTCOMM_KERN_CONSUMER_FAIL;
 	return ret;
 }
 
@@ -1420,18 +1466,16 @@ static int start_kconsumerd(void)
 	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;
+	DBG2("Kconsumerd pid %d", kconsumerd_pid);
 	pthread_mutex_unlock(&kconsumerd_pid_mutex);
 
-	DBG("Kconsumerd pid %d", ret);
-
-	DBG("Spawning kconsumerd thread");
+	DBG2("Spawning kconsumerd thread");
 	ret = spawn_kconsumerd_thread();
 	if (ret < 0) {
 		ERR("Fatal error spawning kconsumerd thread");
@@ -1626,7 +1670,7 @@ static int create_ust_session(struct ltt_session *session,
 		struct lttng_domain *domain)
 {
 	int ret;
-	struct ltt_ust_session *lus;
+	struct ltt_ust_session *lus = NULL;
 	struct ust_app *app;
 
 	switch (domain->type) {
@@ -1638,6 +1682,7 @@ static int create_ust_session(struct ltt_session *session,
 		}
 		break;
 	default:
+		ret = LTTCOMM_UNKNOWN_DOMAIN;
 		goto error;
 	}
 
@@ -2365,7 +2410,7 @@ static int cmd_destroy_session(struct ltt_session *session, char *name)
 		perror("write kernel poll pipe");
 	}
 
-	ret = session_destroy(name);
+	ret = session_destroy(session);
 
 	return ret;
 }
@@ -2577,7 +2622,9 @@ static int process_client_msg(struct command_ctx *cmd_ctx)
 		break;
 	default:
 		DBG("Getting session %s by name", cmd_ctx->lsm->session.name);
+		session_lock_list();
 		cmd_ctx->session = session_find_by_name(cmd_ctx->lsm->session.name);
+		session_unlock_list();
 		if (cmd_ctx->session == NULL) {
 			if (cmd_ctx->lsm->session.name != NULL) {
 				ret = LTTCOMM_SESS_NOT_FOUND;
@@ -2619,14 +2666,17 @@ static int process_client_msg(struct command_ctx *cmd_ctx)
 			}
 
 			/* Start the kernel consumer daemon */
+			pthread_mutex_lock(&kconsumerd_pid_mutex);
 			if (kconsumerd_pid == 0 &&
 					cmd_ctx->lsm->cmd_type != LTTNG_REGISTER_CONSUMER) {
+				pthread_mutex_unlock(&kconsumerd_pid_mutex);
 				ret = start_kconsumerd();
 				if (ret < 0) {
 					ret = LTTCOMM_KERN_CONSUMER_FAIL;
 					goto error;
 				}
 			}
+			pthread_mutex_unlock(&kconsumerd_pid_mutex);
 		}
 		break;
 	case LTTNG_DOMAIN_UST_PID: