[lttng-ust.git] / libust / lttng-ust-comm.c

/*
 * lttng-ust-comm.c
 *
 * Copyright (C) 2011 David Goulet <david.goulet@polymtl.ca>
 * Copyright (C) 2011 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; only
 * version 2.1 of the License.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

#include <sys/types.h>
#include <sys/socket.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 <urcu/uatomic.h>

/*
 * communication thread mutex. Held when handling a command, also held
 * by fork() to deal with removal of threads, and by exit path.
 */
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;
};

/* 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,
};

/* TODO: allow global_apps_sock_path override */

struct sock_info local_apps = {
	.name = "local",
	.socket = -1,
	.root_handle = -1,
};

static
int setup_local_apps_socket(void)
{
	const char *home_dir;

	home_dir = (const char *) getenv("HOME");
	if (!home_dir)
		return -ENOENT;
	snprintf(local_apps.sock_path, PATH_MAX,
		 DEFAULT_HOME_APPS_UNIX_SOCK, home_dir);
	return 0;
}

static
int register_app_to_sessiond(int socket)
{
	ssize_t ret;
	struct {
		uint32_t major;
		uint32_t minor;
		pid_t pid;
		uid_t uid;
	} reg_msg;

	reg_msg.major = LTTNG_UST_COMM_VERSION_MAJOR;
	reg_msg.minor = LTTNG_UST_COMM_VERSION_MINOR;
	reg_msg.pid = getpid();
	reg_msg.uid = getuid();

	ret = lttcomm_send_unix_sock(socket, &reg_msg, sizeof(reg_msg));
	if (ret >= 0 && ret != sizeof(reg_msg))
		return -EIO;
	return ret;
}

static
int send_reply(int sock, struct lttcomm_ust_reply *lur)
{
	ssize_t len;

	len = lttcomm_send_unix_sock(sock, lur, sizeof(*lur));
	switch (len) {
	case sizeof(*lur):
		DBG("message successfully sent");
		return 0;
	case -1:
		if (errno == ECONNRESET) {
			printf("remote end closed connection\n");
			return 0;
		}
		return -1;
	default:
		printf("incorrect message size: %zd\n", len);
		return -1;
	}
}

static
int handle_register_done(void)
{
	int ret;

	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 = -EPERM;
		goto end;
	}

	ops = objd_ops(lum->handle);
	if (!ops) {
		ret = -ENOENT;
		goto end;
	}

	switch (lum->cmd) {
	case LTTNG_UST_REGISTER_DONE:
		if (lum->handle == LTTNG_UST_ROOT_HANDLE)
			ret = handle_register_done();
		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:
		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
 * fork and exit.
 * The other moment it allocates resources is at socket connexion, which
 * is also protected by the mutex.
 */
static
void *ust_listener_thread(void *arg)
{
	struct sock_info *sock_info = arg;
	int sock, ret;

	/* Restart trying to connect to the session daemon */
restart:
	pthread_mutex_lock(&lttng_ust_comm_mutex);

	if (lttng_ust_comm_should_quit) {
		pthread_mutex_unlock(&lttng_ust_comm_mutex);
		goto quit;
	}

	if (sock_info->socket != -1) {
		ret = close(sock_info->socket);
		if (ret) {
			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 %s apps socket", sock_info->name);
		/*
		 * If we cannot find the sessiond daemon, don't delay
		 * constructor execution.
		 */
		ret = handle_register_done();
		assert(!ret);
		pthread_mutex_unlock(&lttng_ust_comm_mutex);
		sleep(5);
		goto restart;
	}

	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 to %s apps socket", sock_info->name);
		/*
		 * If we cannot register to the sessiond daemon, don't
		 * delay constructor execution.
		 */
		ret = handle_register_done();
		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;

		len = lttcomm_recv_unix_sock(sock, &lum, sizeof(lum));
		switch (len) {
		case 0:	/* orderly shutdown */
			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_info, sock, &lum);
			if (ret < 0) {
				ERR("Error handling message for %s socket", sock_info->name);
			}
			continue;
		case -1:
			if (errno == ECONNRESET) {
				ERR("%s remote end closed connection\n", sock_info->name);
				goto end;
			}
			goto end;
		default:
			ERR("incorrect message size (%s socket): %zd\n", sock_info->name, len);
			continue;
		}

	}
end:
	goto restart;	/* try to reconnect */
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
 * sessiond by polling the application common named pipe.
 */
/* TODO */

void __attribute__((constructor)) lttng_ust_comm_init(void)
{
	struct timespec constructor_timeout;
	int timeout_mode;
	int ret;

	init_usterr();

	timeout_mode = get_timeout(&constructor_timeout);

	ret = sem_init(&constructor_wait, 0, 0);
	assert(!ret);

	ret = setup_local_apps_socket();
	if (ret) {
		ERR("Error setting up to local apps socket");
	}

	ret = pthread_create(&global_apps.ust_listener, NULL,
			ust_listener_thread, &global_apps);
	ret = pthread_create(&local_apps.ust_listener, NULL,
			ust_listener_thread, &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)
{
	int ret;

	/*
	 * Using pthread_cancel here because:
	 * A) we don't want to hang application teardown.
	 * B) the thread is not allocating any resource.
	 */

	/*
	 * Require the communication thread to quit. Synchronize with
	 * mutexes to ensure it is not in a mutex critical section when
	 * pthread_cancel is later called.
	 */
	pthread_mutex_lock(&lttng_ust_comm_mutex);
	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

	cleanup_sock_info(&global_apps);

	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();
}
Commit	Line	Data
	1	/*
	2	* lttng-ust-comm.c
	3	*
	4	* Copyright (C) 2011 David Goulet <david.goulet@polymtl.ca>
	5	* Copyright (C) 2011 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
	6	*
	7	* This library is free software; you can redistribute it and/or
	8	* modify it under the terms of the GNU Lesser General Public
	9	* License as published by the Free Software Foundation; only
	10	* version 2.1 of the License.
	11	*
	12	* This library is distributed in the hope that it will be useful,
	13	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	15	* Lesser General Public License for more details.
	16	*
	17	* You should have received a copy of the GNU Lesser General Public
	18	* License along with this library; if not, write to the Free Software
	19	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
	20	*/
	21
	22	#include <sys/types.h>
	23	#include <sys/socket.h>
	24	#include <unistd.h>
	25	#include <errno.h>
	26	#include <ust/lttng-ust-abi.h>
	27	#include <lttng-ust-comm.h>
	28	#include <ust/usterr-signal-safe.h>
	29	#include <pthread.h>
	30	#include <semaphore.h>
	31	#include <time.h>
	32	#include <assert.h>
	33	#include <urcu/uatomic.h>
	34
	35	/*
	36	* communication thread mutex. Held when handling a command, also held
	37	* by fork() to deal with removal of threads, and by exit path.
	38	*/
	39	static pthread_mutex_t lttng_ust_comm_mutex = PTHREAD_MUTEX_INITIALIZER;
	40
	41	/* Should the ust comm thread quit ? */
	42	static int lttng_ust_comm_should_quit;
	43
	44	/*
	45	* Wait for either of these before continuing to the main
	46	* program:
	47	* - the register_done message from sessiond daemon
	48	* (will let the sessiond daemon enable sessions before main
	49	* starts.)
	50	* - sessiond daemon is not reachable.
	51	* - timeout (ensuring applications are resilient to session
	52	* daemon problems).
	53	*/
	54	static sem_t constructor_wait;
	55	/*
	56	* Doing this for both the global and local sessiond.
	57	*/
	58	static int sem_count = { 2 };
	59
	60	/*
	61	* Info about socket and associated listener thread.
	62	*/
	63	struct sock_info {
	64	const char *name;
	65	char sock_path[PATH_MAX];
	66	int socket;
	67	pthread_t ust_listener; /* listener thread */
	68	int root_handle;
	69	};
	70
	71	/* Socket from app (connect) to session daemon (listen) for communication */
	72	struct sock_info global_apps = {
	73	.name = "global",
	74	.sock_path = DEFAULT_GLOBAL_APPS_UNIX_SOCK,
	75	.socket = -1,
	76	.root_handle = -1,
	77	};
	78
	79	/* TODO: allow global_apps_sock_path override */
	80
	81	struct sock_info local_apps = {
	82	.name = "local",
	83	.socket = -1,
	84	.root_handle = -1,
	85	};
	86
	87	static
	88	int setup_local_apps_socket(void)
	89	{
	90	const char *home_dir;
	91
	92	home_dir = (const char *) getenv("HOME");
	93	if (!home_dir)
	94	return -ENOENT;
	95	snprintf(local_apps.sock_path, PATH_MAX,
	96	DEFAULT_HOME_APPS_UNIX_SOCK, home_dir);
	97	return 0;
	98	}
	99
	100	static
	101	int register_app_to_sessiond(int socket)
	102	{
	103	ssize_t ret;
	104	struct {
	105	uint32_t major;
	106	uint32_t minor;
	107	pid_t pid;
	108	uid_t uid;
	109	} reg_msg;
	110
	111	reg_msg.major = LTTNG_UST_COMM_VERSION_MAJOR;
	112	reg_msg.minor = LTTNG_UST_COMM_VERSION_MINOR;
	113	reg_msg.pid = getpid();
	114	reg_msg.uid = getuid();
	115
	116	ret = lttcomm_send_unix_sock(socket, &reg_msg, sizeof(reg_msg));
	117	if (ret >= 0 && ret != sizeof(reg_msg))
	118	return -EIO;
	119	return ret;
	120	}
	121
	122	static
	123	int send_reply(int sock, struct lttcomm_ust_reply *lur)
	124	{
	125	ssize_t len;
	126
	127	len = lttcomm_send_unix_sock(sock, lur, sizeof(*lur));
	128	switch (len) {
	129	case sizeof(*lur):
	130	DBG("message successfully sent");
	131	return 0;
	132	case -1:
	133	if (errno == ECONNRESET) {
	134	printf("remote end closed connection\n");
	135	return 0;
	136	}
	137	return -1;
	138	default:
	139	printf("incorrect message size: %zd\n", len);
	140	return -1;
	141	}
	142	}
	143
	144	static
	145	int handle_register_done(void)
	146	{
	147	int ret;
	148
	149	ret = uatomic_add_return(&sem_count, -1);
	150	if (ret == 0) {
	151	ret = sem_post(&constructor_wait);
	152	assert(!ret);
	153	}
	154	return 0;
	155	}
	156
	157	static
	158	int handle_message(struct sock_info *sock_info,
	159	int sock, struct lttcomm_ust_msg *lum)
	160	{
	161	int ret = 0;
	162	const struct objd_ops *ops;
	163	struct lttcomm_ust_reply lur;
	164
	165	pthread_mutex_lock(&lttng_ust_comm_mutex);
	166
	167	memset(&lur, 0, sizeof(lur));
	168
	169	if (lttng_ust_comm_should_quit) {
	170	ret = -EPERM;
	171	goto end;
	172	}
	173
	174	ops = objd_ops(lum->handle);
	175	if (!ops) {
	176	ret = -ENOENT;
	177	goto end;
	178	}
	179
	180	switch (lum->cmd) {
	181	case LTTNG_UST_REGISTER_DONE:
	182	if (lum->handle == LTTNG_UST_ROOT_HANDLE)
	183	ret = handle_register_done();
	184	else
	185	ret = -EINVAL;
	186	break;
	187	case LTTNG_UST_RELEASE:
	188	if (lum->handle == LTTNG_UST_ROOT_HANDLE)
	189	ret = -EPERM;
	190	else
	191	ret = objd_unref(lum->handle);
	192	break;
	193	default:
	194	if (ops->cmd)
	195	ret = ops->cmd(lum->handle, lum->cmd,
	196	(unsigned long) &lum->u);
	197	else
	198	ret = -ENOSYS;
	199	break;
	200	}
	201
	202	end:
	203	lur.handle = lum->handle;
	204	lur.cmd = lum->cmd;
	205	lur.ret_val = ret;
	206	if (ret >= 0) {
	207	lur.ret_code = LTTCOMM_OK;
	208	} else {
	209	lur.ret_code = LTTCOMM_SESSION_FAIL;
	210	}
	211	ret = send_reply(sock, &lur);
	212
	213	pthread_mutex_unlock(&lttng_ust_comm_mutex);
	214	return ret;
	215	}
	216
	217	static
	218	void cleanup_sock_info(struct sock_info *sock_info)
	219	{
	220	int ret;
	221
	222	if (sock_info->socket != -1) {
	223	ret = close(sock_info->socket);
	224	if (ret) {
	225	ERR("Error closing local apps socket");
	226	}
	227	sock_info->socket = -1;
	228	}
	229	if (sock_info->root_handle != -1) {
	230	ret = objd_unref(sock_info->root_handle);
	231	if (ret) {
	232	ERR("Error unref root handle");
	233	}
	234	sock_info->root_handle = -1;
	235	}
	236	}
	237
	238	/*
	239	* This thread does not allocate any resource, except within
	240	* handle_message, within mutex protection. This mutex protects against
	241	* fork and exit.
	242	* The other moment it allocates resources is at socket connexion, which
	243	* is also protected by the mutex.
	244	*/
	245	static
	246	void ust_listener_thread(void arg)
	247	{
	248	struct sock_info *sock_info = arg;
	249	int sock, ret;
	250
	251	/* Restart trying to connect to the session daemon */
	252	restart:
	253	pthread_mutex_lock(&lttng_ust_comm_mutex);
	254
	255	if (lttng_ust_comm_should_quit) {
	256	pthread_mutex_unlock(&lttng_ust_comm_mutex);
	257	goto quit;
	258	}
	259
	260	if (sock_info->socket != -1) {
	261	ret = close(sock_info->socket);
	262	if (ret) {
	263	ERR("Error closing %s apps socket", sock_info->name);
	264	}
	265	sock_info->socket = -1;
	266	}
	267
	268	/* Check for sessiond availability with pipe TODO */
	269
	270	/* Register */
	271	ret = lttcomm_connect_unix_sock(sock_info->sock_path);
	272	if (ret < 0) {
	273	ERR("Error connecting to %s apps socket", sock_info->name);
	274	/*
	275	* If we cannot find the sessiond daemon, don't delay
	276	* constructor execution.
	277	*/
	278	ret = handle_register_done();
	279	assert(!ret);
	280	pthread_mutex_unlock(&lttng_ust_comm_mutex);
	281	sleep(5);
	282	goto restart;
	283	}
	284
	285	sock_info->socket = sock = ret;
	286
	287	/*
	288	* Create only one root handle per listener thread for the whole
	289	* process lifetime.
	290	*/
	291	if (sock_info->root_handle == -1) {
	292	ret = lttng_abi_create_root_handle();
	293	if (ret) {
	294	ERR("Error creating root handle");
	295	pthread_mutex_unlock(&lttng_ust_comm_mutex);
	296	goto quit;
	297	}
	298	sock_info->root_handle = ret;
	299	}
	300
	301	ret = register_app_to_sessiond(sock);
	302	if (ret < 0) {
	303	ERR("Error registering to %s apps socket", sock_info->name);
	304	/*
	305	* If we cannot register to the sessiond daemon, don't
	306	* delay constructor execution.
	307	*/
	308	ret = handle_register_done();
	309	assert(!ret);
	310	pthread_mutex_unlock(&lttng_ust_comm_mutex);
	311	sleep(5);
	312	goto restart;
	313	}
	314	pthread_mutex_unlock(&lttng_ust_comm_mutex);
	315
	316	for (;;) {
	317	ssize_t len;
	318	struct lttcomm_ust_msg lum;
	319
	320	len = lttcomm_recv_unix_sock(sock, &lum, sizeof(lum));
	321	switch (len) {
	322	case 0: /* orderly shutdown */
	323	DBG("%s ltt-sessiond has performed an orderly shutdown\n", sock_info->name);
	324	goto end;
	325	case sizeof(lum):
	326	DBG("message received\n");
	327	ret = handle_message(sock_info, sock, &lum);
	328	if (ret < 0) {
	329	ERR("Error handling message for %s socket", sock_info->name);
	330	}
	331	continue;
	332	case -1:
	333	if (errno == ECONNRESET) {
	334	ERR("%s remote end closed connection\n", sock_info->name);
	335	goto end;
	336	}
	337	goto end;
	338	default:
	339	ERR("incorrect message size (%s socket): %zd\n", sock_info->name, len);
	340	continue;
	341	}
	342
	343	}
	344	end:
	345	goto restart; /* try to reconnect */
	346	quit:
	347	return NULL;
	348	}
	349
	350	/*
	351	* Return values: -1: don't wait. 0: wait forever. 1: timeout wait.
	352	*/
	353	static
	354	int get_timeout(struct timespec *constructor_timeout)
	355	{
	356	long constructor_delay_ms = LTTNG_UST_DEFAULT_CONSTRUCTOR_TIMEOUT_MS;
	357	char *str_delay;
	358	int ret;
	359
	360	str_delay = getenv("UST_REGISTER_TIMEOUT");
	361	if (str_delay) {
	362	constructor_delay_ms = strtol(str_delay, NULL, 10);
	363	}
	364
	365	switch (constructor_delay_ms) {
	366	case -1:/* fall-through */
	367	case 0:
	368	return constructor_delay_ms;
	369	default:
	370	break;
	371	}
	372
	373	/*
	374	* If we are unable to find the current time, don't wait.
	375	*/
	376	ret = clock_gettime(CLOCK_REALTIME, constructor_timeout);
	377	if (ret) {
	378	return -1;
	379	}
	380	constructor_timeout->tv_sec += constructor_delay_ms / 1000UL;
	381	constructor_timeout->tv_nsec +=
	382	(constructor_delay_ms % 1000UL) * 1000000UL;
	383	if (constructor_timeout->tv_nsec >= 1000000000UL) {
	384	constructor_timeout->tv_sec++;
	385	constructor_timeout->tv_nsec -= 1000000000UL;
	386	}
	387	return 1;
	388	}
	389
	390	/*
	391	* sessiond monitoring thread: monitor presence of global and per-user
	392	* sessiond by polling the application common named pipe.
	393	*/
	394	/* TODO */
	395
	396	void __attribute__((constructor)) lttng_ust_comm_init(void)
	397	{
	398	struct timespec constructor_timeout;
	399	int timeout_mode;
	400	int ret;
	401
	402	init_usterr();
	403
	404	timeout_mode = get_timeout(&constructor_timeout);
	405
	406	ret = sem_init(&constructor_wait, 0, 0);
	407	assert(!ret);
	408
	409	ret = setup_local_apps_socket();
	410	if (ret) {
	411	ERR("Error setting up to local apps socket");
	412	}
	413
	414	ret = pthread_create(&global_apps.ust_listener, NULL,
	415	ust_listener_thread, &global_apps);
	416	ret = pthread_create(&local_apps.ust_listener, NULL,
	417	ust_listener_thread, &local_apps);
	418
	419	switch (timeout_mode) {
	420	case 1: /* timeout wait */
	421	do {
	422	ret = sem_timedwait(&constructor_wait,
	423	&constructor_timeout);
	424	} while (ret < 0 && errno == EINTR);
	425	if (ret < 0 && errno == ETIMEDOUT) {
	426	ERR("Timed out waiting for ltt-sessiond");
	427	} else {
	428	assert(!ret);
	429	}
	430	break;
	431	case -1:/* wait forever */
	432	do {
	433	ret = sem_wait(&constructor_wait);
	434	} while (ret < 0 && errno == EINTR);
	435	assert(!ret);
	436	break;
	437	case 0: /* no timeout */
	438	break;
	439	}
	440	}
	441
	442	void __attribute__((destructor)) lttng_ust_comm_exit(void)
	443	{
	444	int ret;
	445
	446	/*
	447	* Using pthread_cancel here because:
	448	* A) we don't want to hang application teardown.
	449	* B) the thread is not allocating any resource.
	450	*/
	451
	452	/*
	453	* Require the communication thread to quit. Synchronize with
	454	* mutexes to ensure it is not in a mutex critical section when
	455	* pthread_cancel is later called.
	456	*/
	457	pthread_mutex_lock(&lttng_ust_comm_mutex);
	458	lttng_ust_comm_should_quit = 1;
	459	pthread_mutex_unlock(&lttng_ust_comm_mutex);
	460
	461	#if 0
	462	ret = pthread_cancel(global_apps.ust_listener);
	463	if (ret) {
	464	ERR("Error cancelling global ust listener thread");
	465	}
	466	#endif //0
	467
	468	cleanup_sock_info(&global_apps);
	469
	470	ret = pthread_cancel(local_apps.ust_listener);
	471	if (ret) {
	472	ERR("Error cancelling local ust listener thread");
	473	}
	474
	475	cleanup_sock_info(&local_apps);
	476
	477	lttng_ust_abi_exit();
	478	ltt_events_exit();
	479	}