X-Git-Url: https://git.lttng.org/?p=lttng-tools.git;a=blobdiff_plain;f=src%2Fbin%2Flttng-consumerd%2Flttng-consumerd.c;h=4d02c842798f65c1024b9326a248493ea60204af;hp=32571bddf36cfc94483eaf0f180694ac21a99fae;hb=81ffed9c49284d91e2fa05a88050e187d5b325ae;hpb=d14d33bf091e72b23b1f90ea18a0a01bed098b76

diff --git a/src/bin/lttng-consumerd/lttng-consumerd.c b/src/bin/lttng-consumerd/lttng-consumerd.c
index 32571bddf..4d02c8427 100644
--- a/src/bin/lttng-consumerd/lttng-consumerd.c
+++ b/src/bin/lttng-consumerd/lttng-consumerd.c
@@ -27,6 +27,7 @@
 #include <stdlib.h>
 #include <string.h>
 #include <sys/ipc.h>
+#include <sys/resource.h>
 #include <sys/shm.h>
 #include <sys/socket.h>
 #include <sys/stat.h>
@@ -38,20 +39,20 @@
 #include <assert.h>
 #include <config.h>
 #include <urcu/compiler.h>
+#include <ulimit.h>
 
 #include <common/defaults.h>
 #include <common/common.h>
-#include <common/kernel-consumer/kernel-consumer.h>
-#include <common/kernel-ctl/kernel-ctl.h>
+#include <common/consumer.h>
+#include <common/compat/poll.h>
 #include <common/sessiond-comm/sessiond-comm.h>
-#include <common/ust-consumer/ust-consumer.h>
 
 #include "lttng-consumerd.h"
 
 /* TODO : support UST (all direct kernel-ctl accesses). */
 
-/* the two threads (receive fd and poll) */
-static pthread_t threads[2];
+/* the two threads (receive fd, poll and metadata) */
+static pthread_t data_thread, metadata_thread, sessiond_thread;
 
 /* to count the number of times the user pressed ctrl+c */
 static int sigintcount = 0;
@@ -78,6 +79,14 @@ static void sighandler(int sig)
 		return;
 	}
 
+	/*
+	 * Ignore SIGPIPE because it should not stop the consumer whenever a
+	 * SIGPIPE is catched through a FD operation.
+	 */
+	if (sig == SIGPIPE) {
+		return;
+	}
+
 	lttng_consumer_should_exit(ctx);
 }
 
@@ -227,12 +236,30 @@ static void parse_args(int argc, char **argv)
 	}
 }
 
+/*
+ * 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;
+
+	/* The kernel does not allowed an infinite limit for open files */
+	lim.rlim_cur = 65535;
+	lim.rlim_max = 65535;
+
+	ret = setrlimit(RLIMIT_NOFILE, &lim);
+	if (ret < 0) {
+		PERROR("failed to set open files limit");
+	}
+}
+
 /*
  * main
  */
 int main(int argc, char **argv)
 {
-	int i;
 	int ret = 0;
 	void *status;
 
@@ -242,13 +269,31 @@ int main(int argc, char **argv)
 
 	/* Daemonize */
 	if (opt_daemon) {
+		int i;
+
+		/*
+		 * fork
+		 * child: setsid, close FD 0, 1, 2, chdir /
+		 * parent: exit (if fork is successful)
+		 */
 		ret = daemon(0, 0);
 		if (ret < 0) {
-			perror("daemon");
+			PERROR("daemon");
 			goto error;
 		}
+		/*
+		 * We are in the child. Make sure all other file
+		 * descriptors are closed, in case we are called with
+		 * more opened file descriptors than the standard ones.
+		 */
+		for (i = 3; i < sysconf(_SC_OPEN_MAX); i++) {
+			(void) close(i);
+		}
 	}
 
+	/* Set up max poll set size */
+	lttng_poll_set_max_size();
+
 	if (strlen(command_sock_path) == 0) {
 		switch (opt_type) {
 		case LTTNG_CONSUMER_KERNEL:
@@ -272,6 +317,11 @@ int main(int argc, char **argv)
 	/* Init */
 	lttng_consumer_init();
 
+	if (!getuid()) {
+		/* Set limit for open files */
+		set_ulimit();
+	}
+
 	/* create the consumer instance with and assign the callbacks */
 	ctx = lttng_consumer_create(opt_type, lttng_consumer_read_subbuffer,
 		NULL, lttng_consumer_on_recv_stream, NULL);
@@ -313,36 +363,59 @@ int main(int argc, char **argv)
 	}
 	lttng_consumer_set_error_sock(ctx, ret);
 
-	/* Create the thread to manage the receive of fd */
-	ret = pthread_create(&threads[0], NULL, lttng_consumer_thread_receive_fds,
+	/* Create thread to manage the polling/writing of trace metadata */
+	ret = pthread_create(&metadata_thread, NULL, consumer_thread_metadata_poll,
 			(void *) ctx);
 	if (ret != 0) {
 		perror("pthread_create");
 		goto error;
 	}
 
-	/* Create thread to manage the polling/writing of traces */
-	ret = pthread_create(&threads[1], NULL, lttng_consumer_thread_poll_fds,
+	/* Create thread to manage the polling/writing of trace data */
+	ret = pthread_create(&data_thread, NULL, consumer_thread_data_poll,
 			(void *) ctx);
 	if (ret != 0) {
 		perror("pthread_create");
+		goto data_error;
+	}
+
+	/* Create the thread to manage the receive of fd */
+	ret = pthread_create(&sessiond_thread, NULL, consumer_thread_sessiond_poll,
+			(void *) ctx);
+	if (ret != 0) {
+		perror("pthread_create");
+		goto sessiond_error;
+	}
+
+	ret = pthread_join(sessiond_thread, &status);
+	if (ret != 0) {
+		perror("pthread_join");
 		goto error;
 	}
 
-	for (i = 0; i < 2; i++) {
-		ret = pthread_join(threads[i], &status);
-		if (ret != 0) {
-			perror("pthread_join");
-			goto error;
-		}
+sessiond_error:
+	ret = pthread_join(data_thread, &status);
+	if (ret != 0) {
+		perror("pthread_join");
+		goto error;
+	}
+
+data_error:
+	ret = pthread_join(metadata_thread, &status);
+	if (ret != 0) {
+		perror("pthread_join");
+		goto error;
+	}
+
+	if (!ret) {
+		ret = EXIT_SUCCESS;
+		lttng_consumer_send_error(ctx, LTTCOMM_CONSUMERD_EXIT_SUCCESS);
+		goto end;
 	}
-	ret = EXIT_SUCCESS;
-	lttng_consumer_send_error(ctx, CONSUMERD_EXIT_SUCCESS);
-	goto end;
 
 error:
 	ret = EXIT_FAILURE;
-	lttng_consumer_send_error(ctx, CONSUMERD_EXIT_FAILURE);
+	lttng_consumer_send_error(ctx, LTTCOMM_CONSUMERD_EXIT_FAILURE);
 
 end:
 	lttng_consumer_destroy(ctx);