2 * Copyright (C) 2018 Jérémie Galarneau <jeremie.galarneau@efficios.com>
4 * SPDX-License-Identifier: GPL-2.0-only
14 #include <sys/types.h>
20 #include <sys/types.h>
24 #include <common/compat/directory-handle.h>
25 #include <common/compat/errno.h>
26 #include <common/error.h>
27 #include <common/fs-handle.h>
28 #include <common/fd-tracker/fd-tracker.h>
31 int lttng_opt_quiet
= 1;
32 int lttng_opt_verbose
;
35 /* Number of TAP tests in this file */
37 /* 3 for stdin, stdout, and stderr */
38 #define STDIO_FD_COUNT 3
39 #define TRACKER_FD_LIMIT 50
40 #define TMP_DIR_PATTERN "/tmp/fd-tracker-XXXXXX"
41 #define TEST_UNLINK_DIRECTORY_NAME "unlinked_files"
44 #define SELF_FD_DIR "/proc/self/fd"
46 /* Most Unices have /dev/fd */
47 #define SELF_FD_DIR "/dev/fd"
51 * Count of fds, beyond stdin, stderr, stdout that were open
52 * at the launch of the test. This allows the test to succeed when
53 * run by automake's test runner or valgrind which both open
54 * fds behind our back.
56 int unknown_fds_count
;
58 const char file_contents
[] = "Bacon ipsum dolor amet jerky drumstick sirloin "
59 "strip steak venison boudin filet mignon picanha doner shoulder. "
60 "Strip steak brisket alcatra, venison beef chuck cupim pastrami. "
61 "Landjaeger tri-tip salami leberkas ball tip, ham hock chuck sausage "
62 "flank jerky cupim. Pig bacon chuck pancetta andouille.";
65 void get_temporary_directories(char **_test_directory
, char **_unlink_directory
)
68 char tmp_path_pattern
[] = TMP_DIR_PATTERN
;
71 output_dir
= mkdtemp(tmp_path_pattern
);
73 diag("Failed to create temporary path of the form %s",
78 *_test_directory
= strdup(output_dir
);
79 LTTNG_ASSERT(*_test_directory
);
80 ret
= asprintf(_unlink_directory
, "%s/%s", output_dir
,
81 TEST_UNLINK_DIRECTORY_NAME
);
94 dir
= opendir(SELF_FD_DIR
);
96 perror("# Failed to enumerate " SELF_FD_DIR
" to count the number of used file descriptors");
101 while ((entry
= readdir(dir
)) != NULL
) {
102 if (!strcmp(entry
->d_name
, ".") || !strcmp(entry
->d_name
, "..")) {
107 /* Don't account for the file descriptor opened by opendir(). */
110 perror("# Failed to close test program's " SELF_FD_DIR
" directory file descriptor");
117 void check_fd_count(int expected_count
)
122 ok(count
== expected_count
, "Expected %d open file descriptors (%d are open)",
123 expected_count
, count
);
127 int noop_open(void *data
, int *fds
)
129 *fds
= *((int *) data
);
134 int noop_close(void *data
__attribute__((unused
)),
135 int *fds
__attribute__((unused
)))
141 void track_std_fds(struct fd_tracker
*tracker
)
144 struct { int fd
; const char *name
; } files
[] = {
145 { .fd
= fileno(stdin
), .name
= "stdin" },
146 { .fd
= fileno(stdout
), .name
= "stdout" },
147 { .fd
= fileno(stderr
), .name
= "stderr" },
150 for (i
= 0; i
< sizeof(files
) / sizeof(*files
); i
++) {
153 ret
= fd_tracker_open_unsuspendable_fd(tracker
, &out_fd
,
154 &files
[i
].name
, 1, noop_open
, &files
[i
].fd
);
155 LTTNG_ASSERT(out_fd
== files
[i
].fd
);
157 ok(ret
== 0, "Track unsuspendable fd %d (%s)", files
[i
].fd
,
163 void untrack_std_fds(struct fd_tracker
*tracker
)
166 struct { int fd
; const char *name
; } files
[] = {
167 { .fd
= fileno(stdin
), .name
= "stdin" },
168 { .fd
= fileno(stdout
), .name
= "stdout" },
169 { .fd
= fileno(stderr
), .name
= "stderr" },
172 for (i
= 0; i
< sizeof(files
) / sizeof(*files
); i
++) {
173 int fd
= files
[i
].fd
;
174 int ret
= fd_tracker_close_unsuspendable_fd(tracker
,
175 &files
[i
].fd
, 1, noop_close
, NULL
);
177 ok(ret
== 0, "Untrack unsuspendable fd %d (%s)", fd
,
183 * Basic test opening and closing three unsuspendable fds.
186 void test_unsuspendable_basic(void)
189 struct fd_tracker
*tracker
;
190 char *test_directory
= NULL
, *unlinked_files_directory
= NULL
;
192 get_temporary_directories(&test_directory
, &unlinked_files_directory
);
194 tracker
= fd_tracker_create(unlinked_files_directory
, TRACKER_FD_LIMIT
);
195 ok(tracker
, "Created an fd tracker with a limit of %d simulateously opened file descriptors",
201 track_std_fds(tracker
);
202 untrack_std_fds(tracker
);
204 fd_tracker_destroy(tracker
);
205 ret
= rmdir(test_directory
);
206 ok(ret
== 0, "Test directory is empty");
208 free(test_directory
);
209 free(unlinked_files_directory
);
213 int error_open(void *data
, int *fds
__attribute__((unused
)))
215 return *((int *) data
);
219 int error_close(void *data
, int *fds
__attribute__((unused
)))
221 return *((int *) data
);
225 * Validate that user callback return values are returned to the
226 * caller of the fd tracker.
229 void test_unsuspendable_cb_return(void)
231 int ret
, stdout_fd
= fileno(stdout
), out_fd
= 42;
232 struct fd_tracker
*tracker
;
233 int expected_error
= -ENETDOWN
;
234 char *test_directory
= NULL
, *unlinked_files_directory
= NULL
;
236 get_temporary_directories(&test_directory
, &unlinked_files_directory
);
238 tracker
= fd_tracker_create(test_directory
, TRACKER_FD_LIMIT
);
239 LTTNG_ASSERT(tracker
);
241 /* The error_open callback should fail and return 'expected_error'. */
242 ret
= fd_tracker_open_unsuspendable_fd(tracker
, &out_fd
,
243 NULL
, 1, error_open
, &expected_error
);
244 ok(ret
== expected_error
, "fd_tracker_open_unsuspendable_fd() forwards the user callback's error code");
245 ok(out_fd
== 42, "Output fd parameter is unaffected on error of fd_tracker_open_unsuspendable_fd()");
248 * Track a valid fd since we don't want the tracker to fail with an
249 * invalid fd error for this test.
251 ret
= fd_tracker_open_unsuspendable_fd(tracker
, &out_fd
,
252 NULL
, 1, noop_open
, &stdout_fd
);
253 ok(out_fd
== stdout_fd
, "fd_tracker_open_unsuspendable_fd() sets the output fd parameter to the newly-tracked fd's value");
256 ret
= fd_tracker_close_unsuspendable_fd(tracker
,
257 &stdout_fd
, 1, error_close
, &expected_error
);
258 ok(ret
== expected_error
, "fd_tracker_close_unsuspendable_fd() forwards the user callback's error code");
259 ret
= fd_tracker_close_unsuspendable_fd(tracker
,
260 &stdout_fd
, 1, noop_close
, &expected_error
);
263 fd_tracker_destroy(tracker
);
264 ret
= rmdir(test_directory
);
265 ok(ret
== 0, "Test directory is empty");
266 free(test_directory
);
267 free(unlinked_files_directory
);
271 * Validate that the tracker refuses to track two identical unsuspendable
275 void test_unsuspendable_duplicate(void)
277 int ret
, stdout_fd
= fileno(stdout
), out_fd
;
278 struct fd_tracker
*tracker
;
279 char *test_directory
= NULL
, *unlinked_files_directory
= NULL
;
281 get_temporary_directories(&test_directory
, &unlinked_files_directory
);
283 tracker
= fd_tracker_create(unlinked_files_directory
, TRACKER_FD_LIMIT
);
284 LTTNG_ASSERT(tracker
);
286 ret
= fd_tracker_open_unsuspendable_fd(tracker
, &out_fd
,
287 NULL
, 1, noop_open
, &stdout_fd
);
289 ret
= fd_tracker_open_unsuspendable_fd(tracker
, &out_fd
,
290 NULL
, 1, noop_open
, &stdout_fd
);
291 ok(ret
== -EEXIST
, "EEXIST reported on open of an already tracked file descriptor");
293 ret
= fd_tracker_close_unsuspendable_fd(tracker
,
294 &stdout_fd
, 1, noop_close
, NULL
);
297 fd_tracker_destroy(tracker
);
298 ret
= rmdir(test_directory
);
299 ok(ret
== 0, "Test directory is empty");
300 free(test_directory
);
301 free(unlinked_files_directory
);
305 int open_pipes(void *data
__attribute__((unused
)), int *out_fds
)
308 const unsigned int pipe_count
= TRACKER_FD_LIMIT
/ 2;
310 for (i
= 0; i
< pipe_count
; i
++) {
311 int ret
= pipe(&out_fds
[i
* 2]);
321 int close_pipes(void *data
__attribute__((unused
)), int *fds
)
326 for (i
= 0; i
< TRACKER_FD_LIMIT
; i
++) {
327 int ret
= close(pipes
[i
]);
337 * Validate that the tracker enforces the open file descriptor limit
338 * when unsuspendable file descriptors are being opened.
341 void test_unsuspendable_limit(void)
343 struct fd_tracker
*tracker
;
344 int ret
, stdout_fd
= fileno(stdout
), out_fd
;
345 int fds
[TRACKER_FD_LIMIT
];
346 char *test_directory
= NULL
, *unlinked_files_directory
= NULL
;
348 get_temporary_directories(&test_directory
, &unlinked_files_directory
);
350 /* This test assumes TRACKER_FD_LIMIT is a multiple of 2. */
351 LTTNG_ASSERT((TRACKER_FD_LIMIT
% 2 == 0) && TRACKER_FD_LIMIT
);
353 tracker
= fd_tracker_create(unlinked_files_directory
, TRACKER_FD_LIMIT
);
354 LTTNG_ASSERT(tracker
);
356 ret
= fd_tracker_open_unsuspendable_fd(tracker
, fds
,
357 NULL
, TRACKER_FD_LIMIT
, open_pipes
, NULL
);
358 ok(ret
== 0, "File descriptor tracker allowed the user to meet its limit with unsuspendable file descriptors (%d)",
361 ret
= fd_tracker_open_unsuspendable_fd(tracker
, &out_fd
,
362 NULL
, 1, noop_open
, &stdout_fd
);
363 ok(ret
== -EMFILE
, "EMFILE reported when exceeding the file descriptor limit while opening an unsuspendable fd");
365 ret
= fd_tracker_close_unsuspendable_fd(tracker
,
366 fds
, TRACKER_FD_LIMIT
, close_pipes
, NULL
);
369 fd_tracker_destroy(tracker
);
370 ret
= rmdir(test_directory
);
371 ok(ret
== 0, "Test directory is empty");
372 free(test_directory
);
373 free(unlinked_files_directory
);
377 * Validate that the tracker refuses to track two identical unsuspendable
381 void test_unsuspendable_close_untracked(void)
383 int ret
, stdout_fd
= fileno(stdout
), unknown_fds
[2], out_fd
;
384 struct fd_tracker
*tracker
;
385 char *test_directory
= NULL
, *unlinked_files_directory
= NULL
;
387 get_temporary_directories(&test_directory
, &unlinked_files_directory
);
389 tracker
= fd_tracker_create(unlinked_files_directory
, TRACKER_FD_LIMIT
);
394 ret
= pipe(unknown_fds
);
396 ret
= close(unknown_fds
[0]);
397 LTTNG_ASSERT(ret
== 0);
398 ret
= close(unknown_fds
[1]);
399 LTTNG_ASSERT(ret
== 0);
401 ret
= fd_tracker_open_unsuspendable_fd(tracker
, &out_fd
,
402 NULL
, 1, noop_open
, &stdout_fd
);
405 ret
= fd_tracker_close_unsuspendable_fd(tracker
,
406 unknown_fds
, 1, noop_close
, NULL
);
407 ok(ret
== -EINVAL
, "EINVAL reported on close of an untracked file descriptor");
409 ret
= fd_tracker_close_unsuspendable_fd(tracker
,
410 &stdout_fd
, 1, noop_close
, NULL
);
413 fd_tracker_destroy(tracker
);
414 ret
= rmdir(test_directory
);
415 ok(ret
== 0, "Test directory is empty");
417 free(test_directory
);
418 free(unlinked_files_directory
);
421 static int open_files(struct fd_tracker
*tracker
,
422 struct lttng_directory_handle
*directory
,
424 struct fs_handle
**handles
,
430 for (i
= 0; i
< count
; i
++) {
433 struct fs_handle
*handle
;
434 mode_t mode
= S_IWUSR
| S_IRUSR
;
436 p_ret
= asprintf(&file_path
, "file-%u", i
);
437 LTTNG_ASSERT(p_ret
>= 0);
438 file_paths
[i
] = file_path
;
440 handle
= fd_tracker_open_fs_handle(tracker
, directory
, file_path
,
441 O_RDWR
| O_CREAT
, &mode
);
451 static int open_same_file(struct fd_tracker
*tracker
,
452 struct lttng_directory_handle
*directory
,
455 struct fs_handle
**handles
)
460 for (i
= 0; i
< count
; i
++) {
461 struct fs_handle
*handle
;
462 mode_t mode
= S_IWUSR
| S_IRUSR
;
464 handle
= fd_tracker_open_fs_handle(tracker
, directory
, file
,
465 O_RDWR
| O_CREAT
, &mode
);
476 int cleanup_files(struct fd_tracker
*tracker
__attribute__((unused
)),
477 const char *dir
__attribute__((unused
)),
478 unsigned int count
, struct fs_handle
**handles
,
484 for (i
= 0; i
< count
; i
++) {
485 char *file_path
= file_paths
[i
];
490 if (fs_handle_unlink(handles
[i
])) {
491 diag("Failed to unlink fs_handle to file %s", file_path
);
494 if (fs_handle_close(handles
[i
])) {
495 diag("Failed to close fs_handle to file %s", file_path
);
504 void test_suspendable_limit(void)
507 const int files_to_create
= TRACKER_FD_LIMIT
* 10;
508 struct fd_tracker
*tracker
;
509 char *test_directory
= NULL
, *unlinked_files_directory
= NULL
;
510 char *output_files
[files_to_create
];
511 struct fs_handle
*handles
[files_to_create
];
512 struct lttng_directory_handle
*dir_handle
= NULL
;
513 int dir_handle_fd_count
;
515 memset(output_files
, 0, sizeof(output_files
));
516 memset(handles
, 0, sizeof(handles
));
518 get_temporary_directories(&test_directory
, &unlinked_files_directory
);
520 tracker
= fd_tracker_create(unlinked_files_directory
, TRACKER_FD_LIMIT
);
525 dir_handle
= lttng_directory_handle_create(test_directory
);
526 LTTNG_ASSERT(dir_handle
);
527 dir_handle_fd_count
= !!lttng_directory_handle_uses_fd(dir_handle
);
529 ret
= open_files(tracker
, dir_handle
, files_to_create
, handles
,
531 ok(!ret
, "Created %d files with a limit of %d simultaneously-opened file descriptor",
532 files_to_create
, TRACKER_FD_LIMIT
);
533 check_fd_count(TRACKER_FD_LIMIT
+ STDIO_FD_COUNT
+ unknown_fds_count
+
534 dir_handle_fd_count
);
536 ret
= cleanup_files(tracker
, test_directory
, files_to_create
, handles
,
538 ok(!ret
, "Close all opened filesystem handles");
539 ret
= rmdir(test_directory
);
540 ok(ret
== 0, "Test directory is empty");
541 fd_tracker_destroy(tracker
);
542 lttng_directory_handle_put(dir_handle
);
544 free(test_directory
);
545 free(unlinked_files_directory
);
549 void test_mixed_limit(void)
552 const int files_to_create
= TRACKER_FD_LIMIT
;
553 struct fd_tracker
*tracker
;
554 char *test_directory
= NULL
, *unlinked_files_directory
= NULL
;
555 char *output_files
[files_to_create
];
556 struct fs_handle
*handles
[files_to_create
];
557 struct lttng_directory_handle
*dir_handle
= NULL
;
558 int dir_handle_fd_count
;
560 memset(output_files
, 0, sizeof(output_files
));
561 memset(handles
, 0, sizeof(handles
));
563 get_temporary_directories(&test_directory
, &unlinked_files_directory
);
565 tracker
= fd_tracker_create(unlinked_files_directory
, TRACKER_FD_LIMIT
);
570 dir_handle
= lttng_directory_handle_create(test_directory
);
571 LTTNG_ASSERT(dir_handle
);
572 dir_handle_fd_count
= !!lttng_directory_handle_uses_fd(dir_handle
);
574 ret
= open_files(tracker
, dir_handle
, files_to_create
, handles
,
576 ok(!ret
, "Created %d files with a limit of %d simultaneously-opened file descriptor",
577 files_to_create
, TRACKER_FD_LIMIT
);
578 diag("Check file descriptor count after opening %u files", files_to_create
);
579 check_fd_count(TRACKER_FD_LIMIT
+ STDIO_FD_COUNT
+ unknown_fds_count
+
580 dir_handle_fd_count
);
583 * Open unsuspendable fds (stdin, stdout, stderr) and verify that the fd
584 * cap is still respected.
586 diag("Check file descriptor count after adding %d unsuspendable fds",
588 track_std_fds(tracker
);
589 check_fd_count(TRACKER_FD_LIMIT
+ unknown_fds_count
+
590 dir_handle_fd_count
);
591 diag("Untrack unsuspendable file descriptors");
592 untrack_std_fds(tracker
);
593 check_fd_count(TRACKER_FD_LIMIT
+ unknown_fds_count
+
594 dir_handle_fd_count
);
596 ret
= cleanup_files(tracker
, test_directory
, files_to_create
, handles
,
598 ok(!ret
, "Close all opened filesystem handles");
599 ret
= rmdir(test_directory
);
600 ok(ret
== 0, "Test directory is empty");
601 fd_tracker_destroy(tracker
);
602 lttng_directory_handle_put(dir_handle
);
604 free(test_directory
);
605 free(unlinked_files_directory
);
609 * Open more files than allowed by the fd tracker's cap and write,
610 * byte-by-byte, and in round-robin, a string. The goal is to force
611 * the fd tracker to suspend and resume the fs_handles often and
612 * verify that the fd cap is always respected.
614 * The content of the files is also verified at the end.
617 void test_suspendable_restore(void)
620 const int files_to_create
= TRACKER_FD_LIMIT
* 10;
621 struct fd_tracker
*tracker
;
622 char *output_files
[files_to_create
];
623 struct fs_handle
*handles
[files_to_create
];
624 size_t content_index
;
626 bool write_success
= true;
627 bool fd_cap_respected
= true;
628 bool content_ok
= true;
629 struct lttng_directory_handle
*dir_handle
= NULL
;
630 int dir_handle_fd_count
;
631 char *test_directory
= NULL
, *unlinked_files_directory
= NULL
;
633 memset(output_files
, 0, sizeof(output_files
));
634 memset(handles
, 0, sizeof(handles
));
636 get_temporary_directories(&test_directory
, &unlinked_files_directory
);
638 tracker
= fd_tracker_create(unlinked_files_directory
, TRACKER_FD_LIMIT
);
643 dir_handle
= lttng_directory_handle_create(test_directory
);
644 LTTNG_ASSERT(dir_handle
);
645 dir_handle_fd_count
= !!lttng_directory_handle_uses_fd(dir_handle
);
647 ret
= open_files(tracker
, dir_handle
, files_to_create
, handles
,
649 ok(!ret
, "Created %d files with a limit of %d simultaneously-opened file descriptor",
650 files_to_create
, TRACKER_FD_LIMIT
);
651 diag("Check file descriptor count after opening %u files", files_to_create
);
652 check_fd_count(TRACKER_FD_LIMIT
+ STDIO_FD_COUNT
+ unknown_fds_count
+
653 dir_handle_fd_count
);
655 for (content_index
= 0; content_index
< sizeof(file_contents
); content_index
++) {
656 for (handle_index
= 0; handle_index
< files_to_create
; handle_index
++) {
658 struct fs_handle
*handle
= handles
[handle_index
];
659 const char *path
= output_files
[handle_index
];
661 fd
= fs_handle_get_fd(handle
);
663 write_success
= false;
664 diag("Failed to restore fs_handle to %s",
670 ret
= write(fd
, file_contents
+ content_index
, 1);
671 } while (ret
< 0 && errno
== EINTR
);
674 write_success
= false;
675 PERROR("write() to %s failed", path
);
679 if (fd_count() > (TRACKER_FD_LIMIT
+ STDIO_FD_COUNT
+
681 dir_handle_fd_count
)) {
682 fd_cap_respected
= false;
685 fs_handle_put_fd(handle
);
689 ok(write_success
, "Wrote reference string to %d files",
691 ok(fd_cap_respected
, "FD tracker enforced the file descriptor cap");
693 /* Validate the contents of the files. */
694 for (handle_index
= 0; handle_index
< files_to_create
; handle_index
++) {
696 const char *path
= output_files
[handle_index
];
697 char read_buf
[sizeof(file_contents
)];
699 size_t to_read
= sizeof(read_buf
);
702 fd
= lttng_directory_handle_open_file(
703 dir_handle
, path
, O_RDONLY
, 0);
704 LTTNG_ASSERT(fd
>= 0);
705 ret
= fstat(fd
, &fd_stat
);
707 if (fd_stat
.st_size
!= sizeof(file_contents
)) {
708 diag("Content size of file %s doesn't match, got %" PRId64
", expected %zu",
709 path
, (int64_t) fd_stat
.st_size
,
710 sizeof(file_contents
));
718 ret
= read(fd
, read_pos
, to_read
);
723 } while (to_read
&& (ret
< 0 && errno
== EINTR
));
726 PERROR("Failed to read file %s", path
);
731 if (strcmp(file_contents
, read_buf
)) {
733 diag("File content doesn't match the expectated string");
739 ok(content_ok
, "Files contain the expected content");
740 ret
= cleanup_files(tracker
, test_directory
, files_to_create
, handles
,
742 ok(!ret
, "Close all opened filesystem handles");
743 ret
= rmdir(test_directory
);
744 ok(ret
== 0, "Test directory is empty");
745 fd_tracker_destroy(tracker
);
746 lttng_directory_handle_put(dir_handle
);
748 free(test_directory
);
749 free(unlinked_files_directory
);
753 void test_unlink(void)
756 struct fd_tracker
*tracker
;
757 const int handles_to_open
= 2;
758 struct fs_handle
*handles
[handles_to_open
];
759 struct fs_handle
*new_handle
= NULL
;
761 struct lttng_directory_handle
*dir_handle
= NULL
;
762 const char file_name
[] = "my_file";
763 char *test_directory
= NULL
, *unlinked_files_directory
= NULL
;
764 char *unlinked_file_zero
= NULL
, *unlinked_file_one
= NULL
;
767 get_temporary_directories(&test_directory
, &unlinked_files_directory
);
768 ret
= asprintf(&unlinked_file_zero
, "%s/%u", unlinked_files_directory
,
770 LTTNG_ASSERT(ret
> 0);
771 ret
= asprintf(&unlinked_file_one
, "%s/%u", unlinked_files_directory
,
773 LTTNG_ASSERT(ret
> 0);
775 tracker
= fd_tracker_create(unlinked_files_directory
, 1);
780 dir_handle
= lttng_directory_handle_create(test_directory
);
781 LTTNG_ASSERT(dir_handle
);
783 /* Open two handles to the same file. */
784 ret
= open_same_file(tracker
, dir_handle
, file_name
, handles_to_open
,
786 ok(!ret
, "Successfully opened %i handles to %s/%s", handles_to_open
,
787 test_directory
, file_name
);
793 * Unlinking the first handle should cause the file to be renamed
796 ret
= fs_handle_unlink(handles
[0]);
797 ok(!ret
, "Successfully unlinked the first handle to %s/%s",
798 test_directory
, file_name
);
801 * The original file should no longer exist on the file system, and a
802 * new file named '0' should exist.
804 ok(lttng_directory_handle_stat(dir_handle
, file_name
, &statbuf
) == -1 &&
806 "%s no longer present on file system after unlink",
808 ok(lttng_directory_handle_stat(
809 dir_handle
, unlinked_file_zero
, &statbuf
) == 0,
810 "%s exists on file system after unlink",
814 * It should be possible to use the file descriptors of both handles.
815 * Since only one file descriptor can be opened at once, this should
816 * force the fd_tracker to suspend and restore the handles.
818 fd
= fs_handle_get_fd(handles
[0]);
819 ok(fd
>= 0, "Got fd from first handle");
821 fd
= fs_handle_get_fd(handles
[1]);
822 ok (fd
< 0, "fd tracker does not allow two fds to be used at once");
824 fs_handle_put_fd(handles
[0]);
825 fd
= fs_handle_get_fd(handles
[1]);
826 ok(fd
>= 0, "Got fd from second handle");
827 fs_handle_put_fd(handles
[1]);
829 /* The second unlink should fail with -ENOENT. */
830 ret
= fs_handle_unlink(handles
[1]);
832 "ENOENT is reported when attempting to unlink the second handle to %s/%s",
833 test_directory
, file_name
);
836 * Opening a new handle to 'my_file' should succeed.
838 ret
= open_same_file(tracker
, dir_handle
, file_name
, 1, &new_handle
);
839 ok(!ret
, "Successfully opened a new handle to previously unlinked file %s/%s",
840 test_directory
, file_name
);
841 LTTNG_ASSERT(new_handle
);
844 * Unlinking the new handle should cause the file to be renamed
845 * to '1' since '0' already exists.
847 ret
= fs_handle_unlink(new_handle
);
848 ok(!ret
, "Successfully unlinked the new handle handle to %s/%s",
849 test_directory
, file_name
);
850 ok(stat(unlinked_file_one
, &statbuf
) == 0,
851 "%s exists on file system after unlink",
854 ret
= fs_handle_close(handles
[0]);
855 ok(!ret
, "Successfully closed the first handle");
856 ret
= fs_handle_close(handles
[1]);
857 ok(!ret
, "Successfully closed the second handle");
858 ret
= fs_handle_close(new_handle
);
859 ok(!ret
, "Successfully closed the third handle");
861 ok(lttng_directory_handle_stat(dir_handle
, file_name
, &statbuf
) == -1 &&
863 "%s no longer present on file system after handle close",
865 ok(lttng_directory_handle_stat(
866 dir_handle
, unlinked_file_zero
, &statbuf
) == -1 &&
868 "%s no longer present on file system after handle close",
870 ok(lttng_directory_handle_stat(dir_handle
, unlinked_file_one
,
873 "%s no longer present on file system after handle close",
876 ret
= rmdir(test_directory
);
877 ok(ret
== 0, "Test directory is empty");
879 fd_tracker_destroy(tracker
);
880 free(test_directory
);
881 free(unlinked_files_directory
);
882 free(unlinked_file_zero
);
883 free(unlinked_file_one
);
884 lttng_directory_handle_put(dir_handle
);
889 plan_tests(NUM_TESTS
);
890 diag("File descriptor tracker unit tests");
892 rcu_register_thread();
894 unknown_fds_count
= fd_count() - STDIO_FD_COUNT
;
895 LTTNG_ASSERT(unknown_fds_count
>= 0);
897 diag("Unsuspendable - basic");
898 test_unsuspendable_basic();
899 diag("Unsuspendable - callback return values");
900 test_unsuspendable_cb_return();
901 diag("Unsuspendable - duplicate file descriptors");
902 test_unsuspendable_duplicate();
903 diag("Unsuspendable - closing an untracked file descriptor");
904 test_unsuspendable_close_untracked();
905 diag("Unsuspendable - check that file descriptor limit is enforced");
906 test_unsuspendable_limit();
908 diag("Suspendable - check that file descriptor limit is enforced");
909 test_suspendable_limit();
910 diag("Suspendable - restoration test");
911 test_suspendable_restore();
913 diag("Mixed - check that file descriptor limit is enforced");
916 diag("Suspendable - Unlinking test");
920 rcu_unregister_thread();
921 return exit_status();