[lttng-ust.git] / src / lib / lttng-ust-common / fd-tracker.c

/*
 * SPDX-License-Identifier: LGPL-2.1-only
 *
 * Copyright (C) 2016 Aravind HT <aravind.ht@gmail.com>
 * Copyright (C) 2016 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
 */

#include <limits.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <unistd.h>
#include <assert.h>
#include <errno.h>
#include <fcntl.h>
#include <sys/select.h>
#include <sys/resource.h>
#include <sys/time.h>
#include <fcntl.h>
#include <pthread.h>
#include <signal.h>
#include <stdbool.h>
#include <dlfcn.h>
#include <urcu/compiler.h>
#include <urcu/tls-compat.h>
#include <urcu/system.h>

#include "common/ust-fd.h"
#include "common/macros.h"
#include <lttng/ust-error.h>
#include <lttng/ust-cancelstate.h>
#include "common/logging.h"

#include "lib/lttng-ust-common/fd-tracker.h"

/* Operations on the fd set. */
#define IS_FD_VALID(fd)			((fd) >= 0 && (fd) < lttng_ust_max_fd)
#define GET_FD_SET_FOR_FD(fd, fd_sets)	(&((fd_sets)[(fd) / FD_SETSIZE]))
#define CALC_INDEX_TO_SET(fd)		((fd) % FD_SETSIZE)
#define IS_FD_STD(fd)			(IS_FD_VALID(fd) && (fd) <= STDERR_FILENO)

/* Check fd validity before calling these. */
#define ADD_FD_TO_SET(fd, fd_sets)	\
		FD_SET(CALC_INDEX_TO_SET(fd), GET_FD_SET_FOR_FD(fd, fd_sets))
#define IS_FD_SET(fd, fd_sets)		\
		FD_ISSET(CALC_INDEX_TO_SET(fd), GET_FD_SET_FOR_FD(fd, fd_sets))
#define DEL_FD_FROM_SET(fd, fd_sets)	\
		FD_CLR(CALC_INDEX_TO_SET(fd), GET_FD_SET_FOR_FD(fd, fd_sets))

/*
 * Protect the lttng_fd_set. Nests within the ust_lock, and therefore
 * within the libc dl lock. Therefore, we need to allocate the TLS before
 * nesting into this lock.
 *
 * The ust_safe_guard_fd_mutex nests within the ust_mutex. This mutex
 * is also held across fork.
 */
static pthread_mutex_t ust_safe_guard_fd_mutex = PTHREAD_MUTEX_INITIALIZER;

/*
 * Track whether we are within lttng-ust or application, for close
 * system call override by LD_PRELOAD library. This also tracks whether
 * we are invoking close() from a signal handler nested on an
 * application thread.
 */
static DEFINE_URCU_TLS(int, ust_fd_mutex_nest);

/* fd_set used to book keep fd being used by lttng-ust. */
static fd_set *lttng_fd_set;
static int lttng_ust_max_fd;
static int num_fd_sets;
static int init_done;

/*
 * Force a read (imply TLS allocation for dlopen) of TLS variables.
 */
void lttng_ust_fd_tracker_alloc_tls(void)
{
	asm volatile ("" : : "m" (URCU_TLS(ust_fd_mutex_nest)));
}

/*
 * Allocate the fd set array based on the hard limit set for this
 * process. This will be called during the constructor execution
 * and will also be called in the child after fork via lttng_ust_init.
 */
void lttng_ust_fd_tracker_init(void)
{
	struct rlimit rlim;
	int i;

	if (CMM_LOAD_SHARED(init_done))
		return;

	memset(&rlim, 0, sizeof(rlim));
	/* Get the current possible max number of fd for this process. */
	if (getrlimit(RLIMIT_NOFILE, &rlim) < 0)
		abort();
	/*
	 * FD set array size determined using the hard limit. Even if
	 * the process wishes to increase its limit using setrlimit, it
	 * can only do so with the softlimit which will be less than the
	 * hard limit.
	 */
	lttng_ust_max_fd = rlim.rlim_max;
	num_fd_sets = lttng_ust_max_fd / FD_SETSIZE;
	if (lttng_ust_max_fd % FD_SETSIZE)
		++num_fd_sets;
	if (lttng_fd_set != NULL) {
		free(lttng_fd_set);
		lttng_fd_set = NULL;
	}
	lttng_fd_set = malloc(num_fd_sets * (sizeof(fd_set)));
	if (!lttng_fd_set)
		abort();
	for (i = 0; i < num_fd_sets; i++)
		FD_ZERO((&lttng_fd_set[i]));
	CMM_STORE_SHARED(init_done, 1);
}

static void lttng_ust_lock_fd_tracker_orig(void)
{
	sigset_t sig_all_blocked, orig_mask;
	int ret;

	if (lttng_ust_cancelstate_disable_push()) {
		ERR("lttng_ust_cancelstate_disable_push");
	}
	sigfillset(&sig_all_blocked);
	ret = pthread_sigmask(SIG_SETMASK, &sig_all_blocked, &orig_mask);
	if (ret) {
		ERR("pthread_sigmask: %s", strerror(ret));
	}
	if (!URCU_TLS(ust_fd_mutex_nest)++) {
		/*
		 * Ensure the compiler don't move the store after the close()
		 * call in case close() would be marked as leaf.
		 */
		cmm_barrier();
		pthread_mutex_lock(&ust_safe_guard_fd_mutex);
	}
	ret = pthread_sigmask(SIG_SETMASK, &orig_mask, NULL);
	if (ret) {
		ERR("pthread_sigmask: %s", strerror(ret));
	}
}

static void lttng_ust_unlock_fd_tracker_orig(void)
{
	sigset_t sig_all_blocked, orig_mask;
	int ret;

	sigfillset(&sig_all_blocked);
	ret = pthread_sigmask(SIG_SETMASK, &sig_all_blocked, &orig_mask);
	if (ret) {
		ERR("pthread_sigmask: %s", strerror(ret));
	}
	/*
	 * Ensure the compiler don't move the store before the close()
	 * call, in case close() would be marked as leaf.
	 */
	cmm_barrier();
	if (!--URCU_TLS(ust_fd_mutex_nest)) {
		pthread_mutex_unlock(&ust_safe_guard_fd_mutex);
	}
	ret = pthread_sigmask(SIG_SETMASK, &orig_mask, NULL);
	if (ret) {
		ERR("pthread_sigmask: %s", strerror(ret));
	}
	if (lttng_ust_cancelstate_disable_pop()) {
		ERR("lttng_ust_cancelstate_disable_pop");
	}
}

static int dup_std_fd(int fd)
{
	int ret, i;
	int fd_to_close[STDERR_FILENO + 1];
	int fd_to_close_count = 0;
	int dup_cmd = F_DUPFD; /* Default command */
	int fd_valid = -1;

	if (!(IS_FD_STD(fd))) {
		/* Should not be here */
		ret = -1;
		goto error;
	}

	/* Check for FD_CLOEXEC flag */
	ret = fcntl(fd, F_GETFD);
	if (ret < 0) {
		PERROR("fcntl on f_getfd");
		ret = -1;
		goto error;
	}

	if (ret & FD_CLOEXEC) {
		dup_cmd = F_DUPFD_CLOEXEC;
	}

	/* Perform dup */
	for (i = 0; i < STDERR_FILENO + 1; i++) {
		ret = fcntl(fd, dup_cmd, 0);
		if (ret < 0) {
			PERROR("fcntl dup fd");
			goto error;
		}

		if (!(IS_FD_STD(ret))) {
			/* fd is outside of STD range, use it. */
			fd_valid = ret;
			/* Close fd received as argument. */
			fd_to_close[i] = fd;
			fd_to_close_count++;
			break;
		}

		fd_to_close[i] = ret;
		fd_to_close_count++;
	}

	/* Close intermediary fds */
	for (i = 0; i < fd_to_close_count; i++) {
		ret = close(fd_to_close[i]);
		if (ret) {
			PERROR("close on temporary fd: %d.", fd_to_close[i]);
			/*
			 * Not using an abort here would yield a complicated
			 * error handling for the caller. If a failure occurs
			 * here, the system is already in a bad state.
			 */
			abort();
		}
	}

	ret = fd_valid;
error:
	return ret;
}

/*
 * Needs to be called with ust_safe_guard_fd_mutex held when opening the fd.
 * Has strict checking of fd validity.
 *
 * If fd <= 2, dup the fd until fd > 2. This enables us to bypass
 * problems that can be encountered if UST uses stdin, stdout, stderr
 * fds for internal use (daemon etc.). This can happen if the
 * application closes either of those file descriptors. Intermediary fds
 * are closed as needed.
 *
 * Return -1 on error.
 *
 */
static int lttng_ust_add_fd_to_tracker_orig(int fd)
{
	int ret;
	/*
	 * Ensure the tracker is initialized when called from
	 * constructors.
	 */
	lttng_ust_fd_tracker_init();
	assert(URCU_TLS(ust_fd_mutex_nest));

	if (IS_FD_STD(fd)) {
		ret = dup_std_fd(fd);
		if (ret < 0) {
			goto error;
		}
		fd = ret;
	}

	/* Trying to add an fd which we can not accommodate. */
	assert(IS_FD_VALID(fd));
	/* Setting an fd thats already set. */
	assert(!IS_FD_SET(fd, lttng_fd_set));

	ADD_FD_TO_SET(fd, lttng_fd_set);
	return fd;
error:
	return ret;
}

/*
 * Needs to be called with ust_safe_guard_fd_mutex held when opening the fd.
 * Has strict checking for fd validity.
 */
static void lttng_ust_delete_fd_from_tracker_orig(int fd)
{
	/*
	 * Ensure the tracker is initialized when called from
	 * constructors.
	 */
	lttng_ust_fd_tracker_init();

	assert(URCU_TLS(ust_fd_mutex_nest));
	/* Not a valid fd. */
	assert(IS_FD_VALID(fd));
	/* Deleting an fd which was not set. */
	assert(IS_FD_SET(fd, lttng_fd_set));

	DEL_FD_FROM_SET(fd, lttng_fd_set);
}

#if !defined(LTTNG_UST_CUSTOM_UPGRADE_CONFLICTING_SYMBOLS)
static int (*__lttng_ust_safe_close_fd)(int fd, int (*close_cb)(int fd)) = NULL;

static
void *_init_lttng_ust_safe_close_fd(void)
{
	if (__lttng_ust_safe_close_fd == NULL) {
		__lttng_ust_safe_close_fd = dlsym(RTLD_DEFAULT, "lttng_ust_safe_close_fd");

		if (__lttng_ust_safe_close_fd == NULL) {
			fprintf(stderr, "%s\n", dlerror());
		}
	}

	return __lttng_ust_safe_close_fd;
}

static int lttng_ust_safe_close_fd_chain(int fd, int (*close_cb)(int fd))
{
	if (_init_lttng_ust_safe_close_fd()) {
		/* Chain on ust-2.12 preload */
		return __lttng_ust_safe_close_fd(fd, close_cb);
	} else {
		/* Fallback to libc symbol */
		return close_cb(fd);
	}
}
#endif

/*
 * Interface allowing applications to close arbitrary file descriptors.
 * We check if it is owned by lttng-ust, and return -1, errno=EBADF
 * instead of closing it if it is the case.
 */
static int lttng_ust_safe_close_fd_orig(int fd, int (*close_cb)(int fd))
{
	int ret = 0;

	lttng_ust_fd_tracker_alloc_tls();

	/*
	 * Ensure the tracker is initialized when called from
	 * constructors.
	 */
	lttng_ust_fd_tracker_init();

	/*
	 * If called from lttng-ust, we directly call close without
	 * validating whether the FD is part of the tracked set.
	 */
	if (URCU_TLS(ust_fd_mutex_nest)) {
#if !defined(LTTNG_UST_CUSTOM_UPGRADE_CONFLICTING_SYMBOLS)
		return lttng_ust_safe_close_fd_chain(fd, close_cb);
#else
		return close_cb(fd);
#endif
	}

	lttng_ust_lock_fd_tracker();
	if (IS_FD_VALID(fd) && IS_FD_SET(fd, lttng_fd_set)) {
		ret = -1;
		errno = EBADF;
	} else {
#if !defined(LTTNG_UST_CUSTOM_UPGRADE_CONFLICTING_SYMBOLS)
		ret = lttng_ust_safe_close_fd_chain(fd, close_cb);
#else
		ret = close_cb(fd);
#endif
	}
	lttng_ust_unlock_fd_tracker();

	return ret;
}

#if !defined(LTTNG_UST_CUSTOM_UPGRADE_CONFLICTING_SYMBOLS)
static int (*__lttng_ust_safe_fclose_stream)(FILE *stream, int (*fclose_cb)(FILE *stream)) = NULL;

static
void *_init_lttng_ust_safe_fclose_stream(void)
{
	if (__lttng_ust_safe_fclose_stream == NULL) {
		__lttng_ust_safe_fclose_stream = dlsym(RTLD_DEFAULT, "lttng_ust_safe_fclose_stream");

		if (__lttng_ust_safe_fclose_stream == NULL) {
			fprintf(stderr, "%s\n", dlerror());
		}
	}

	return __lttng_ust_safe_fclose_stream;
}

static int lttng_ust_safe_fclose_stream_chain(FILE *stream, int (*fclose_cb)(FILE *stream))
{
	if (_init_lttng_ust_safe_fclose_stream()) {
		/* Chain on ust-2.12 preload */
		return __lttng_ust_safe_fclose_stream(stream, fclose_cb);
	} else {
		/* Fallback to libc symbol */
		return fclose_cb(stream);
	}
}
#endif

/*
 * Interface allowing applications to close arbitrary streams.
 * We check if it is owned by lttng-ust, and return -1, errno=EBADF
 * instead of closing it if it is the case.
 */
static int lttng_ust_safe_fclose_stream_orig(FILE *stream, int (*fclose_cb)(FILE *stream))
{
	int ret = 0, fd;

	lttng_ust_fd_tracker_alloc_tls();

	/*
	 * Ensure the tracker is initialized when called from
	 * constructors.
	 */
	lttng_ust_fd_tracker_init();

	/*
	 * If called from lttng-ust, we directly call fclose without
	 * validating whether the FD is part of the tracked set.
	 */
	if (URCU_TLS(ust_fd_mutex_nest)) {
#if !defined(LTTNG_UST_CUSTOM_UPGRADE_CONFLICTING_SYMBOLS)
		return lttng_ust_safe_fclose_stream_chain(stream, fclose_cb);
#else
		return fclose_cb(stream);
#endif
	}

	fd = fileno(stream);

	lttng_ust_lock_fd_tracker();
	if (IS_FD_VALID(fd) && IS_FD_SET(fd, lttng_fd_set)) {
		ret = -1;
		errno = EBADF;
	} else {
#if !defined(LTTNG_UST_CUSTOM_UPGRADE_CONFLICTING_SYMBOLS)
		ret = lttng_ust_safe_fclose_stream_chain(stream, fclose_cb);
#else
		ret = fclose_cb(stream);
#endif
	}
	lttng_ust_unlock_fd_tracker();

	return ret;
}

#ifdef __OpenBSD__
static void set_close_success(int *p)
{
	*p = 1;
}
static int test_close_success(const int *p)
{
	return *p;
}
#else
static void set_close_success(int *p  __attribute__((unused)))
{
}
static int test_close_success(const int *p __attribute__((unused)))
{
	return 1;
}
#endif

/*
 * Implement helper for closefrom() override.
 */
static int lttng_ust_safe_closefrom_fd_orig(int lowfd, int (*close_cb)(int fd))
{
	int ret = 0, close_success = 0, i;

	lttng_ust_fd_tracker_alloc_tls();

	/*
	 * Ensure the tracker is initialized when called from
	 * constructors.
	 */
	lttng_ust_fd_tracker_init();

	if (lowfd < 0) {
		/*
		 * NetBSD return EBADF if fd is invalid.
		 */
		errno = EBADF;
		ret = -1;
		goto end;
	}
	/*
	 * If called from lttng-ust, we directly call close without
	 * validating whether the FD is part of the tracked set.
	 */
	if (URCU_TLS(ust_fd_mutex_nest)) {
		for (i = lowfd; i < lttng_ust_max_fd; i++) {
			if (close_cb(i) < 0) {
				switch (errno) {
				case EBADF:
					continue;
				case EINTR:
				default:
					ret = -1;
					goto end;
				}
			}
			set_close_success(&close_success);
		}
	} else {
		lttng_ust_lock_fd_tracker();
		for (i = lowfd; i < lttng_ust_max_fd; i++) {
			if (IS_FD_VALID(i) && IS_FD_SET(i, lttng_fd_set))
				continue;
			if (close_cb(i) < 0) {
				switch (errno) {
				case EBADF:
					continue;
				case EINTR:
				default:
					ret = -1;
					lttng_ust_unlock_fd_tracker();
					goto end;
				}
			}
			set_close_success(&close_success);
		}
		lttng_ust_unlock_fd_tracker();
	}
	if (!test_close_success(&close_success)) {
		/*
		 * OpenBSD return EBADF if fd is greater than all open
		 * file descriptors.
		 */
		ret = -1;
		errno = EBADF;
	}
end:
	return ret;
}

/* Custom upgrade 2.12 to 2.13 */

#undef lttng_ust_add_fd_to_tracker
#undef lttng_ust_delete_fd_from_tracker
#undef lttng_ust_lock_fd_tracker
#undef lttng_ust_unlock_fd_tracker
#undef lttng_ust_safe_close_fd
#undef lttng_ust_safe_fclose_stream
#undef lttng_ust_safe_closefrom_fd

int lttng_ust_add_fd_to_tracker1(int fd)
	__attribute__ ((alias ("lttng_ust_add_fd_to_tracker_orig")));
void lttng_ust_delete_fd_from_tracker1(int fd)
	__attribute__ ((alias ("lttng_ust_delete_fd_from_tracker_orig")));
void lttng_ust_lock_fd_tracker1(void)
	__attribute__ ((alias ("lttng_ust_lock_fd_tracker_orig")));
void lttng_ust_unlock_fd_tracker1(void)
	__attribute__ ((alias ("lttng_ust_unlock_fd_tracker_orig")));
int lttng_ust_safe_close_fd1(int fd, int (*close_cb)(int))
	__attribute__ ((alias ("lttng_ust_safe_close_fd_orig")));
int lttng_ust_safe_fclose_stream1(FILE *stream, int (*fclose_cb)(FILE *stream))
	__attribute__ ((alias ("lttng_ust_safe_fclose_stream_orig")));
int lttng_ust_safe_closefrom_fd1(int lowfd, int (*close_cb)(int))
	__attribute__ ((alias ("lttng_ust_safe_closefrom_fd_orig")));

#ifdef LTTNG_UST_CUSTOM_UPGRADE_CONFLICTING_SYMBOLS
int lttng_ust_add_fd_to_tracker(int fd)
	__attribute__ ((alias ("lttng_ust_add_fd_to_tracker_orig")));
void lttng_ust_delete_fd_from_tracker(int fd)
	__attribute__ ((alias ("lttng_ust_delete_fd_from_tracker_orig")));
void lttng_ust_lock_fd_tracker(void)
	__attribute__ ((alias ("lttng_ust_lock_fd_tracker_orig")));
void lttng_ust_unlock_fd_tracker(void)
	__attribute__ ((alias ("lttng_ust_unlock_fd_tracker_orig")));
int lttng_ust_safe_close_fd(int fd, int (*close_cb)(int))
	__attribute__ ((alias ("lttng_ust_safe_close_fd_orig")));
int lttng_ust_safe_fclose_stream(FILE *stream, int (*fclose_cb)(FILE *stream))
	__attribute__ ((alias ("lttng_ust_safe_fclose_stream_orig")));
int lttng_ust_safe_closefrom_fd(int lowfd, int (*close_cb)(int))
	__attribute__ ((alias ("lttng_ust_safe_closefrom_fd_orig")));
#endif
Commit	Line	Data
	1	/*
	2	* SPDX-License-Identifier: LGPL-2.1-only
	3	*
	4	* Copyright (C) 2016 Aravind HT <aravind.ht@gmail.com>
	5	* Copyright (C) 2016 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
	6	*/
	7
	8	#include <limits.h>
	9	#include <stdio.h>
	10	#include <stdlib.h>
	11	#include <string.h>
	12	#include <sys/types.h>
	13	#include <unistd.h>
	14	#include <assert.h>
	15	#include <errno.h>
	16	#include <fcntl.h>
	17	#include <sys/select.h>
	18	#include <sys/resource.h>
	19	#include <sys/time.h>
	20	#include <fcntl.h>
	21	#include <pthread.h>
	22	#include <signal.h>
	23	#include <stdbool.h>
	24	#include <dlfcn.h>
	25	#include <urcu/compiler.h>
	26	#include <urcu/tls-compat.h>
	27	#include <urcu/system.h>
	28
	29	#include "common/ust-fd.h"
	30	#include "common/macros.h"
	31	#include <lttng/ust-error.h>
	32	#include <lttng/ust-cancelstate.h>
	33	#include "common/logging.h"
	34
	35	#include "lib/lttng-ust-common/fd-tracker.h"
	36
	37	/* Operations on the fd set. */
	38	#define IS_FD_VALID(fd) ((fd) >= 0 && (fd) < lttng_ust_max_fd)
	39	#define GET_FD_SET_FOR_FD(fd, fd_sets) (&((fd_sets)[(fd) / FD_SETSIZE]))
	40	#define CALC_INDEX_TO_SET(fd) ((fd) % FD_SETSIZE)
	41	#define IS_FD_STD(fd) (IS_FD_VALID(fd) && (fd) <= STDERR_FILENO)
	42
	43	/* Check fd validity before calling these. */
	44	#define ADD_FD_TO_SET(fd, fd_sets) \
	45	FD_SET(CALC_INDEX_TO_SET(fd), GET_FD_SET_FOR_FD(fd, fd_sets))
	46	#define IS_FD_SET(fd, fd_sets) \
	47	FD_ISSET(CALC_INDEX_TO_SET(fd), GET_FD_SET_FOR_FD(fd, fd_sets))
	48	#define DEL_FD_FROM_SET(fd, fd_sets) \
	49	FD_CLR(CALC_INDEX_TO_SET(fd), GET_FD_SET_FOR_FD(fd, fd_sets))
	50
	51	/*
	52	* Protect the lttng_fd_set. Nests within the ust_lock, and therefore
	53	* within the libc dl lock. Therefore, we need to allocate the TLS before
	54	* nesting into this lock.
	55	*
	56	* The ust_safe_guard_fd_mutex nests within the ust_mutex. This mutex
	57	* is also held across fork.
	58	*/
	59	static pthread_mutex_t ust_safe_guard_fd_mutex = PTHREAD_MUTEX_INITIALIZER;
	60
	61	/*
	62	* Track whether we are within lttng-ust or application, for close
	63	* system call override by LD_PRELOAD library. This also tracks whether
	64	* we are invoking close() from a signal handler nested on an
	65	* application thread.
	66	*/
	67	static DEFINE_URCU_TLS(int, ust_fd_mutex_nest);
	68
	69	/* fd_set used to book keep fd being used by lttng-ust. */
	70	static fd_set *lttng_fd_set;
	71	static int lttng_ust_max_fd;
	72	static int num_fd_sets;
	73	static int init_done;
	74
	75	/*
	76	* Force a read (imply TLS allocation for dlopen) of TLS variables.
	77	*/
	78	void lttng_ust_fd_tracker_alloc_tls(void)
	79	{
	80	asm volatile ("" : : "m" (URCU_TLS(ust_fd_mutex_nest)));
	81	}
	82
	83	/*
	84	* Allocate the fd set array based on the hard limit set for this
	85	* process. This will be called during the constructor execution
	86	* and will also be called in the child after fork via lttng_ust_init.
	87	*/
	88	void lttng_ust_fd_tracker_init(void)
	89	{
	90	struct rlimit rlim;
	91	int i;
	92
	93	if (CMM_LOAD_SHARED(init_done))
	94	return;
	95
	96	memset(&rlim, 0, sizeof(rlim));
	97	/* Get the current possible max number of fd for this process. */
	98	if (getrlimit(RLIMIT_NOFILE, &rlim) < 0)
	99	abort();
	100	/*
	101	* FD set array size determined using the hard limit. Even if
	102	* the process wishes to increase its limit using setrlimit, it
	103	* can only do so with the softlimit which will be less than the
	104	* hard limit.
	105	*/
	106	lttng_ust_max_fd = rlim.rlim_max;
	107	num_fd_sets = lttng_ust_max_fd / FD_SETSIZE;
	108	if (lttng_ust_max_fd % FD_SETSIZE)
	109	++num_fd_sets;
	110	if (lttng_fd_set != NULL) {
	111	free(lttng_fd_set);
	112	lttng_fd_set = NULL;
	113	}
	114	lttng_fd_set = malloc(num_fd_sets * (sizeof(fd_set)));
	115	if (!lttng_fd_set)
	116	abort();
	117	for (i = 0; i < num_fd_sets; i++)
	118	FD_ZERO((&lttng_fd_set[i]));
	119	CMM_STORE_SHARED(init_done, 1);
	120	}
	121
	122	static void lttng_ust_lock_fd_tracker_orig(void)
	123	{
	124	sigset_t sig_all_blocked, orig_mask;
	125	int ret;
	126
	127	if (lttng_ust_cancelstate_disable_push()) {
	128	ERR("lttng_ust_cancelstate_disable_push");
	129	}
	130	sigfillset(&sig_all_blocked);
	131	ret = pthread_sigmask(SIG_SETMASK, &sig_all_blocked, &orig_mask);
	132	if (ret) {
	133	ERR("pthread_sigmask: %s", strerror(ret));
	134	}
	135	if (!URCU_TLS(ust_fd_mutex_nest)++) {
	136	/*
	137	* Ensure the compiler don't move the store after the close()
	138	* call in case close() would be marked as leaf.
	139	*/
	140	cmm_barrier();
	141	pthread_mutex_lock(&ust_safe_guard_fd_mutex);
	142	}
	143	ret = pthread_sigmask(SIG_SETMASK, &orig_mask, NULL);
	144	if (ret) {
	145	ERR("pthread_sigmask: %s", strerror(ret));
	146	}
	147	}
	148
	149	static void lttng_ust_unlock_fd_tracker_orig(void)
	150	{
	151	sigset_t sig_all_blocked, orig_mask;
	152	int ret;
	153
	154	sigfillset(&sig_all_blocked);
	155	ret = pthread_sigmask(SIG_SETMASK, &sig_all_blocked, &orig_mask);
	156	if (ret) {
	157	ERR("pthread_sigmask: %s", strerror(ret));
	158	}
	159	/*
	160	* Ensure the compiler don't move the store before the close()
	161	* call, in case close() would be marked as leaf.
	162	*/
	163	cmm_barrier();
	164	if (!--URCU_TLS(ust_fd_mutex_nest)) {
	165	pthread_mutex_unlock(&ust_safe_guard_fd_mutex);
	166	}
	167	ret = pthread_sigmask(SIG_SETMASK, &orig_mask, NULL);
	168	if (ret) {
	169	ERR("pthread_sigmask: %s", strerror(ret));
	170	}
	171	if (lttng_ust_cancelstate_disable_pop()) {
	172	ERR("lttng_ust_cancelstate_disable_pop");
	173	}
	174	}
	175
	176	static int dup_std_fd(int fd)
	177	{
	178	int ret, i;
	179	int fd_to_close[STDERR_FILENO + 1];
	180	int fd_to_close_count = 0;
	181	int dup_cmd = F_DUPFD; /* Default command */
	182	int fd_valid = -1;
	183
	184	if (!(IS_FD_STD(fd))) {
	185	/* Should not be here */
	186	ret = -1;
	187	goto error;
	188	}
	189
	190	/* Check for FD_CLOEXEC flag */
	191	ret = fcntl(fd, F_GETFD);
	192	if (ret < 0) {
	193	PERROR("fcntl on f_getfd");
	194	ret = -1;
	195	goto error;
	196	}
	197
	198	if (ret & FD_CLOEXEC) {
	199	dup_cmd = F_DUPFD_CLOEXEC;
	200	}
	201
	202	/* Perform dup */
	203	for (i = 0; i < STDERR_FILENO + 1; i++) {
	204	ret = fcntl(fd, dup_cmd, 0);
	205	if (ret < 0) {
	206	PERROR("fcntl dup fd");
	207	goto error;
	208	}
	209
	210	if (!(IS_FD_STD(ret))) {
	211	/* fd is outside of STD range, use it. */
	212	fd_valid = ret;
	213	/* Close fd received as argument. */
	214	fd_to_close[i] = fd;
	215	fd_to_close_count++;
	216	break;
	217	}
	218
	219	fd_to_close[i] = ret;
	220	fd_to_close_count++;
	221	}
	222
	223	/* Close intermediary fds */
	224	for (i = 0; i < fd_to_close_count; i++) {
	225	ret = close(fd_to_close[i]);
	226	if (ret) {
	227	PERROR("close on temporary fd: %d.", fd_to_close[i]);
	228	/*
	229	* Not using an abort here would yield a complicated
	230	* error handling for the caller. If a failure occurs
	231	* here, the system is already in a bad state.
	232	*/
	233	abort();
	234	}
	235	}
	236
	237	ret = fd_valid;
	238	error:
	239	return ret;
	240	}
	241
	242	/*
	243	* Needs to be called with ust_safe_guard_fd_mutex held when opening the fd.
	244	* Has strict checking of fd validity.
	245	*
	246	* If fd <= 2, dup the fd until fd > 2. This enables us to bypass
	247	* problems that can be encountered if UST uses stdin, stdout, stderr
	248	* fds for internal use (daemon etc.). This can happen if the
	249	* application closes either of those file descriptors. Intermediary fds
	250	* are closed as needed.
	251	*
	252	* Return -1 on error.
	253	*
	254	*/
	255	static int lttng_ust_add_fd_to_tracker_orig(int fd)
	256	{
	257	int ret;
	258	/*
	259	* Ensure the tracker is initialized when called from
	260	* constructors.
	261	*/
	262	lttng_ust_fd_tracker_init();
	263	assert(URCU_TLS(ust_fd_mutex_nest));
	264
	265	if (IS_FD_STD(fd)) {
	266	ret = dup_std_fd(fd);
	267	if (ret < 0) {
	268	goto error;
	269	}
	270	fd = ret;
	271	}
	272
	273	/* Trying to add an fd which we can not accommodate. */
	274	assert(IS_FD_VALID(fd));
	275	/* Setting an fd thats already set. */
	276	assert(!IS_FD_SET(fd, lttng_fd_set));
	277
	278	ADD_FD_TO_SET(fd, lttng_fd_set);
	279	return fd;
	280	error:
	281	return ret;
	282	}
	283
	284	/*
	285	* Needs to be called with ust_safe_guard_fd_mutex held when opening the fd.
	286	* Has strict checking for fd validity.
	287	*/
	288	static void lttng_ust_delete_fd_from_tracker_orig(int fd)
	289	{
	290	/*
	291	* Ensure the tracker is initialized when called from
	292	* constructors.
	293	*/
	294	lttng_ust_fd_tracker_init();
	295
	296	assert(URCU_TLS(ust_fd_mutex_nest));
	297	/* Not a valid fd. */
	298	assert(IS_FD_VALID(fd));
	299	/* Deleting an fd which was not set. */
	300	assert(IS_FD_SET(fd, lttng_fd_set));
	301
	302	DEL_FD_FROM_SET(fd, lttng_fd_set);
	303	}
	304
	305	#if !defined(LTTNG_UST_CUSTOM_UPGRADE_CONFLICTING_SYMBOLS)
	306	static int (__lttng_ust_safe_close_fd)(int fd, int (close_cb)(int fd)) = NULL;
	307
	308	static
	309	void *_init_lttng_ust_safe_close_fd(void)
	310	{
	311	if (__lttng_ust_safe_close_fd == NULL) {
	312	__lttng_ust_safe_close_fd = dlsym(RTLD_DEFAULT, "lttng_ust_safe_close_fd");
	313
	314	if (__lttng_ust_safe_close_fd == NULL) {
	315	fprintf(stderr, "%s\n", dlerror());
	316	}
	317	}
	318
	319	return __lttng_ust_safe_close_fd;
	320	}
	321
	322	static int lttng_ust_safe_close_fd_chain(int fd, int (*close_cb)(int fd))
	323	{
	324	if (_init_lttng_ust_safe_close_fd()) {
	325	/* Chain on ust-2.12 preload */
	326	return __lttng_ust_safe_close_fd(fd, close_cb);
	327	} else {
	328	/* Fallback to libc symbol */
	329	return close_cb(fd);
	330	}
	331	}
	332	#endif
	333
	334	/*
	335	* Interface allowing applications to close arbitrary file descriptors.
	336	* We check if it is owned by lttng-ust, and return -1, errno=EBADF
	337	* instead of closing it if it is the case.
	338	*/
	339	static int lttng_ust_safe_close_fd_orig(int fd, int (*close_cb)(int fd))
	340	{
	341	int ret = 0;
	342
	343	lttng_ust_fd_tracker_alloc_tls();
	344
	345	/*
	346	* Ensure the tracker is initialized when called from
	347	* constructors.
	348	*/
	349	lttng_ust_fd_tracker_init();
	350
	351	/*
	352	* If called from lttng-ust, we directly call close without
	353	* validating whether the FD is part of the tracked set.
	354	*/
	355	if (URCU_TLS(ust_fd_mutex_nest)) {
	356	#if !defined(LTTNG_UST_CUSTOM_UPGRADE_CONFLICTING_SYMBOLS)
	357	return lttng_ust_safe_close_fd_chain(fd, close_cb);
	358	#else
	359	return close_cb(fd);
	360	#endif
	361	}
	362
	363	lttng_ust_lock_fd_tracker();
	364	if (IS_FD_VALID(fd) && IS_FD_SET(fd, lttng_fd_set)) {
	365	ret = -1;
	366	errno = EBADF;
	367	} else {
	368	#if !defined(LTTNG_UST_CUSTOM_UPGRADE_CONFLICTING_SYMBOLS)
	369	ret = lttng_ust_safe_close_fd_chain(fd, close_cb);
	370	#else
	371	ret = close_cb(fd);
	372	#endif
	373	}
	374	lttng_ust_unlock_fd_tracker();
	375
	376	return ret;
	377	}
	378
	379	#if !defined(LTTNG_UST_CUSTOM_UPGRADE_CONFLICTING_SYMBOLS)
	380	static int (__lttng_ust_safe_fclose_stream)(FILE stream, int (fclose_cb)(FILE stream)) = NULL;
	381
	382	static
	383	void *_init_lttng_ust_safe_fclose_stream(void)
	384	{
	385	if (__lttng_ust_safe_fclose_stream == NULL) {
	386	__lttng_ust_safe_fclose_stream = dlsym(RTLD_DEFAULT, "lttng_ust_safe_fclose_stream");
	387
	388	if (__lttng_ust_safe_fclose_stream == NULL) {
	389	fprintf(stderr, "%s\n", dlerror());
	390	}
	391	}
	392
	393	return __lttng_ust_safe_fclose_stream;
	394	}
	395
	396	static int lttng_ust_safe_fclose_stream_chain(FILE stream, int (fclose_cb)(FILE *stream))
	397	{
	398	if (_init_lttng_ust_safe_fclose_stream()) {
	399	/* Chain on ust-2.12 preload */
	400	return __lttng_ust_safe_fclose_stream(stream, fclose_cb);
	401	} else {
	402	/* Fallback to libc symbol */
	403	return fclose_cb(stream);
	404	}
	405	}
	406	#endif
	407
	408	/*
	409	* Interface allowing applications to close arbitrary streams.
	410	* We check if it is owned by lttng-ust, and return -1, errno=EBADF
	411	* instead of closing it if it is the case.
	412	*/
	413	static int lttng_ust_safe_fclose_stream_orig(FILE stream, int (fclose_cb)(FILE *stream))
	414	{
	415	int ret = 0, fd;
	416
	417	lttng_ust_fd_tracker_alloc_tls();
	418
	419	/*
	420	* Ensure the tracker is initialized when called from
	421	* constructors.
	422	*/
	423	lttng_ust_fd_tracker_init();
	424
	425	/*
	426	* If called from lttng-ust, we directly call fclose without
	427	* validating whether the FD is part of the tracked set.
	428	*/
	429	if (URCU_TLS(ust_fd_mutex_nest)) {
	430	#if !defined(LTTNG_UST_CUSTOM_UPGRADE_CONFLICTING_SYMBOLS)
	431	return lttng_ust_safe_fclose_stream_chain(stream, fclose_cb);
	432	#else
	433	return fclose_cb(stream);
	434	#endif
	435	}
	436
	437	fd = fileno(stream);
	438
	439	lttng_ust_lock_fd_tracker();
	440	if (IS_FD_VALID(fd) && IS_FD_SET(fd, lttng_fd_set)) {
	441	ret = -1;
	442	errno = EBADF;
	443	} else {
	444	#if !defined(LTTNG_UST_CUSTOM_UPGRADE_CONFLICTING_SYMBOLS)
	445	ret = lttng_ust_safe_fclose_stream_chain(stream, fclose_cb);
	446	#else
	447	ret = fclose_cb(stream);
	448	#endif
	449	}
	450	lttng_ust_unlock_fd_tracker();
	451
	452	return ret;
	453	}
	454
	455	#ifdef __OpenBSD__
	456	static void set_close_success(int *p)
	457	{
	458	*p = 1;
	459	}
	460	static int test_close_success(const int *p)
	461	{
	462	return *p;
	463	}
	464	#else
	465	static void set_close_success(int *p __attribute__((unused)))
	466	{
	467	}
	468	static int test_close_success(const int *p __attribute__((unused)))
	469	{
	470	return 1;
	471	}
	472	#endif
	473
	474	/*
	475	* Implement helper for closefrom() override.
	476	*/
	477	static int lttng_ust_safe_closefrom_fd_orig(int lowfd, int (*close_cb)(int fd))
	478	{
	479	int ret = 0, close_success = 0, i;
	480
	481	lttng_ust_fd_tracker_alloc_tls();
	482
	483	/*
	484	* Ensure the tracker is initialized when called from
	485	* constructors.
	486	*/
	487	lttng_ust_fd_tracker_init();
	488
	489	if (lowfd < 0) {
	490	/*
	491	* NetBSD return EBADF if fd is invalid.
	492	*/
	493	errno = EBADF;
	494	ret = -1;
	495	goto end;
	496	}
	497	/*
	498	* If called from lttng-ust, we directly call close without
	499	* validating whether the FD is part of the tracked set.
	500	*/
	501	if (URCU_TLS(ust_fd_mutex_nest)) {
	502	for (i = lowfd; i < lttng_ust_max_fd; i++) {
	503	if (close_cb(i) < 0) {
	504	switch (errno) {
	505	case EBADF:
	506	continue;
	507	case EINTR:
	508	default:
	509	ret = -1;
	510	goto end;
	511	}
	512	}
	513	set_close_success(&close_success);
	514	}
	515	} else {
	516	lttng_ust_lock_fd_tracker();
	517	for (i = lowfd; i < lttng_ust_max_fd; i++) {
	518	if (IS_FD_VALID(i) && IS_FD_SET(i, lttng_fd_set))
	519	continue;
	520	if (close_cb(i) < 0) {
	521	switch (errno) {
	522	case EBADF:
	523	continue;
	524	case EINTR:
	525	default:
	526	ret = -1;
	527	lttng_ust_unlock_fd_tracker();
	528	goto end;
	529	}
	530	}
	531	set_close_success(&close_success);
	532	}
	533	lttng_ust_unlock_fd_tracker();
	534	}
	535	if (!test_close_success(&close_success)) {
	536	/*
	537	* OpenBSD return EBADF if fd is greater than all open
	538	* file descriptors.
	539	*/
	540	ret = -1;
	541	errno = EBADF;
	542	}
	543	end:
	544	return ret;
	545	}
	546
	547	/* Custom upgrade 2.12 to 2.13 */
	548
	549	#undef lttng_ust_add_fd_to_tracker
	550	#undef lttng_ust_delete_fd_from_tracker
	551	#undef lttng_ust_lock_fd_tracker
	552	#undef lttng_ust_unlock_fd_tracker
	553	#undef lttng_ust_safe_close_fd
	554	#undef lttng_ust_safe_fclose_stream
	555	#undef lttng_ust_safe_closefrom_fd
	556
	557	int lttng_ust_add_fd_to_tracker1(int fd)
	558	__attribute__ ((alias ("lttng_ust_add_fd_to_tracker_orig")));
	559	void lttng_ust_delete_fd_from_tracker1(int fd)
	560	__attribute__ ((alias ("lttng_ust_delete_fd_from_tracker_orig")));
	561	void lttng_ust_lock_fd_tracker1(void)
	562	__attribute__ ((alias ("lttng_ust_lock_fd_tracker_orig")));
	563	void lttng_ust_unlock_fd_tracker1(void)
	564	__attribute__ ((alias ("lttng_ust_unlock_fd_tracker_orig")));
	565	int lttng_ust_safe_close_fd1(int fd, int (*close_cb)(int))
	566	__attribute__ ((alias ("lttng_ust_safe_close_fd_orig")));
	567	int lttng_ust_safe_fclose_stream1(FILE stream, int (fclose_cb)(FILE *stream))
	568	__attribute__ ((alias ("lttng_ust_safe_fclose_stream_orig")));
	569	int lttng_ust_safe_closefrom_fd1(int lowfd, int (*close_cb)(int))
	570	__attribute__ ((alias ("lttng_ust_safe_closefrom_fd_orig")));
	571
	572	#ifdef LTTNG_UST_CUSTOM_UPGRADE_CONFLICTING_SYMBOLS
	573	int lttng_ust_add_fd_to_tracker(int fd)
	574	__attribute__ ((alias ("lttng_ust_add_fd_to_tracker_orig")));
	575	void lttng_ust_delete_fd_from_tracker(int fd)
	576	__attribute__ ((alias ("lttng_ust_delete_fd_from_tracker_orig")));
	577	void lttng_ust_lock_fd_tracker(void)
	578	__attribute__ ((alias ("lttng_ust_lock_fd_tracker_orig")));
	579	void lttng_ust_unlock_fd_tracker(void)
	580	__attribute__ ((alias ("lttng_ust_unlock_fd_tracker_orig")));
	581	int lttng_ust_safe_close_fd(int fd, int (*close_cb)(int))
	582	__attribute__ ((alias ("lttng_ust_safe_close_fd_orig")));
	583	int lttng_ust_safe_fclose_stream(FILE stream, int (fclose_cb)(FILE *stream))
	584	__attribute__ ((alias ("lttng_ust_safe_fclose_stream_orig")));
	585	int lttng_ust_safe_closefrom_fd(int lowfd, int (*close_cb)(int))
	586	__attribute__ ((alias ("lttng_ust_safe_closefrom_fd_orig")));
	587	#endif