#include <stdlib.h>
#include <inttypes.h>
#include <stdbool.h>
-#include <assert.h>
#include <string.h>
#include <stdarg.h>
#include <tap/tap.h>
#include <sys/types.h>
#include <dirent.h>
#include <stdio.h>
-#include <errno.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <urcu.h>
#include <common/compat/directory-handle.h>
+#include <common/compat/errno.h>
#include <common/error.h>
#include <common/fd-tracker/fd-tracker.h>
#define TMP_DIR_PATTERN "/tmp/fd-tracker-XXXXXX"
#define TEST_UNLINK_DIRECTORY_NAME "unlinked_files"
+#ifdef __linux__
+#define SELF_FD_DIR "/proc/self/fd"
+#else
+/* Most Unices have /dev/fd */
+#define SELF_FD_DIR "/dev/fd"
+#endif
+
/*
* Count of fds, beyond stdin, stderr, stdout that were open
* at the launch of the test. This allows the test to succeed when
"Landjaeger tri-tip salami leberkas ball tip, ham hock chuck sausage "
"flank jerky cupim. Pig bacon chuck pancetta andouille.";
+static
void get_temporary_directories(char **_test_directory, char **_unlink_directory)
{
int ret;
if (!output_dir) {
diag("Failed to create temporary path of the form %s",
TMP_DIR_PATTERN);
- assert(0);
+ abort();
}
*_test_directory = strdup(output_dir);
- assert(*_test_directory);
+ LTTNG_ASSERT(*_test_directory);
ret = asprintf(_unlink_directory, "%s/%s", output_dir,
TEST_UNLINK_DIRECTORY_NAME);
if (ret < 0) {
- assert(0);
+ abort();
}
}
{
DIR *dir;
struct dirent *entry;
- int count = 0;
+ int count = 0;
- dir = opendir("/proc/self/fd");
+ dir = opendir(SELF_FD_DIR);
if (!dir) {
- perror("# Failed to enumerate /proc/self/fd/ to count the number of used file descriptors");
- count = -1;
+ perror("# Failed to enumerate " SELF_FD_DIR " to count the number of used file descriptors");
+ count = -1;
goto end;
}
if (!strcmp(entry->d_name, ".") || !strcmp(entry->d_name, "..")) {
continue;
}
- count++;
+ count++;
}
/* Don't account for the file descriptor opened by opendir(). */
- count--;
+ count--;
if (closedir(dir)) {
- perror("# Failed to close test program's self/fd directory file descriptor");
+ perror("# Failed to close test program's " SELF_FD_DIR " directory file descriptor");
}
end:
return count;
static
void check_fd_count(int expected_count)
{
- int count = 0;
+ int count = 0;
- count = fd_count();
+ count = fd_count();
ok(count == expected_count, "Expected %d open file descriptors (%d are open)",
expected_count, count);
}
static
int noop_open(void *data, int *fds)
{
- *fds = *((int *) data);
+ *fds = *((int *) data);
return 0;
}
void track_std_fds(struct fd_tracker *tracker)
{
int i;
- struct { int fd; const char *name; } files[] = {
+ struct { int fd; const char *name; } files[] = {
{ .fd = fileno(stdin), .name = "stdin" },
{ .fd = fileno(stdout), .name = "stdout" },
{ .fd = fileno(stderr), .name = "stderr" },
ret = fd_tracker_open_unsuspendable_fd(tracker, &out_fd,
&files[i].name, 1, noop_open, &files[i].fd);
- assert(out_fd == files[i].fd);
+ LTTNG_ASSERT(out_fd == files[i].fd);
ok(ret == 0, "Track unsuspendable fd %d (%s)", files[i].fd,
files[i].name);
void untrack_std_fds(struct fd_tracker *tracker)
{
int i;
- struct { int fd; const char *name; } files[] = {
+ struct { int fd; const char *name; } files[] = {
{ .fd = fileno(stdin), .name = "stdin" },
{ .fd = fileno(stdout), .name = "stdout" },
{ .fd = fileno(stderr), .name = "stderr" },
get_temporary_directories(&test_directory, &unlinked_files_directory);
- tracker = fd_tracker_create(unlinked_files_directory, TRACKER_FD_LIMIT);
+ tracker = fd_tracker_create(unlinked_files_directory, TRACKER_FD_LIMIT);
ok(tracker, "Created an fd tracker with a limit of %d simulateously opened file descriptors",
TRACKER_FD_LIMIT);
if (!tracker) {
get_temporary_directories(&test_directory, &unlinked_files_directory);
- tracker = fd_tracker_create(test_directory, TRACKER_FD_LIMIT);
- assert(tracker);
+ tracker = fd_tracker_create(test_directory, TRACKER_FD_LIMIT);
+ LTTNG_ASSERT(tracker);
/* The error_open callback should fail and return 'expected_error'. */
ret = fd_tracker_open_unsuspendable_fd(tracker, &out_fd,
ret = fd_tracker_open_unsuspendable_fd(tracker, &out_fd,
NULL, 1, noop_open, &stdout_fd);
ok(out_fd == stdout_fd, "fd_tracker_open_unsuspendable_fd() sets the output fd parameter to the newly-tracked fd's value");
- assert(!ret);
+ LTTNG_ASSERT(!ret);
ret = fd_tracker_close_unsuspendable_fd(tracker,
&stdout_fd, 1, error_close, &expected_error);
ok(ret == expected_error, "fd_tracker_close_unsuspendable_fd() forwards the user callback's error code");
ret = fd_tracker_close_unsuspendable_fd(tracker,
&stdout_fd, 1, noop_close, &expected_error);
- assert(!ret);
+ LTTNG_ASSERT(!ret);
fd_tracker_destroy(tracker);
ret = rmdir(test_directory);
get_temporary_directories(&test_directory, &unlinked_files_directory);
- tracker = fd_tracker_create(unlinked_files_directory, TRACKER_FD_LIMIT);
- assert(tracker);
+ tracker = fd_tracker_create(unlinked_files_directory, TRACKER_FD_LIMIT);
+ LTTNG_ASSERT(tracker);
ret = fd_tracker_open_unsuspendable_fd(tracker, &out_fd,
NULL, 1, noop_open, &stdout_fd);
- assert(!ret);
+ LTTNG_ASSERT(!ret);
ret = fd_tracker_open_unsuspendable_fd(tracker, &out_fd,
NULL, 1, noop_open, &stdout_fd);
ok(ret == -EEXIST, "EEXIST reported on open of an already tracked file descriptor");
ret = fd_tracker_close_unsuspendable_fd(tracker,
&stdout_fd, 1, noop_close, NULL);
- assert(!ret);
+ LTTNG_ASSERT(!ret);
fd_tracker_destroy(tracker);
ret = rmdir(test_directory);
/*
* Validate that the tracker enforces the open file descriptor limit
- * when unsuspendable file descritptors are being opened.
+ * when unsuspendable file descriptors are being opened.
*/
static
void test_unsuspendable_limit(void)
get_temporary_directories(&test_directory, &unlinked_files_directory);
/* This test assumes TRACKER_FD_LIMIT is a multiple of 2. */
- assert((TRACKER_FD_LIMIT % 2 == 0) && TRACKER_FD_LIMIT);
+ LTTNG_ASSERT((TRACKER_FD_LIMIT % 2 == 0) && TRACKER_FD_LIMIT);
- tracker = fd_tracker_create(unlinked_files_directory, TRACKER_FD_LIMIT);
- assert(tracker);
+ tracker = fd_tracker_create(unlinked_files_directory, TRACKER_FD_LIMIT);
+ LTTNG_ASSERT(tracker);
ret = fd_tracker_open_unsuspendable_fd(tracker, fds,
NULL, TRACKER_FD_LIMIT, open_pipes, NULL);
- ok(ret == 0, "File descriptor tracker allowed the user to meet its limit with unsuspendable file descritptors (%d)",
+ ok(ret == 0, "File descriptor tracker allowed the user to meet its limit with unsuspendable file descriptors (%d)",
TRACKER_FD_LIMIT);
ret = fd_tracker_open_unsuspendable_fd(tracker, &out_fd,
ret = fd_tracker_close_unsuspendable_fd(tracker,
fds, TRACKER_FD_LIMIT, close_pipes, NULL);
- assert(!ret);
+ LTTNG_ASSERT(!ret);
fd_tracker_destroy(tracker);
ret = rmdir(test_directory);
get_temporary_directories(&test_directory, &unlinked_files_directory);
- tracker = fd_tracker_create(unlinked_files_directory, TRACKER_FD_LIMIT);
+ tracker = fd_tracker_create(unlinked_files_directory, TRACKER_FD_LIMIT);
if (!tracker) {
goto end;;
}
ret = pipe(unknown_fds);
- assert(!ret);
- assert(close(unknown_fds[0]) == 0);
- assert(close(unknown_fds[1]) == 0);
+ LTTNG_ASSERT(!ret);
+ ret = close(unknown_fds[0]);
+ LTTNG_ASSERT(ret == 0);
+ ret = close(unknown_fds[1]);
+ LTTNG_ASSERT(ret == 0);
ret = fd_tracker_open_unsuspendable_fd(tracker, &out_fd,
NULL, 1, noop_open, &stdout_fd);
- assert(!ret);
+ LTTNG_ASSERT(!ret);
ret = fd_tracker_close_unsuspendable_fd(tracker,
unknown_fds, 1, noop_close, NULL);
ret = fd_tracker_close_unsuspendable_fd(tracker,
&stdout_fd, 1, noop_close, NULL);
- assert(!ret);
+ LTTNG_ASSERT(!ret);
fd_tracker_destroy(tracker);
ret = rmdir(test_directory);
for (i = 0; i < count; i++) {
int p_ret;
- char *file_path;
+ char *file_path;
struct fs_handle *handle;
mode_t mode = S_IWUSR | S_IRUSR;
p_ret = asprintf(&file_path, "file-%u", i);
- assert(p_ret >= 0);
- file_paths[i] = file_path;
+ LTTNG_ASSERT(p_ret >= 0);
+ file_paths[i] = file_path;
handle = fd_tracker_open_fs_handle(tracker, directory, file_path,
O_RDWR | O_CREAT, &mode);
diag("Failed to unlink fs_handle to file %s", file_path);
ret = -1;
}
- if (fs_handle_close(handles[i])) {
+ if (fs_handle_close(handles[i])) {
diag("Failed to close fs_handle to file %s", file_path);
ret = -1;
}
get_temporary_directories(&test_directory, &unlinked_files_directory);
- tracker = fd_tracker_create(unlinked_files_directory, TRACKER_FD_LIMIT);
+ tracker = fd_tracker_create(unlinked_files_directory, TRACKER_FD_LIMIT);
if (!tracker) {
goto end;
}
dir_handle = lttng_directory_handle_create(test_directory);
- assert(dir_handle);
+ LTTNG_ASSERT(dir_handle);
dir_handle_fd_count = !!lttng_directory_handle_uses_fd(dir_handle);
ret = open_files(tracker, dir_handle, files_to_create, handles,
}
dir_handle = lttng_directory_handle_create(test_directory);
- assert(dir_handle);
+ LTTNG_ASSERT(dir_handle);
dir_handle_fd_count = !!lttng_directory_handle_uses_fd(dir_handle);
ret = open_files(tracker, dir_handle, files_to_create, handles,
get_temporary_directories(&test_directory, &unlinked_files_directory);
- tracker = fd_tracker_create(unlinked_files_directory, TRACKER_FD_LIMIT);
+ tracker = fd_tracker_create(unlinked_files_directory, TRACKER_FD_LIMIT);
if (!tracker) {
goto end;
}
dir_handle = lttng_directory_handle_create(test_directory);
- assert(dir_handle);
+ LTTNG_ASSERT(dir_handle);
dir_handle_fd_count = !!lttng_directory_handle_uses_fd(dir_handle);
ret = open_files(tracker, dir_handle, files_to_create, handles,
fd = fs_handle_get_fd(handle);
if (fd < 0) {
write_success = false;
- diag("Failed to restore fs_handle to %s",
- path);
+ diag("Failed to restore fs_handle to %s",
+ path);
goto skip_write;
}
if (ret != 1) {
write_success = false;
- PERROR("write() to %s failed", path);
+ PERROR("write() to %s failed", path);
goto skip_write;
}
fd = lttng_directory_handle_open_file(
dir_handle, path, O_RDONLY, 0);
- assert(fd >= 0);
+ LTTNG_ASSERT(fd >= 0);
ret = fstat(fd, &fd_stat);
- assert(!ret);
+ LTTNG_ASSERT(!ret);
if (fd_stat.st_size != sizeof(file_contents)) {
diag("Content size of file %s doesn't match, got %" PRId64 ", expected %zu",
path, (int64_t) fd_stat.st_size,
get_temporary_directories(&test_directory, &unlinked_files_directory);
ret = asprintf(&unlinked_file_zero, "%s/%u", unlinked_files_directory,
0);
- assert(ret > 0);
+ LTTNG_ASSERT(ret > 0);
ret = asprintf(&unlinked_file_one, "%s/%u", unlinked_files_directory,
1);
- assert(ret > 0);
+ LTTNG_ASSERT(ret > 0);
tracker = fd_tracker_create(unlinked_files_directory, 1);
if (!tracker) {
}
dir_handle = lttng_directory_handle_create(test_directory);
- assert(dir_handle);
+ LTTNG_ASSERT(dir_handle);
/* Open two handles to the same file. */
ret = open_same_file(tracker, dir_handle, file_name, handles_to_open,
ret = open_same_file(tracker, dir_handle, file_name, 1, &new_handle);
ok(!ret, "Successfully opened a new handle to previously unlinked file %s/%s",
test_directory, file_name);
- assert(new_handle);
+ LTTNG_ASSERT(new_handle);
/*
* Unlinking the new handle should cause the file to be renamed
rcu_register_thread();
unknown_fds_count = fd_count() - STDIO_FD_COUNT;
- assert(unknown_fds_count >= 0);
+ LTTNG_ASSERT(unknown_fds_count >= 0);
diag("Unsuspendable - basic");
test_unsuspendable_basic();
test_unsuspendable_duplicate();
diag("Unsuspendable - closing an untracked file descriptor");
test_unsuspendable_close_untracked();
- diag("Unsuspendable - check that file descritptor limit is enforced");
+ diag("Unsuspendable - check that file descriptor limit is enforced");
test_unsuspendable_limit();
- diag("Suspendable - check that file descritptor limit is enforced");
+ diag("Suspendable - check that file descriptor limit is enforced");
test_suspendable_limit();
diag("Suspendable - restoration test");
test_suspendable_restore();
- diag("Mixed - check that file descritptor limit is enforced");
+ diag("Mixed - check that file descriptor limit is enforced");
test_mixed_limit();
diag("Suspendable - Unlinking test");
projects / lttng-tools.git / blobdiff