[lttng-tools.git] / tests / unit / test_utils_compat_poll.cpp

/*
 * test_utils_compat_poll.c
 *
 * Unit tests for the compatibility layer of poll/epoll API.
 *
 * Copyright (C) 2019 Yannick Lamarre <ylamarre@efficios.com>
 *
 * SPDX-License-Identifier: GPL-2.0-only
 *
 */

#include <common/compat/poll.hpp>
#include <common/dynamic-array.hpp>
#include <common/pipe.hpp>
#include <common/readwrite.hpp>

#include <inttypes.h>
#include <stdio.h>
#include <string.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <tap/tap.h>
#include <unistd.h>

/* Verification without trashing test order in the child process */
#define childok(e, test, ...)                      \
	do {                                       \
		if (!(e)) {                        \
			diag(test, ##__VA_ARGS__); \
			_exit(EXIT_FAILURE);       \
		}                                  \
	} while (0)

/* For error.h */
int lttng_opt_quiet = 1;
int lttng_opt_verbose;
int lttng_opt_mi;

/*
 * Non-zero 8-bits arbitrary value below 0x7f to ensure no sign extension
 * occurs. Used to verify that the value is properly propagated through the
 * pipe.
 */
#define MAGIC_VALUE ((char) 0x5A)

#ifdef HAVE_EPOLL
#define NUM_TESTS 48
#else
#define NUM_TESTS 47
#endif

#ifdef HAVE_EPOLL
#if defined(HAVE_EPOLL_CREATE1) && defined(EPOLL_CLOEXEC)
#define CLOE_VALUE EPOLL_CLOEXEC
#else
#define CLOE_VALUE FD_CLOEXEC
#endif

static void test_epoll_compat()
{
	/*
	 * Type conversion present to disable warning of anonymous enum from
	 * compiler.
	 */
	ok((int) LTTNG_CLOEXEC == (int) CLOE_VALUE, "epoll's CLOEXEC value");
}
#endif

static void test_alloc()
{
	struct lttng_poll_event poll_events;

	lttng_poll_init(&poll_events);

	/* Null pointer */
	ok(lttng_poll_create(nullptr, 1, 0) != 0, "Create over NULL pointer fails");
	/* Size 0 */
	ok(lttng_poll_create(&poll_events, 0, 0) != 0, "Create with size 0 fails");
	/* without CLOEXEC */
	ok(lttng_poll_create(&poll_events, 1, 0) == 0, "Create valid poll set succeeds");
	/*
	 * lttng_poll_event structure untested due to incompatibility across
	 * sublayers. lttng_poll_clean cannot be tested. There is no success
	 * criteria. Verify set's max size cases.
	 */
	lttng_poll_clean(&poll_events);
}

/* Tests stuff related to what would be handled with epoll_ctl. */
static void test_add_del()
{
	struct lttng_poll_event poll_events;

	lttng_poll_init(&poll_events);
	ok(lttng_poll_add(nullptr, 1, LPOLLIN) != 0, "Adding to NULL set fails");
	ok(lttng_poll_add(&poll_events, 1, LPOLLIN) != 0,
	   "Adding to uninitialized structure fails");
	ok(lttng_poll_add(&poll_events, -1, LPOLLIN) != 0, "Adding invalid FD fails");

	ok(lttng_poll_create(&poll_events, 1, 0) == 0, "Create a poll set succeeds");
	ok(LTTNG_POLL_GETNB(&poll_events) == 0, "Set created empty");

	ok(lttng_poll_add(nullptr, 1, LPOLLIN) != 0, "Adding to NULL set fails");
	ok(LTTNG_POLL_GETNB(&poll_events) == 0, "Set still empty");
	ok(lttng_poll_add(&poll_events, -1, LPOLLIN) != 0, "Adding invalid FD fails");
	ok(LTTNG_POLL_GETNB(&poll_events) == 0, "Set still empty");

	ok(lttng_poll_add(&poll_events, 1, LPOLLIN) == 0, "Adding valid FD succeeds");
	ok(LTTNG_POLL_GETNB(&poll_events) == 1, "Nb of elements incremented");

	ok(lttng_poll_del(nullptr, 1) != 0, "Removing from NULL set fails");
	ok(LTTNG_POLL_GETNB(&poll_events) == 1, "Number of FD in set unchanged");

	ok(lttng_poll_del(&poll_events, -1) != 0, "Removing from negative FD fails");
	ok(LTTNG_POLL_GETNB(&poll_events) == 1, "Number of FD in set unchanged");

	ok(lttng_poll_del(&poll_events, 2) == 0, "Removing invalid FD still succeeds");
	ok(LTTNG_POLL_GETNB(&poll_events) == 1, "Number of elements unchanged");

	ok(lttng_poll_del(&poll_events, 1) == 0, "Removing valid FD succeeds");
	ok(LTTNG_POLL_GETNB(&poll_events) == 0, "Nb of elements decremented");

	ok(lttng_poll_del(&poll_events, 1) != 0, "Removing from empty set fails");
	ok(LTTNG_POLL_GETNB(&poll_events) == 0, "Nb of elements unchanged");

	lttng_poll_clean(&poll_events);
}

static void test_mod_wait()
{
	struct lttng_poll_event poll_events;
	struct lttng_poll_event cpoll_events;
	int hupfd[2];
	int infd[2];
	pid_t cpid;
	char rbuf = 0, tbuf = MAGIC_VALUE;
	int wstatus;

	lttng_poll_init(&poll_events);
	lttng_poll_init(&cpoll_events);

	ok(pipe(hupfd) != -1, "pipe function succeeds");
	ok(pipe(infd) != -1, "pipe function succeeds");

	cpid = fork();
	if (cpid == 0) {
		childok(lttng_poll_create(&cpoll_events, 1, 0) == 0,
			"Create valid poll set succeeds");
		childok(lttng_poll_mod(nullptr, infd[0], LPOLLIN) == -1,
			"lttng_poll_mod with invalid input returns an error");
		childok(lttng_poll_mod(&cpoll_events, infd[0], LPOLLIN) == -1,
			"lttng_poll_mod with invalid input returns an error");
		childok(lttng_poll_add(&cpoll_events, infd[0], LPOLLIN) == 0,
			"Add valid FD succeeds");
		childok(lttng_poll_mod(&cpoll_events, -1, LPOLLIN) == -1,
			"lttng_poll_mod with invalid input returns an error");
		childok(lttng_poll_mod(&cpoll_events, hupfd[0], LPOLLIN) == 0,
			"lttng_poll_mod on unincluded FD goes on");
		childok(lttng_poll_mod(&cpoll_events, infd[0], LPOLLIN) == 0,
			"Modify event type succeeds");
		childok(close(infd[1]) == 0, "Close valid FD succeeds");
		childok(lttng_poll_wait(&cpoll_events, -1) == 1, "Wait on close times out");
		childok(lttng_read(infd[0], &rbuf, 1) == 1, "Data is present in the pipe");
		childok(rbuf == MAGIC_VALUE, "Received data is consistent with transmitted data");
		childok(lttng_poll_del(&cpoll_events, infd[0]) == 0, "Removing valid FD succeeds");
		childok(close(infd[0]) == 0, "Close valid FD succeeds");
		childok(close(hupfd[0]) == 0, "Close valid FD succeeds");
		childok(close(hupfd[1]) == 0, "Close valid FD succeeds");
		lttng_poll_clean(&cpoll_events);
		_exit(EXIT_SUCCESS);
	} else {
		ok(close(hupfd[1]) == 0, "Close valid FD succeeds");
		ok(close(infd[0]) == 0, "Close valid FD succeeds");

		ok(lttng_poll_wait(nullptr, -1) == -1,
		   "lttng_poll_wait call with invalid input returns error");

		ok(lttng_poll_create(&poll_events, 1, 0) == 0, "Create valid poll set succeeds");
		ok(lttng_poll_wait(&poll_events, -1) == -1,
		   "lttng_poll_wait call with invalid input returns error");
		ok(lttng_poll_add(&poll_events, hupfd[0], LPOLLIN) == 0, "Add valid FD succeeds");
		ok(lttng_write(infd[1], &tbuf, 1) == 1, "Write to pipe succeeds");
		ok(lttng_poll_wait(&poll_events, -1) == 1, "Wakes up on one event");
		ok(lttng_poll_del(&poll_events, hupfd[0]) == 0, "Removing valid FD succeeds");
		ok(close(hupfd[0]) == 0, "Close valid FD succeeds");
		ok(close(infd[1]) == 0, "Close valid FD succeeds");
		lttng_poll_clean(&poll_events);
		ok(waitpid(cpid, &wstatus, 0) == cpid, "Wait for child exit");
		ok(WIFEXITED(wstatus) == 1, "Child process exited");
		ok(WEXITSTATUS(wstatus) == EXIT_SUCCESS, "Child process exited with EXIT_SUCCESS");
	}
}

static void destroy_pipe(void *pipe)
{
	lttng_pipe_destroy((lttng_pipe *) pipe);
}

static int run_active_set_combination(unsigned int fd_count, unsigned int active_fds_mask)
{
	int ret = 0;
	unsigned int i;
	const unsigned int active_fds_count = __builtin_popcount(active_fds_mask);
	struct lttng_poll_event poll_events;
	struct lttng_dynamic_pointer_array pipes;
	struct lttng_pipe *pipe = nullptr;

	lttng_poll_init(&poll_events);
	lttng_dynamic_pointer_array_init(&pipes, destroy_pipe);

	ret = lttng_poll_create(&poll_events, fd_count, 0);
	if (ret) {
		diag("Failed to create poll set for %u file descriptors", fd_count);
		goto end;
	}

	for (i = 0; i < fd_count; i++) {
		pipe = lttng_pipe_open(0);

		if (!pipe) {
			diag("Failed to allocate pipe");
			ret = -1;
			goto end;
		}

		ret = lttng_poll_add(&poll_events, lttng_pipe_get_readfd(pipe), LPOLLIN);
		if (ret) {
			diag("Failed to add file descriptor to poll set");
			ret = -1;
			goto end;
		}

		ret = lttng_dynamic_pointer_array_add_pointer(&pipes, pipe);
		if (ret) {
			diag("Failed to add pipe to pipes array");
			ret = -1;
			goto end;
		}

		/* Ownership transferred to the pointer array. */
		pipe = nullptr;
	}

	/* Write one byte for all active fds that should be active. */
	for (i = 0; i < fd_count; i++) {
		struct lttng_pipe *borrowed_pipe;

		/* Should this fd be made active? */
		if (!(active_fds_mask & (1 << i))) {
			continue;
		}

		borrowed_pipe = (lttng_pipe *) lttng_dynamic_pointer_array_get_pointer(&pipes, i);

		char c = 'a';
		ret = lttng_pipe_write(borrowed_pipe, &c, sizeof(char));
		if (ret != sizeof(char)) {
			diag("Failed to write to pipe");
			ret = -1;
			goto end;
		}
	}

	ret = lttng_poll_wait(&poll_events, 0);
	if (ret != active_fds_count) {
		diag("lttng_poll_wait returned %d, expected %u active file descriptors",
		     ret,
		     active_fds_count);
		ret = -1;
		goto end;
	} else {
		/* Success! */
		ret = 0;
	}

end:
	lttng_dynamic_pointer_array_reset(&pipes);
	lttng_poll_clean(&poll_events);
	lttng_pipe_destroy(pipe);
	return ret;
}

static void test_active_set_combinations(unsigned int fd_count)
{
	unsigned int i, all_active_mask = 0;

	/* Do you really want to test more than 4,294,967,295 combinations? */
	LTTNG_ASSERT(fd_count <= 32);

	for (i = 0; i < fd_count; i++) {
		all_active_mask |= (1 << i);
	}

	for (i = 0; i <= all_active_mask; i++) {
		const int ret = run_active_set_combination(fd_count, i);

		if (ret) {
			goto fail;
		}
	}

	pass("Test all combinations of active file descriptors for %u file descriptors", fd_count);
	return;
fail:
	fail("Test all combinations of active file descriptors for %u file descriptors", fd_count);
}

static void test_func_def()
{
#ifdef LTTNG_POLL_GETFD
#define PASS_GETFD 1
#else
#define PASS_GETFD 0
#endif

#ifdef LTTNG_POLL_GETEV
#define PASS_GETEV 1
#else
#define PASS_GETEV 0
#endif

#ifdef LTTNG_POLL_GETSZ
#define PASS_GETSZ 1
#else
#define PASS_GETSZ 0
#endif

#ifdef LTTNG_POLL_GET_PREV_FD
#define PASS_GET_PREV_FD 1
#else
#define PASS_GET_PREV_FD 0
#endif

	ok(lttng_poll_reset == lttng_poll_reset, "lttng_poll_reset is defined");
	ok(lttng_poll_init == lttng_poll_init, "lttng_poll_init is defined");
	ok(PASS_GETFD, "GETFD is defined");
	ok(PASS_GETEV, "GETEV is defined");
	ok(PASS_GETSZ, "GETSZ is defined");
	ok(PASS_GET_PREV_FD, "GET_PREV_FD is defined");
}

int main()
{
	plan_tests(NUM_TESTS);
#ifdef HAVE_EPOLL
	test_epoll_compat();
#endif
	test_func_def();
	test_alloc();
	test_add_del();
	test_mod_wait();
	test_active_set_combinations(8);
	return exit_status();
}
Commit	Line	Data
b12e3724 YL	1	/*
	2	* test_utils_compat_poll.c
	3	*
	4	* Unit tests for the compatibility layer of poll/epoll API.
	5	*
	6	* Copyright (C) 2019 Yannick Lamarre <ylamarre@efficios.com>
	7	*
9d16b343	8	* SPDX-License-Identifier: GPL-2.0-only
b12e3724	9	*
b12e3724 YL	10	*/
b12e3724 YL	11
28ab034a JG	12	#include <common/compat/poll.hpp>
	13	#include <common/dynamic-array.hpp>
	14	#include <common/pipe.hpp>
	15	#include <common/readwrite.hpp>
	16
b12e3724 YL	17	#include <inttypes.h>
	18	#include <stdio.h>
	19	#include <string.h>
b12e3724 YL	20	#include <sys/types.h>
b12e3724 YL	21	#include <sys/wait.h>
e30c79d2	22	#include <tap/tap.h>
28ab034a	23	#include <unistd.h>
e30c79d2	24
b12e3724	25	/* Verification without trashing test order in the child process */
28ab034a JG	26	#define childok(e, test, ...) \
	27	do { \
	28	if (!(e)) { \
	29	diag(test, ##__VA_ARGS__); \
	30	_exit(EXIT_FAILURE); \
	31	} \
	32	} while (0)
b12e3724 YL	33
	34	/* For error.h */
	35	int lttng_opt_quiet = 1;
	36	int lttng_opt_verbose;
	37	int lttng_opt_mi;
	38
41b42b3b JG	39	/*
	40	* Non-zero 8-bits arbitrary value below 0x7f to ensure no sign extension
	41	* occurs. Used to verify that the value is properly propagated through the
	42	* pipe.
	43	*/
	44	#define MAGIC_VALUE ((char) 0x5A)
	45
b12e3724	46	#ifdef HAVE_EPOLL
efeeaae1	47	#define NUM_TESTS 48
b12e3724	48	#else
efeeaae1	49	#define NUM_TESTS 47
b12e3724 YL	50	#endif
	51
	52	#ifdef HAVE_EPOLL
	53	#if defined(HAVE_EPOLL_CREATE1) && defined(EPOLL_CLOEXEC)
	54	#define CLOE_VALUE EPOLL_CLOEXEC
	55	#else
	56	#define CLOE_VALUE FD_CLOEXEC
	57	#endif
	58
cd9adb8b	59	static void test_epoll_compat()
b12e3724 YL	60	{
	61	/*
	62	* Type conversion present to disable warning of anonymous enum from
	63	* compiler.
	64	*/
	65	ok((int) LTTNG_CLOEXEC == (int) CLOE_VALUE, "epoll's CLOEXEC value");
	66	}
	67	#endif
	68
cd9adb8b	69	static void test_alloc()
b12e3724 YL	70	{
	71	struct lttng_poll_event poll_events;
	72
	73	lttng_poll_init(&poll_events);
	74
	75	/* Null pointer */
cd9adb8b	76	ok(lttng_poll_create(nullptr, 1, 0) != 0, "Create over NULL pointer fails");
b12e3724 YL	77	/* Size 0 */
	78	ok(lttng_poll_create(&poll_events, 0, 0) != 0, "Create with size 0 fails");
	79	/* without CLOEXEC */
	80	ok(lttng_poll_create(&poll_events, 1, 0) == 0, "Create valid poll set succeeds");
	81	/*
	82	* lttng_poll_event structure untested due to incompatibility across
	83	* sublayers. lttng_poll_clean cannot be tested. There is no success
	84	* criteria. Verify set's max size cases.
	85	*/
	86	lttng_poll_clean(&poll_events);
	87	}
	88
	89	/* Tests stuff related to what would be handled with epoll_ctl. */
cd9adb8b	90	static void test_add_del()
b12e3724 YL	91	{
	92	struct lttng_poll_event poll_events;
	93
	94	lttng_poll_init(&poll_events);
cd9adb8b	95	ok(lttng_poll_add(nullptr, 1, LPOLLIN) != 0, "Adding to NULL set fails");
28ab034a JG	96	ok(lttng_poll_add(&poll_events, 1, LPOLLIN) != 0,
28ab034a JG	97	"Adding to uninitialized structure fails");
b12e3724 YL	98	ok(lttng_poll_add(&poll_events, -1, LPOLLIN) != 0, "Adding invalid FD fails");
b12e3724 YL	99
89226f60	100	ok(lttng_poll_create(&poll_events, 1, 0) == 0, "Create a poll set succeeds");
b12e3724 YL	101	ok(LTTNG_POLL_GETNB(&poll_events) == 0, "Set created empty");
b12e3724 YL	102
cd9adb8b	103	ok(lttng_poll_add(nullptr, 1, LPOLLIN) != 0, "Adding to NULL set fails");
b12e3724 YL	104	ok(LTTNG_POLL_GETNB(&poll_events) == 0, "Set still empty");
	105	ok(lttng_poll_add(&poll_events, -1, LPOLLIN) != 0, "Adding invalid FD fails");
	106	ok(LTTNG_POLL_GETNB(&poll_events) == 0, "Set still empty");
	107
	108	ok(lttng_poll_add(&poll_events, 1, LPOLLIN) == 0, "Adding valid FD succeeds");
	109	ok(LTTNG_POLL_GETNB(&poll_events) == 1, "Nb of elements incremented");
	110
cd9adb8b	111	ok(lttng_poll_del(nullptr, 1) != 0, "Removing from NULL set fails");
b12e3724 YL	112	ok(LTTNG_POLL_GETNB(&poll_events) == 1, "Number of FD in set unchanged");
	113
	114	ok(lttng_poll_del(&poll_events, -1) != 0, "Removing from negative FD fails");
	115	ok(LTTNG_POLL_GETNB(&poll_events) == 1, "Number of FD in set unchanged");
	116
	117	ok(lttng_poll_del(&poll_events, 2) == 0, "Removing invalid FD still succeeds");
	118	ok(LTTNG_POLL_GETNB(&poll_events) == 1, "Number of elements unchanged");
	119
	120	ok(lttng_poll_del(&poll_events, 1) == 0, "Removing valid FD succeeds");
	121	ok(LTTNG_POLL_GETNB(&poll_events) == 0, "Nb of elements decremented");
	122
	123	ok(lttng_poll_del(&poll_events, 1) != 0, "Removing from empty set fails");
	124	ok(LTTNG_POLL_GETNB(&poll_events) == 0, "Nb of elements unchanged");
	125
	126	lttng_poll_clean(&poll_events);
	127	}
	128
cd9adb8b	129	static void test_mod_wait()
b12e3724 YL	130	{
	131	struct lttng_poll_event poll_events;
	132	struct lttng_poll_event cpoll_events;
	133	int hupfd[2];
	134	int infd[2];
	135	pid_t cpid;
	136	char rbuf = 0, tbuf = MAGIC_VALUE;
	137	int wstatus;
	138
	139	lttng_poll_init(&poll_events);
	140	lttng_poll_init(&cpoll_events);
	141
	142	ok(pipe(hupfd) != -1, "pipe function succeeds");
	143	ok(pipe(infd) != -1, "pipe function succeeds");
	144
	145	cpid = fork();
	146	if (cpid == 0) {
28ab034a JG	147	childok(lttng_poll_create(&cpoll_events, 1, 0) == 0,
28ab034a JG	148	"Create valid poll set succeeds");
cd9adb8b	149	childok(lttng_poll_mod(nullptr, infd[0], LPOLLIN) == -1,
28ab034a JG	150	"lttng_poll_mod with invalid input returns an error");
	151	childok(lttng_poll_mod(&cpoll_events, infd[0], LPOLLIN) == -1,
	152	"lttng_poll_mod with invalid input returns an error");
	153	childok(lttng_poll_add(&cpoll_events, infd[0], LPOLLIN) == 0,
	154	"Add valid FD succeeds");
	155	childok(lttng_poll_mod(&cpoll_events, -1, LPOLLIN) == -1,
	156	"lttng_poll_mod with invalid input returns an error");
	157	childok(lttng_poll_mod(&cpoll_events, hupfd[0], LPOLLIN) == 0,
	158	"lttng_poll_mod on unincluded FD goes on");
	159	childok(lttng_poll_mod(&cpoll_events, infd[0], LPOLLIN) == 0,
	160	"Modify event type succeeds");
b12e3724 YL	161	childok(close(infd[1]) == 0, "Close valid FD succeeds");
	162	childok(lttng_poll_wait(&cpoll_events, -1) == 1, "Wait on close times out");
	163	childok(lttng_read(infd[0], &rbuf, 1) == 1, "Data is present in the pipe");
	164	childok(rbuf == MAGIC_VALUE, "Received data is consistent with transmitted data");
	165	childok(lttng_poll_del(&cpoll_events, infd[0]) == 0, "Removing valid FD succeeds");
	166	childok(close(infd[0]) == 0, "Close valid FD succeeds");
	167	childok(close(hupfd[0]) == 0, "Close valid FD succeeds");
	168	childok(close(hupfd[1]) == 0, "Close valid FD succeeds");
	169	lttng_poll_clean(&cpoll_events);
	170	_exit(EXIT_SUCCESS);
	171	} else {
	172	ok(close(hupfd[1]) == 0, "Close valid FD succeeds");
	173	ok(close(infd[0]) == 0, "Close valid FD succeeds");
	174
cd9adb8b	175	ok(lttng_poll_wait(nullptr, -1) == -1,
28ab034a	176	"lttng_poll_wait call with invalid input returns error");
b12e3724 YL	177
b12e3724 YL	178	ok(lttng_poll_create(&poll_events, 1, 0) == 0, "Create valid poll set succeeds");
28ab034a JG	179	ok(lttng_poll_wait(&poll_events, -1) == -1,
28ab034a JG	180	"lttng_poll_wait call with invalid input returns error");
1524f98c	181	ok(lttng_poll_add(&poll_events, hupfd[0], LPOLLIN) == 0, "Add valid FD succeeds");
b12e3724 YL	182	ok(lttng_write(infd[1], &tbuf, 1) == 1, "Write to pipe succeeds");
	183	ok(lttng_poll_wait(&poll_events, -1) == 1, "Wakes up on one event");
	184	ok(lttng_poll_del(&poll_events, hupfd[0]) == 0, "Removing valid FD succeeds");
	185	ok(close(hupfd[0]) == 0, "Close valid FD succeeds");
	186	ok(close(infd[1]) == 0, "Close valid FD succeeds");
	187	lttng_poll_clean(&poll_events);
	188	ok(waitpid(cpid, &wstatus, 0) == cpid, "Wait for child exit");
	189	ok(WIFEXITED(wstatus) == 1, "Child process exited");
	190	ok(WEXITSTATUS(wstatus) == EXIT_SUCCESS, "Child process exited with EXIT_SUCCESS");
	191	}
	192	}
	193
efeeaae1 JG	194	static void destroy_pipe(void *pipe)
efeeaae1 JG	195	{
740da7d5	196	lttng_pipe_destroy((lttng_pipe *) pipe);
efeeaae1 JG	197	}
efeeaae1 JG	198
28ab034a	199	static int run_active_set_combination(unsigned int fd_count, unsigned int active_fds_mask)
efeeaae1 JG	200	{
	201	int ret = 0;
	202	unsigned int i;
	203	const unsigned int active_fds_count = __builtin_popcount(active_fds_mask);
	204	struct lttng_poll_event poll_events;
	205	struct lttng_dynamic_pointer_array pipes;
cd9adb8b	206	struct lttng_pipe *pipe = nullptr;
efeeaae1 JG	207
	208	lttng_poll_init(&poll_events);
	209	lttng_dynamic_pointer_array_init(&pipes, destroy_pipe);
	210
	211	ret = lttng_poll_create(&poll_events, fd_count, 0);
	212	if (ret) {
28ab034a	213	diag("Failed to create poll set for %u file descriptors", fd_count);
efeeaae1 JG	214	goto end;
	215	}
	216
	217	for (i = 0; i < fd_count; i++) {
	218	pipe = lttng_pipe_open(0);
	219
	220	if (!pipe) {
	221	diag("Failed to allocate pipe");
	222	ret = -1;
	223	goto end;
	224	}
	225
28ab034a	226	ret = lttng_poll_add(&poll_events, lttng_pipe_get_readfd(pipe), LPOLLIN);
efeeaae1 JG	227	if (ret) {
	228	diag("Failed to add file descriptor to poll set");
	229	ret = -1;
	230	goto end;
	231	}
	232
	233	ret = lttng_dynamic_pointer_array_add_pointer(&pipes, pipe);
	234	if (ret) {
	235	diag("Failed to add pipe to pipes array");
	236	ret = -1;
	237	goto end;
	238	}
	239
	240	/* Ownership transferred to the pointer array. */
cd9adb8b	241	pipe = nullptr;
efeeaae1 JG	242	}
	243
	244	/* Write one byte for all active fds that should be active. */
	245	for (i = 0; i < fd_count; i++) {
c26ada1f	246	struct lttng_pipe *borrowed_pipe;
efeeaae1 JG	247
	248	/* Should this fd be made active? */
	249	if (!(active_fds_mask & (1 << i))) {
	250	continue;
	251	}
	252
28ab034a	253	borrowed_pipe = (lttng_pipe *) lttng_dynamic_pointer_array_get_pointer(&pipes, i);
efeeaae1	254
740da7d5	255	char c = 'a';
28ab034a	256	ret = lttng_pipe_write(borrowed_pipe, &c, sizeof(char));
efeeaae1 JG	257	if (ret != sizeof(char)) {
	258	diag("Failed to write to pipe");
	259	ret = -1;
	260	goto end;
	261	}
	262	}
	263
	264	ret = lttng_poll_wait(&poll_events, 0);
	265	if (ret != active_fds_count) {
	266	diag("lttng_poll_wait returned %d, expected %u active file descriptors",
28ab034a JG	267	ret,
28ab034a JG	268	active_fds_count);
efeeaae1 JG	269	ret = -1;
	270	goto end;
	271	} else {
	272	/* Success! */
	273	ret = 0;
	274	}
	275
	276	end:
	277	lttng_dynamic_pointer_array_reset(&pipes);
	278	lttng_poll_clean(&poll_events);
	279	lttng_pipe_destroy(pipe);
	280	return ret;
	281	}
	282
	283	static void test_active_set_combinations(unsigned int fd_count)
	284	{
	285	unsigned int i, all_active_mask = 0;
	286
	287	/* Do you really want to test more than 4,294,967,295 combinations? */
a0377dfe	288	LTTNG_ASSERT(fd_count <= 32);
efeeaae1 JG	289
	290	for (i = 0; i < fd_count; i++) {
	291	all_active_mask \|= (1 << i);
	292	}
	293
	294	for (i = 0; i <= all_active_mask; i++) {
	295	const int ret = run_active_set_combination(fd_count, i);
	296
	297	if (ret) {
	298	goto fail;
	299	}
	300	}
	301
	302	pass("Test all combinations of active file descriptors for %u file descriptors", fd_count);
	303	return;
	304	fail:
	305	fail("Test all combinations of active file descriptors for %u file descriptors", fd_count);
	306	}
	307
cd9adb8b	308	static void test_func_def()
b12e3724 YL	309	{
	310	#ifdef LTTNG_POLL_GETFD
	311	#define PASS_GETFD 1
	312	#else
	313	#define PASS_GETFD 0
	314	#endif
	315
	316	#ifdef LTTNG_POLL_GETEV
	317	#define PASS_GETEV 1
	318	#else
	319	#define PASS_GETEV 0
	320	#endif
	321
	322	#ifdef LTTNG_POLL_GETSZ
	323	#define PASS_GETSZ 1
	324	#else
	325	#define PASS_GETSZ 0
	326	#endif
	327
	328	#ifdef LTTNG_POLL_GET_PREV_FD
	329	#define PASS_GET_PREV_FD 1
	330	#else
	331	#define PASS_GET_PREV_FD 0
	332	#endif
	333
	334	ok(lttng_poll_reset == lttng_poll_reset, "lttng_poll_reset is defined");
28ab034a	335	ok(lttng_poll_init == lttng_poll_init, "lttng_poll_init is defined");
b12e3724 YL	336	ok(PASS_GETFD, "GETFD is defined");
	337	ok(PASS_GETEV, "GETEV is defined");
	338	ok(PASS_GETSZ, "GETSZ is defined");
	339	ok(PASS_GET_PREV_FD, "GET_PREV_FD is defined");
	340	}
	341
cd9adb8b	342	int main()
b12e3724 YL	343	{
	344	plan_tests(NUM_TESTS);
	345	#ifdef HAVE_EPOLL
	346	test_epoll_compat();
	347	#endif
	348	test_func_def();
	349	test_alloc();
	350	test_add_del();
	351	test_mod_wait();
efeeaae1	352	test_active_set_combinations(8);
b12e3724 YL	353	return exit_status();
b12e3724 YL	354	}