X-Git-Url: https://git.lttng.org/?a=blobdiff_plain;f=liblttng-ust%2Flttng-ust-comm.c;h=0d4f5ef9e9c389656b23016c8e63191ce9dce923;hb=e32d20e94c6c0acb82cfacda4652fd566960c575;hp=516e39d2f570c6837352ccedb23bd798bbb1b3b0;hpb=ef9ff354212ff4b038e1a5b6a7ed0ffe1b949663;p=lttng-ust.git

diff --git a/liblttng-ust/lttng-ust-comm.c b/liblttng-ust/lttng-ust-comm.c
index 516e39d2..0d4f5ef9 100644
--- a/liblttng-ust/lttng-ust-comm.c
+++ b/liblttng-ust/lttng-ust-comm.c
@@ -46,6 +46,7 @@
 #include <usterr-signal-safe.h>
 #include "tracepoint-internal.h"
 #include "ltt-tracer-core.h"
+#include "../libringbuffer/tlsfixup.h"
 
 /*
  * Has lttng ust comm constructor been called ?
@@ -289,28 +290,30 @@ end:
 		//lur.ret_code = USTCOMM_SESSION_FAIL;
 		lur.ret_code = ret;
 	}
-	switch (lum->cmd) {
-	case LTTNG_UST_STREAM:
-		/*
-		 * Special-case reply to send stream info.
-		 * Use lum.u output.
-		 */
-		lur.u.stream.memory_map_size = *args.stream.memory_map_size;
-		shm_fd = *args.stream.shm_fd;
-		wait_fd = *args.stream.wait_fd;
-		break;
-	case LTTNG_UST_METADATA:
-	case LTTNG_UST_CHANNEL:
-		lur.u.channel.memory_map_size = *args.channel.memory_map_size;
-		shm_fd = *args.channel.shm_fd;
-		wait_fd = *args.channel.wait_fd;
-		break;
-	case LTTNG_UST_TRACER_VERSION:
-		lur.u.version = lum->u.version;
-		break;
-	case LTTNG_UST_TRACEPOINT_LIST_GET:
-		memcpy(&lur.u.tracepoint, &lum->u.tracepoint, sizeof(lur.u.tracepoint));
-		break;
+	if (ret >= 0) {
+		switch (lum->cmd) {
+		case LTTNG_UST_STREAM:
+			/*
+			 * Special-case reply to send stream info.
+			 * Use lum.u output.
+			 */
+			lur.u.stream.memory_map_size = *args.stream.memory_map_size;
+			shm_fd = *args.stream.shm_fd;
+			wait_fd = *args.stream.wait_fd;
+			break;
+		case LTTNG_UST_METADATA:
+		case LTTNG_UST_CHANNEL:
+			lur.u.channel.memory_map_size = *args.channel.memory_map_size;
+			shm_fd = *args.channel.shm_fd;
+			wait_fd = *args.channel.wait_fd;
+			break;
+		case LTTNG_UST_TRACER_VERSION:
+			lur.u.version = lum->u.version;
+			break;
+		case LTTNG_UST_TRACEPOINT_LIST_GET:
+			memcpy(&lur.u.tracepoint, &lum->u.tracepoint, sizeof(lur.u.tracepoint));
+			break;
+		}
 	}
 	ret = send_reply(sock, &lur);
 	if (ret < 0) {
@@ -322,14 +325,20 @@ end:
 	     || lum->cmd == LTTNG_UST_CHANNEL
 	     || lum->cmd == LTTNG_UST_METADATA)
 			&& lur.ret_code == USTCOMM_OK) {
+		int sendret = 0;
+
 		/* we also need to send the file descriptors. */
 		ret = ustcomm_send_fds_unix_sock(sock,
 			&shm_fd, &shm_fd,
 			1, sizeof(int));
 		if (ret < 0) {
 			perror("send shm_fd");
-			goto error;
+			sendret = ret;
 		}
+		/*
+		 * The sessiond expects 2 file descriptors, even upon
+		 * error.
+		 */
 		ret = ustcomm_send_fds_unix_sock(sock,
 			&wait_fd, &wait_fd,
 			1, sizeof(int));
@@ -337,10 +346,16 @@ end:
 			perror("send wait_fd");
 			goto error;
 		}
+		if (sendret) {
+			ret = sendret;
+			goto error;
+		}
 	}
 	/*
 	 * We still have the memory map reference, and the fds have been
-	 * sent to the sessiond. We can therefore close those fds.
+	 * sent to the sessiond. We can therefore close those fds. Note
+	 * that we keep the write side of the wait_fd open, but close
+	 * the read side.
 	 */
 	if (lur.ret_code == USTCOMM_OK) {
 		switch (lum->cmd) {
@@ -386,12 +401,12 @@ error:
 }
 
 static
-void cleanup_sock_info(struct sock_info *sock_info)
+void cleanup_sock_info(struct sock_info *sock_info, int exiting)
 {
 	int ret;
 
 	if (sock_info->socket != -1) {
-		ret = close(sock_info->socket);
+		ret = ustcomm_close_unix_sock(sock_info->socket);
 		if (ret) {
 			ERR("Error closing apps socket");
 		}
@@ -405,7 +420,13 @@ void cleanup_sock_info(struct sock_info *sock_info)
 		sock_info->root_handle = -1;
 	}
 	sock_info->constructor_sem_posted = 0;
-	if (sock_info->wait_shm_mmap) {
+	/*
+	 * wait_shm_mmap is used by listener threads outside of the
+	 * ust lock, so we cannot tear it down ourselves, because we
+	 * cannot join on these threads. Leave this task to the OS
+	 * process exit.
+	 */
+	if (!exiting && sock_info->wait_shm_mmap) {
 		ret = munmap(sock_info->wait_shm_mmap, sysconf(_SC_PAGE_SIZE));
 		if (ret) {
 			ERR("Error unmapping wait shm");
@@ -665,7 +686,7 @@ restart:
 	}
 
 	if (sock_info->socket != -1) {
-		ret = close(sock_info->socket);
+		ret = ustcomm_close_unix_sock(sock_info->socket);
 		if (ret) {
 			ERR("Error closing %s apps socket", sock_info->name);
 		}
@@ -816,12 +837,22 @@ int get_timeout(struct timespec *constructor_timeout)
 void __attribute__((constructor)) lttng_ust_init(void)
 {
 	struct timespec constructor_timeout;
+	sigset_t sig_all_blocked, orig_parent_mask;
 	int timeout_mode;
 	int ret;
 
 	if (uatomic_xchg(&initialized, 1) == 1)
 		return;
 
+	/*
+	 * Fixup interdependency between TLS fixup mutex (which happens
+	 * to be the dynamic linker mutex) and ust_lock, taken within
+	 * the ust lock.
+	 */
+	lttng_fixup_event_tls();
+	lttng_fixup_ringbuffer_tls();
+	lttng_fixup_vtid_tls();
+
 	/*
 	 * We want precise control over the order in which we construct
 	 * our sub-libraries vs starting to receive commands from
@@ -843,6 +874,18 @@ void __attribute__((constructor)) lttng_ust_init(void)
 	if (ret) {
 		ERR("Error setting up to local apps");
 	}
+
+	/* A new thread created by pthread_create inherits the signal mask
+	 * from the parent. To avoid any signal being received by the
+	 * listener thread, we block all signals temporarily in the parent,
+	 * while we create the listener thread.
+	 */
+	sigfillset(&sig_all_blocked);
+	ret = pthread_sigmask(SIG_SETMASK, &sig_all_blocked, &orig_parent_mask);
+	if (ret) {
+		PERROR("pthread_sigmask: %s", strerror(ret));
+	}
+
 	ret = pthread_create(&local_apps.ust_listener, NULL,
 			ust_listener_thread, &local_apps);
 
@@ -853,6 +896,12 @@ void __attribute__((constructor)) lttng_ust_init(void)
 		handle_register_done(&local_apps);
 	}
 
+	/* Restore original signal mask in parent */
+	ret = pthread_sigmask(SIG_SETMASK, &orig_parent_mask, NULL);
+	if (ret) {
+		PERROR("pthread_sigmask: %s", strerror(ret));
+	}
+
 	switch (timeout_mode) {
 	case 1:	/* timeout wait */
 		do {
@@ -879,10 +928,17 @@ void __attribute__((constructor)) lttng_ust_init(void)
 static
 void lttng_ust_cleanup(int exiting)
 {
-	cleanup_sock_info(&global_apps);
+	cleanup_sock_info(&global_apps, exiting);
 	if (local_apps.allowed) {
-		cleanup_sock_info(&local_apps);
+		cleanup_sock_info(&local_apps, exiting);
 	}
+	/*
+	 * The teardown in this function all affect data structures
+	 * accessed under the UST lock by the listener thread. This
+	 * lock, along with the lttng_ust_comm_should_quit flag, ensure
+	 * that none of these threads are accessing this data at this
+	 * point.
+	 */
 	lttng_ust_abi_exit();
 	lttng_ust_events_exit();
 	ltt_ring_buffer_client_discard_exit();
@@ -916,6 +972,7 @@ void __attribute__((destructor)) lttng_ust_exit(void)
 	lttng_ust_comm_should_quit = 1;
 	ust_unlock();
 
+	/* cancel threads */
 	ret = pthread_cancel(global_apps.ust_listener);
 	if (ret) {
 		ERR("Error cancelling global ust listener thread");
@@ -926,6 +983,14 @@ void __attribute__((destructor)) lttng_ust_exit(void)
 			ERR("Error cancelling local ust listener thread");
 		}
 	}
+	/*
+	 * Do NOT join threads: use of sys_futex makes it impossible to
+	 * join the threads without using async-cancel, but async-cancel
+	 * is delivered by a signal, which could hit the target thread
+	 * anywhere in its code path, including while the ust_lock() is
+	 * held, causing a deadlock for the other thread. Let the OS
+	 * cleanup the threads if there are stalled in a syscall.
+	 */
 	lttng_ust_cleanup(1);
 }