X-Git-Url: https://git.lttng.org/?a=blobdiff_plain;f=libust%2Flttng-ust-comm.c;h=1e4031be273fcbcc7a29d397ab0bb8db3bbcfa22;hb=4dac85d27a1f1b380c1aa95f75d8722398feee80;hp=1c7b35a36125fa952824898aa11b7ba21c55b794;hpb=d3a492d1abfdf2aa19b7187a56b26a43f1a3e28e;p=lttng-ust.git

diff --git a/libust/lttng-ust-comm.c b/libust/lttng-ust-comm.c
index 1c7b35a3..1e4031be 100644
--- a/libust/lttng-ust-comm.c
+++ b/libust/lttng-ust-comm.c
@@ -21,13 +21,27 @@
 
 #include <sys/types.h>
 #include <sys/socket.h>
+#include <sys/prctl.h>
 #include <unistd.h>
 #include <errno.h>
-#include <ust/lttng-ust-abi.h>
-#include <lttng-ust-comm.h>
-#include <ust/usterr-signal-safe.h>
 #include <pthread.h>
+#include <semaphore.h>
+#include <time.h>
 #include <assert.h>
+#include <signal.h>
+#include <urcu/uatomic.h>
+
+#include <lttng-ust-comm.h>
+#include <ust/usterr-signal-safe.h>
+#include <ust/lttng-ust-abi.h>
+#include <ust/tracepoint.h>
+#include <ust/tracepoint-internal.h>
+#include <ust/ust.h>
+
+/*
+ * Has lttng ust comm constructor been called ?
+ */
+static int initialized;
 
 /*
  * communication thread mutex. Held when handling a command, also held
@@ -38,32 +52,74 @@ static pthread_mutex_t lttng_ust_comm_mutex = PTHREAD_MUTEX_INITIALIZER;
 /* Should the ust comm thread quit ? */
 static int lttng_ust_comm_should_quit;
 
+/*
+ * Wait for either of these before continuing to the main
+ * program:
+ * - the register_done message from sessiond daemon
+ *   (will let the sessiond daemon enable sessions before main
+ *   starts.)
+ * - sessiond daemon is not reachable.
+ * - timeout (ensuring applications are resilient to session
+ *   daemon problems).
+ */
+static sem_t constructor_wait;
+/*
+ * Doing this for both the global and local sessiond.
+ */
+static int sem_count = { 2 };
+
 /*
  * Info about socket and associated listener thread.
  */
 struct sock_info {
+	const char *name;
 	char sock_path[PATH_MAX];
 	int socket;
 	pthread_t ust_listener;	/* listener thread */
+	int root_handle;
+	int constructor_sem_posted;
+	int allowed;
 };
 
 /* Socket from app (connect) to session daemon (listen) for communication */
 struct sock_info global_apps = {
+	.name = "global",
 	.sock_path = DEFAULT_GLOBAL_APPS_UNIX_SOCK,
 	.socket = -1,
+	.root_handle = -1,
+	.allowed = 1,
 };
 
 /* TODO: allow global_apps_sock_path override */
 
 struct sock_info local_apps = {
+	.name = "local",
 	.socket = -1,
+	.root_handle = -1,
+	.allowed = 0,	/* Check setuid bit first */
 };
 
+extern void ltt_ring_buffer_client_overwrite_init(void);
+extern void ltt_ring_buffer_client_discard_init(void);
+extern void ltt_ring_buffer_metadata_client_init(void);
+extern void ltt_ring_buffer_client_overwrite_exit(void);
+extern void ltt_ring_buffer_client_discard_exit(void);
+extern void ltt_ring_buffer_metadata_client_exit(void);
+
 static
-int setup_local_apps_socket(void)
+int setup_local_apps(void)
 {
 	const char *home_dir;
 
+	/*
+	 * Disallow per-user tracing for setuid binaries.
+	 */
+	if (getuid() != geteuid()) {
+		local_apps.allowed = 0;
+		return 0;
+	} else {
+		local_apps.allowed = 1;
+	}
 	home_dir = (const char *) getenv("HOME");
 	if (!home_dir)
 		return -ENOENT;
@@ -76,17 +132,28 @@ static
 int register_app_to_sessiond(int socket)
 {
 	ssize_t ret;
+	int prctl_ret;
 	struct {
 		uint32_t major;
 		uint32_t minor;
 		pid_t pid;
+		pid_t ppid;
 		uid_t uid;
+		gid_t gid;
+		char name[16];	/* process name */
 	} reg_msg;
 
 	reg_msg.major = LTTNG_UST_COMM_VERSION_MAJOR;
 	reg_msg.minor = LTTNG_UST_COMM_VERSION_MINOR;
 	reg_msg.pid = getpid();
+	reg_msg.ppid = getppid();
 	reg_msg.uid = getuid();
+	reg_msg.gid = getgid();
+	prctl_ret = prctl(PR_GET_NAME, (unsigned long) reg_msg.name, 0, 0, 0);
+	if (prctl_ret) {
+		ERR("Error executing prctl");
+		return -errno;
+	}
 
 	ret = lttcomm_send_unix_sock(socket, &reg_msg, sizeof(reg_msg));
 	if (ret >= 0 && ret != sizeof(reg_msg))
@@ -99,9 +166,9 @@ int send_reply(int sock, struct lttcomm_ust_reply *lur)
 {
 	ssize_t len;
 
-	len = lttcomm_send_unix_sock(sock, &lur, sizeof(lur));
+	len = lttcomm_send_unix_sock(sock, lur, sizeof(*lur));
 	switch (len) {
-	case sizeof(lur):
+	case sizeof(*lur):
 		DBG("message successfully sent");
 		return 0;
 	case -1:
@@ -117,62 +184,102 @@ int send_reply(int sock, struct lttcomm_ust_reply *lur)
 }
 
 static
-int handle_message(int sock, struct lttcomm_ust_msg *lum)
+int handle_register_done(struct sock_info *sock_info)
+{
+	int ret;
+
+	if (sock_info->constructor_sem_posted)
+		return 0;
+	sock_info->constructor_sem_posted = 1;
+	ret = uatomic_add_return(&sem_count, -1);
+	if (ret == 0) {
+		ret = sem_post(&constructor_wait);
+		assert(!ret);
+	}
+	return 0;
+}
+
+static
+int handle_message(struct sock_info *sock_info,
+		int sock, struct lttcomm_ust_msg *lum)
 {
 	int ret = 0;
+	const struct objd_ops *ops;
+	struct lttcomm_ust_reply lur;
 
 	pthread_mutex_lock(&lttng_ust_comm_mutex);
 
+	memset(&lur, 0, sizeof(lur));
+
 	if (lttng_ust_comm_should_quit) {
-		ret = 0;
+		ret = -EPERM;
 		goto end;
 	}
 
-	switch (lum->cmd_type) {
-	case UST_CREATE_SESSION:
-	{
-		struct lttcomm_ust_reply lur;
-
-		DBG("Handling create session message");
-		memset(&lur, 0, sizeof(lur));
-		lur.cmd_type = UST_CREATE_SESSION;
-		ret = lttng_abi_create_session();
-		if (ret >= 0) {
-			lur.ret_val = ret;
-			lur.ret_code = LTTCOMM_OK;
-		} else {
-			lur.ret_code = LTTCOMM_SESSION_FAIL;
-		}
-		ret = send_reply(sock, &lur);
-		break;
+	ops = objd_ops(lum->handle);
+	if (!ops) {
+		ret = -ENOENT;
+		goto end;
 	}
-	case UST_RELEASE:
-	{
-		struct lttcomm_ust_reply lur;
-
-		DBG("Handling release message, handle: %d",
-			lum->handle);
-		memset(&lur, 0, sizeof(lur));
-		lur.cmd_type = UST_RELEASE;
-		ret = objd_unref(lum->handle);
-		if (!ret) {
-			lur.ret_code = LTTCOMM_OK;
-		} else {
-			lur.ret_code = LTTCOMM_ERR;
-		}
-		ret = send_reply(sock, &lur);
+
+	switch (lum->cmd) {
+	case LTTNG_UST_REGISTER_DONE:
+		if (lum->handle == LTTNG_UST_ROOT_HANDLE)
+			ret = handle_register_done(sock_info);
+		else
+			ret = -EINVAL;
+		break;
+	case LTTNG_UST_RELEASE:
+		if (lum->handle == LTTNG_UST_ROOT_HANDLE)
+			ret = -EPERM;
+		else
+			ret = objd_unref(lum->handle);
 		break;
-	}
 	default:
-		ERR("Unimplemented command %d", (int) lum->cmd_type);
-		ret = -1;
-		goto end;
+		if (ops->cmd)
+			ret = ops->cmd(lum->handle, lum->cmd,
+					(unsigned long) &lum->u);
+		else
+			ret = -ENOSYS;
+		break;
 	}
+
 end:
+	lur.handle = lum->handle;
+	lur.cmd = lum->cmd;
+	lur.ret_val = ret;
+	if (ret >= 0) {
+		lur.ret_code = LTTCOMM_OK;
+	} else {
+		lur.ret_code = LTTCOMM_SESSION_FAIL;
+	}
+	ret = send_reply(sock, &lur);
+
 	pthread_mutex_unlock(&lttng_ust_comm_mutex);
 	return ret;
 }
 
+static
+void cleanup_sock_info(struct sock_info *sock_info)
+{
+	int ret;
+
+	if (sock_info->socket != -1) {
+		ret = close(sock_info->socket);
+		if (ret) {
+			ERR("Error closing local apps socket");
+		}
+		sock_info->socket = -1;
+	}
+	if (sock_info->root_handle != -1) {
+		ret = objd_unref(sock_info->root_handle);
+		if (ret) {
+			ERR("Error unref root handle");
+		}
+		sock_info->root_handle = -1;
+	}
+}
+
 /*
  * This thread does not allocate any resource, except within
  * handle_message, within mutex protection. This mutex protects against
@@ -198,54 +305,83 @@ restart:
 	if (sock_info->socket != -1) {
 		ret = close(sock_info->socket);
 		if (ret) {
-			ERR("Error closing local apps socket");
+			ERR("Error closing %s apps socket", sock_info->name);
 		}
 		sock_info->socket = -1;
 	}
+
 	/* Check for sessiond availability with pipe TODO */
 
 	/* Register */
 	ret = lttcomm_connect_unix_sock(sock_info->sock_path);
 	if (ret < 0) {
-		ERR("Error connecting to global apps socket");
+		ERR("Error connecting to %s apps socket", sock_info->name);
+		/*
+		 * If we cannot find the sessiond daemon, don't delay
+		 * constructor execution.
+		 */
+		ret = handle_register_done(sock_info);
+		assert(!ret);
 		pthread_mutex_unlock(&lttng_ust_comm_mutex);
+		sleep(5);
 		goto restart;
-	} else {
-		sock_info->socket = sock = ret;
-		pthread_mutex_unlock(&lttng_ust_comm_mutex);
+	}
+
+	sock_info->socket = sock = ret;
+
+	/*
+	 * Create only one root handle per listener thread for the whole
+	 * process lifetime.
+	 */
+	if (sock_info->root_handle == -1) {
+		ret = lttng_abi_create_root_handle();
+		if (ret) {
+			ERR("Error creating root handle");
+			pthread_mutex_unlock(&lttng_ust_comm_mutex);
+			goto quit;
+		}
+		sock_info->root_handle = ret;
 	}
 
 	ret = register_app_to_sessiond(sock);
 	if (ret < 0) {
-		ERR("Error registering app to local apps socket");
+		ERR("Error registering to %s apps socket", sock_info->name);
+		/*
+		 * If we cannot register to the sessiond daemon, don't
+		 * delay constructor execution.
+		 */
+		ret = handle_register_done(sock_info);
+		assert(!ret);
+		pthread_mutex_unlock(&lttng_ust_comm_mutex);
 		sleep(5);
 		goto restart;
 	}
+	pthread_mutex_unlock(&lttng_ust_comm_mutex);
+
 	for (;;) {
 		ssize_t len;
 		struct lttcomm_ust_msg lum;
 
-		/* Receive session handle */
 		len = lttcomm_recv_unix_sock(sock, &lum, sizeof(lum));
 		switch (len) {
 		case 0:	/* orderly shutdown */
-			DBG("ltt-sessiond has performed an orderly shutdown\n");
+			DBG("%s ltt-sessiond has performed an orderly shutdown\n", sock_info->name);
 			goto end;
 		case sizeof(lum):
 			DBG("message received\n");
-			ret = handle_message(sock, &lum);
+			ret = handle_message(sock_info, sock, &lum);
 			if (ret < 0) {
-				ERR("Error handling message\n");
+				ERR("Error handling message for %s socket", sock_info->name);
 			}
 			continue;
 		case -1:
 			if (errno == ECONNRESET) {
-				ERR("remote end closed connection\n");
+				ERR("%s remote end closed connection\n", sock_info->name);
 				goto end;
 			}
 			goto end;
 		default:
-			ERR("incorrect message size: %zd\n", len);
+			ERR("incorrect message size (%s socket): %zd\n", sock_info->name, len);
 			continue;
 		}
 
@@ -256,6 +392,45 @@ quit:
 	return NULL;
 }
 
+/*
+ * Return values: -1: don't wait. 0: wait forever. 1: timeout wait.
+ */
+static
+int get_timeout(struct timespec *constructor_timeout)
+{
+	long constructor_delay_ms = LTTNG_UST_DEFAULT_CONSTRUCTOR_TIMEOUT_MS;
+	char *str_delay;
+	int ret;
+
+	str_delay = getenv("UST_REGISTER_TIMEOUT");
+	if (str_delay) {
+		constructor_delay_ms = strtol(str_delay, NULL, 10);
+	}
+
+	switch (constructor_delay_ms) {
+	case -1:/* fall-through */
+	case 0:
+		return constructor_delay_ms;
+	default:
+		break;
+	}
+
+	/*
+	 * If we are unable to find the current time, don't wait.
+	 */
+	ret = clock_gettime(CLOCK_REALTIME, constructor_timeout);
+	if (ret) {
+		return -1;
+	}
+	constructor_timeout->tv_sec += constructor_delay_ms / 1000UL;
+	constructor_timeout->tv_nsec +=
+		(constructor_delay_ms % 1000UL) * 1000000UL;
+	if (constructor_timeout->tv_nsec >= 1000000000UL) {
+		constructor_timeout->tv_sec++;
+		constructor_timeout->tv_nsec -= 1000000000UL;
+	}
+	return 1;
+}
 
 /*
  * sessiond monitoring thread: monitor presence of global and per-user
@@ -263,25 +438,70 @@ quit:
  */
 /* TODO */
 
-void __attribute__((constructor)) lttng_ust_comm_init(void)
+void __attribute__((constructor)) lttng_ust_init(void)
 {
+	struct timespec constructor_timeout;
+	int timeout_mode;
 	int ret;
 
+	if (uatomic_xchg(&initialized, 1) == 1)
+		return;
+
+	/*
+	 * We want precise control over the order in which we construct
+	 * our sub-libraries vs starting to receive commands from
+	 * sessiond (otherwise leading to errors when trying to create
+	 * sessiond before the init functions are completed).
+	 */
 	init_usterr();
+	init_tracepoint();
+	ltt_ring_buffer_metadata_client_init();
+	ltt_ring_buffer_client_overwrite_init();
+	ltt_ring_buffer_client_discard_init();
+
+	timeout_mode = get_timeout(&constructor_timeout);
+
+	ret = sem_init(&constructor_wait, 0, 0);
+	assert(!ret);
 
-	ret = setup_local_apps_socket();
+	ret = setup_local_apps();
 	if (ret) {
-		ERR("Error setting up to local apps socket");
+		ERR("Error setting up to local apps");
 	}
-#if 0
-	ret = pthread_create(&global_apps.ust_listener, NULL,
-			ust_listener_thread, &global_apps);
-#endif //0
 	ret = pthread_create(&local_apps.ust_listener, NULL,
 			ust_listener_thread, &local_apps);
+
+	if (local_apps.allowed) {
+		ret = pthread_create(&global_apps.ust_listener, NULL,
+				ust_listener_thread, &global_apps);
+	} else {
+		handle_register_done(&local_apps);
+	}
+
+	switch (timeout_mode) {
+	case 1:	/* timeout wait */
+		do {
+			ret = sem_timedwait(&constructor_wait,
+					&constructor_timeout);
+		} while (ret < 0 && errno == EINTR);
+		if (ret < 0 && errno == ETIMEDOUT) {
+			ERR("Timed out waiting for ltt-sessiond");
+		} else {
+			assert(!ret);
+		}
+		break;
+	case -1:/* wait forever */
+		do {
+			ret = sem_wait(&constructor_wait);
+		} while (ret < 0 && errno == EINTR);
+		assert(!ret);
+		break;
+	case 0:	/* no timeout */
+		break;
+	}
 }
 
-void __attribute__((destructor)) lttng_ust_comm_exit(void)
+void __attribute__((destructor)) lttng_ust_exit(void)
 {
 	int ret;
 
@@ -300,27 +520,81 @@ void __attribute__((destructor)) lttng_ust_comm_exit(void)
 	lttng_ust_comm_should_quit = 1;
 	pthread_mutex_unlock(&lttng_ust_comm_mutex);
 
-#if 0
 	ret = pthread_cancel(global_apps.ust_listener);
 	if (ret) {
 		ERR("Error cancelling global ust listener thread");
 	}
-#endif //0
-	if (global_apps.socket != -1) {
-		ret = close(global_apps.socket);
-		assert(!ret);
-	}
 
-	ret = pthread_cancel(local_apps.ust_listener);
-	if (ret) {
-		ERR("Error cancelling local ust listener thread");
-	}
+	cleanup_sock_info(&global_apps);
 
-	if (local_apps.socket != -1) {
-		ret = close(local_apps.socket);
-		assert(!ret);
+	if (local_apps.allowed) {
+		ret = pthread_cancel(local_apps.ust_listener);
+		if (ret) {
+			ERR("Error cancelling local ust listener thread");
+		}
+
+		cleanup_sock_info(&local_apps);
 	}
 
 	lttng_ust_abi_exit();
 	ltt_events_exit();
+	ltt_ring_buffer_client_discard_exit();
+	ltt_ring_buffer_client_overwrite_exit();
+	ltt_ring_buffer_metadata_client_exit();
+	exit_tracepoint();
+}
+
+/*
+ * We exclude the worker threads across fork and clone (except
+ * CLONE_VM), because these system calls only keep the forking thread
+ * running in the child.  Therefore, we don't want to call fork or clone
+ * in the middle of an tracepoint or ust tracing state modification.
+ * Holding this mutex protects these structures across fork and clone.
+ */
+void ust_before_fork(ust_fork_info_t *fork_info)
+{
+	/*
+	 * Disable signals. This is to avoid that the child intervenes
+	 * before it is properly setup for tracing. It is safer to
+	 * disable all signals, because then we know we are not breaking
+	 * anything by restoring the original mask.
+         */
+	sigset_t all_sigs;
+	int ret;
+
+	/* Disable signals */
+	sigfillset(&all_sigs);
+	ret = sigprocmask(SIG_BLOCK, &all_sigs, &fork_info->orig_sigs);
+	if (ret == -1) {
+		PERROR("sigprocmask");
+	}
+	pthread_mutex_lock(&lttng_ust_comm_mutex);
+	rcu_bp_before_fork();
+}
+
+static void ust_after_fork_common(ust_fork_info_t *fork_info)
+{
+	int ret;
+
+	pthread_mutex_unlock(&lttng_ust_comm_mutex);
+	/* Restore signals */
+	ret = sigprocmask(SIG_SETMASK, &fork_info->orig_sigs, NULL);
+	if (ret == -1) {
+		PERROR("sigprocmask");
+	}
+}
+
+void ust_after_fork_parent(ust_fork_info_t *fork_info)
+{
+	rcu_bp_after_fork_parent();
+	/* Release mutexes and reenable signals */
+	ust_after_fork_common(fork_info);
+}
+
+void ust_after_fork_child(ust_fork_info_t *fork_info)
+{
+	/* Release urcu mutexes */
+	rcu_bp_after_fork_child();
+	/* Release mutexes and reenable signals */
+	ust_after_fork_common(fork_info);
 }