X-Git-Url: http://git.lttng.org/?a=blobdiff_plain;f=liblttng-ust%2Flttng-ust-comm.c;h=516e39d2f570c6837352ccedb23bd798bbb1b3b0;hb=ef9ff354212ff4b038e1a5b6a7ed0ffe1b949663;hp=17c7350de06a8078c6ddc543e8c1468b44430593;hpb=23c8854a5fa1120df5cfdfbf08f00e00976f95fa;p=lttng-ust.git

diff --git a/liblttng-ust/lttng-ust-comm.c b/liblttng-ust/lttng-ust-comm.c
index 17c7350d..516e39d2 100644
--- a/liblttng-ust/lttng-ust-comm.c
+++ b/liblttng-ust/lttng-ust-comm.c
@@ -37,13 +37,14 @@
 #include <signal.h>
 #include <urcu/uatomic.h>
 #include <urcu/futex.h>
+#include <urcu/compiler.h>
 
-#include <ust-comm.h>
 #include <lttng/ust-events.h>
-#include <lttng/usterr-signal-safe.h>
 #include <lttng/ust-abi.h>
-#include "tracepoint-internal.h"
 #include <lttng/ust.h>
+#include <ust-comm.h>
+#include <usterr-signal-safe.h>
+#include "tracepoint-internal.h"
 #include "ltt-tracer-core.h"
 
 /*
@@ -166,6 +167,7 @@ int register_app_to_sessiond(int socket)
 		pid_t ppid;
 		uid_t uid;
 		gid_t gid;
+		uint32_t bits_per_long;
 		char name[16];	/* process name */
 	} reg_msg;
 
@@ -175,6 +177,7 @@ int register_app_to_sessiond(int socket)
 	reg_msg.ppid = getppid();
 	reg_msg.uid = getuid();
 	reg_msg.gid = getgid();
+	reg_msg.bits_per_long = CAA_BITS_PER_LONG;
 	prctl_ret = prctl(PR_GET_NAME, (unsigned long) reg_msg.name, 0, 0, 0);
 	if (prctl_ret) {
 		ERR("Error executing prctl");
@@ -236,6 +239,7 @@ int handle_message(struct sock_info *sock_info,
 	const struct lttng_ust_objd_ops *ops;
 	struct ustcomm_ust_reply lur;
 	int shm_fd, wait_fd;
+	union ust_args args;
 
 	ust_lock();
 
@@ -268,7 +272,8 @@ int handle_message(struct sock_info *sock_info,
 	default:
 		if (ops->cmd)
 			ret = ops->cmd(lum->handle, lum->cmd,
-					(unsigned long) &lum->u);
+					(unsigned long) &lum->u,
+					&args);
 		else
 			ret = -ENOSYS;
 		break;
@@ -290,23 +295,21 @@ end:
 		 * Special-case reply to send stream info.
 		 * Use lum.u output.
 		 */
-		lur.u.stream.memory_map_size = lum->u.stream.memory_map_size;
-		shm_fd = lum->u.stream.shm_fd;
-		wait_fd = lum->u.stream.wait_fd;
+		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 = lum->u.channel.memory_map_size;
-		shm_fd = lum->u.channel.shm_fd;
-		wait_fd = lum->u.channel.wait_fd;
+		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_list_entry,
-			lum->u.tracepoint_list_entry,
-			LTTNG_UST_SYM_NAME_LEN);
+		memcpy(&lur.u.tracepoint, &lum->u.tracepoint, sizeof(lur.u.tracepoint));
 		break;
 	}
 	ret = send_reply(sock, &lur);
@@ -335,6 +338,48 @@ end:
 			goto error;
 		}
 	}
+	/*
+	 * We still have the memory map reference, and the fds have been
+	 * sent to the sessiond. We can therefore close those fds.
+	 */
+	if (lur.ret_code == USTCOMM_OK) {
+		switch (lum->cmd) {
+		case LTTNG_UST_STREAM:
+			if (shm_fd >= 0) {
+				ret = close(shm_fd);
+				if (ret) {
+					PERROR("Error closing stream shm_fd");
+				}
+				*args.stream.shm_fd = -1;
+			}
+			if (wait_fd >= 0) {
+				ret = close(wait_fd);
+				if (ret) {
+					PERROR("Error closing stream wait_fd");
+				}
+				*args.stream.wait_fd = -1;
+			}
+			break;
+		case LTTNG_UST_METADATA:
+		case LTTNG_UST_CHANNEL:
+			if (shm_fd >= 0) {
+				ret = close(shm_fd);
+				if (ret) {
+					PERROR("Error closing channel shm_fd");
+				}
+				*args.channel.shm_fd = -1;
+			}
+			if (wait_fd >= 0) {
+				ret = close(wait_fd);
+				if (ret) {
+					PERROR("Error closing channel wait_fd");
+				}
+				*args.channel.wait_fd = -1;
+			}
+			break;
+		}
+	}
+
 error:
 	ust_unlock();
 	return ret;
@@ -412,7 +457,7 @@ int get_wait_shm(struct sock_info *sock_info, size_t mmap_size)
 		 * shared memory map will have been created.
 		 */
 		pid = wait(&status);
-		if (!WIFEXITED(status) || WEXITSTATUS(status) != 0) {
+		if (pid < 0 || !WIFEXITED(status) || WEXITSTATUS(status) != 0) {
 			wait_shm_fd = -1;
 			goto end;
 		}
@@ -560,14 +605,15 @@ void wait_for_sessiond(struct sock_info *sock_info)
 		if (ret < 0) {
 			if (errno == EFAULT) {
 				wait_poll_fallback = 1;
-				WARN(
+				DBG(
 "Linux kernels 2.6.33 to 3.0 (with the exception of stable versions) "
 "do not support FUTEX_WAKE on read-only memory mappings correctly. "
 "Please upgrade your kernel "
 "(fix is commit 9ea71503a8ed9184d2d0b8ccc4d269d05f7940ae in Linux kernel "
 "mainline). LTTng-UST will use polling mode fallback.");
+				if (ust_debug())
+					PERROR("futex");
 			}
-			PERROR("futex");
 		}
 	}
 	return;
@@ -680,6 +726,20 @@ restart:
 		switch (len) {
 		case 0:	/* orderly shutdown */
 			DBG("%s ltt-sessiond has performed an orderly shutdown\n", sock_info->name);
+			ust_lock();
+			/*
+			 * Either sessiond has shutdown or refused us by closing the socket.
+			 * In either case, we don't want to delay construction execution,
+			 * and we need to wait before retry.
+			 */
+			prev_connect_failed = 1;
+			/*
+			 * If we cannot register to the sessiond daemon, don't
+			 * delay constructor execution.
+			 */
+			ret = handle_register_done(sock_info);
+			assert(!ret);
+			ust_unlock();
 			goto end;
 		case sizeof(lum):
 			DBG("message received\n");
@@ -689,6 +749,7 @@ restart:
 			}
 			continue;
 		case -1:
+			DBG("Receive failed from lttng-sessiond with errno %d", errno);
 			if (errno == ECONNRESET) {
 				ERR("%s remote end closed connection\n", sock_info->name);
 				goto end;