X-Git-Url: http://git.lttng.org./?a=blobdiff_plain;f=liblttng-ust%2Flttng-ust-comm.c;h=44e8bab4c24ca4aa2a77b72727288c9b24c8e67d;hb=c022630241628bd0233d3369ca3e418717fde89d;hp=dda4743fc240cf7c2dc7f71e15846a8ec2a691ca;hpb=982052994af40833768fef0bd342a42a1775e572;p=lttng-ust.git

diff --git a/liblttng-ust/lttng-ust-comm.c b/liblttng-ust/lttng-ust-comm.c
index dda4743f..44e8bab4 100644
--- a/liblttng-ust/lttng-ust-comm.c
+++ b/liblttng-ust/lttng-ust-comm.c
@@ -22,6 +22,7 @@
 #define _LGPL_SOURCE
 #include <sys/types.h>
 #include <sys/socket.h>
+#include <sys/prctl.h>
 #include <sys/mman.h>
 #include <sys/stat.h>
 #include <sys/types.h>
@@ -45,7 +46,6 @@
 #include <usterr-signal-safe.h>
 #include "tracepoint-internal.h"
 #include "ltt-tracer-core.h"
-#include "compat.h"
 
 /*
  * Has lttng ust comm constructor been called ?
@@ -159,6 +159,7 @@ static
 int register_app_to_sessiond(int socket)
 {
 	ssize_t ret;
+	int prctl_ret;
 	struct {
 		uint32_t major;
 		uint32_t minor;
@@ -177,7 +178,11 @@ int register_app_to_sessiond(int socket)
 	reg_msg.uid = getuid();
 	reg_msg.gid = getgid();
 	reg_msg.bits_per_long = CAA_BITS_PER_LONG;
-	lttng_ust_getprocname(reg_msg.name);
+	prctl_ret = prctl(PR_GET_NAME, (unsigned long) reg_msg.name, 0, 0, 0);
+	if (prctl_ret) {
+		ERR("Error executing prctl");
+		return -errno;
+	}
 
 	ret = ustcomm_send_unix_sock(socket, &reg_msg, sizeof(reg_msg));
 	if (ret >= 0 && ret != sizeof(reg_msg))
@@ -284,28 +289,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) {
@@ -403,15 +410,10 @@ void cleanup_sock_info(struct sock_info *sock_info, int exiting)
 	}
 	sock_info->constructor_sem_posted = 0;
 	/*
-	 * When called from process exit, we allow this memory map to be
-	 * released by the OS at exit(), because removing it prior to
-	 * this can cause a segmentation fault when using the
-	 * futex_async timer-based fallback. And we cannot join those
-	 * threads because sys_futex does not react to the cancellation
-	 * request.
-	 *
-	 * So we actually _do_ release it only after a fork, since all
-	 * threads have vanished anyway.
+	 * 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));
@@ -891,6 +893,13 @@ void lttng_ust_cleanup(int exiting)
 	if (local_apps.allowed) {
 		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();
@@ -924,6 +933,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");
@@ -935,8 +945,12 @@ void __attribute__((destructor)) lttng_ust_exit(void)
 		}
 	}
 	/*
-	 * We cannot join the threads because they might be waiting on
-	 * sys_futex. Simply let the OS exit() clean up those threads.
+	 * 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);
 }