544dc84eafee3b6015ef64183c1a071125d51a2b
[lttng-tools.git] / tests / unit / test_fd_tracker.cpp
1 /*
2 * Copyright (C) 2018 Jérémie Galarneau <jeremie.galarneau@efficios.com>
3 *
4 * SPDX-License-Identifier: GPL-2.0-only
5 *
6 */
7
8 #include <stdlib.h>
9 #include <inttypes.h>
10 #include <stdbool.h>
11 #include <string.h>
12 #include <stdarg.h>
13 #include <tap/tap.h>
14 #include <sys/types.h>
15 #include <dirent.h>
16 #include <stdio.h>
17 #include <unistd.h>
18 #include <fcntl.h>
19 #include <sys/stat.h>
20 #include <sys/types.h>
21
22 #include <urcu.h>
23
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>
29
30 /* For error.h */
31 int lttng_opt_quiet = 1;
32 int lttng_opt_verbose;
33 int lttng_opt_mi;
34
35 /* Number of TAP tests in this file */
36 #define NUM_TESTS 61
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"
42
43 #ifdef __linux__
44 #define SELF_FD_DIR "/proc/self/fd"
45 #else
46 /* Most Unices have /dev/fd */
47 #define SELF_FD_DIR "/dev/fd"
48 #endif
49
50 /*
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.
55 */
56 int unknown_fds_count;
57
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.";
63
64 static
65 void get_temporary_directories(char **_test_directory, char **_unlink_directory)
66 {
67 int ret;
68 char tmp_path_pattern[] = TMP_DIR_PATTERN;
69 char *output_dir;
70
71 output_dir = mkdtemp(tmp_path_pattern);
72 if (!output_dir) {
73 diag("Failed to create temporary path of the form %s",
74 TMP_DIR_PATTERN);
75 abort();
76 }
77
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);
82 if (ret < 0) {
83 abort();
84 }
85 }
86
87 static
88 int fd_count(void)
89 {
90 DIR *dir;
91 struct dirent *entry;
92 int count = 0;
93
94 dir = opendir(SELF_FD_DIR);
95 if (!dir) {
96 perror("# Failed to enumerate " SELF_FD_DIR " to count the number of used file descriptors");
97 count = -1;
98 goto end;
99 }
100
101 while ((entry = readdir(dir)) != NULL) {
102 if (!strcmp(entry->d_name, ".") || !strcmp(entry->d_name, "..")) {
103 continue;
104 }
105 count++;
106 }
107 /* Don't account for the file descriptor opened by opendir(). */
108 count--;
109 if (closedir(dir)) {
110 perror("# Failed to close test program's " SELF_FD_DIR " directory file descriptor");
111 }
112 end:
113 return count;
114 }
115
116 static
117 void check_fd_count(int expected_count)
118 {
119 int count = 0;
120
121 count = fd_count();
122 ok(count == expected_count, "Expected %d open file descriptors (%d are open)",
123 expected_count, count);
124 }
125
126 static
127 int noop_open(void *data, int *fds)
128 {
129 *fds = *((int *) data);
130 return 0;
131 }
132
133 static
134 int noop_close(void *data __attribute__((unused)),
135 int *fds __attribute__((unused)))
136 {
137 return 0;
138 }
139
140 static
141 void track_std_fds(struct fd_tracker *tracker)
142 {
143 int i;
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" },
148 };
149
150 for (i = 0; i < sizeof(files) / sizeof(*files); i++) {
151 int out_fd, ret;
152
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);
156
157 ok(ret == 0, "Track unsuspendable fd %d (%s)", files[i].fd,
158 files[i].name);
159 }
160 }
161
162 static
163 void untrack_std_fds(struct fd_tracker *tracker)
164 {
165 int i;
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" },
170 };
171
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);
176
177 ok(ret == 0, "Untrack unsuspendable fd %d (%s)", fd,
178 files[i].name);
179 }
180 }
181
182 /*
183 * Basic test opening and closing three unsuspendable fds.
184 */
185 static
186 void test_unsuspendable_basic(void)
187 {
188 int ret;
189 struct fd_tracker *tracker;
190 char *test_directory = NULL, *unlinked_files_directory = NULL;
191
192 get_temporary_directories(&test_directory, &unlinked_files_directory);
193
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",
196 TRACKER_FD_LIMIT);
197 if (!tracker) {
198 goto end;
199 }
200
201 track_std_fds(tracker);
202 untrack_std_fds(tracker);
203
204 fd_tracker_destroy(tracker);
205 ret = rmdir(test_directory);
206 ok(ret == 0, "Test directory is empty");
207 end:
208 free(test_directory);
209 free(unlinked_files_directory);
210 }
211
212 static
213 int error_open(void *data, int *fds __attribute__((unused)))
214 {
215 return *((int *) data);
216 }
217
218 static
219 int error_close(void *data, int *fds __attribute__((unused)))
220 {
221 return *((int *) data);
222 }
223
224 /*
225 * Validate that user callback return values are returned to the
226 * caller of the fd tracker.
227 */
228 static
229 void test_unsuspendable_cb_return(void)
230 {
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;
235
236 get_temporary_directories(&test_directory, &unlinked_files_directory);
237
238 tracker = fd_tracker_create(test_directory, TRACKER_FD_LIMIT);
239 LTTNG_ASSERT(tracker);
240
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()");
246
247 /*
248 * Track a valid fd since we don't want the tracker to fail with an
249 * invalid fd error for this test.
250 */
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");
254 LTTNG_ASSERT(!ret);
255
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);
261 LTTNG_ASSERT(!ret);
262
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);
268 }
269
270 /*
271 * Validate that the tracker refuses to track two identical unsuspendable
272 * file descriptors.
273 */
274 static
275 void test_unsuspendable_duplicate(void)
276 {
277 int ret, stdout_fd = fileno(stdout), out_fd;
278 struct fd_tracker *tracker;
279 char *test_directory = NULL, *unlinked_files_directory = NULL;
280
281 get_temporary_directories(&test_directory, &unlinked_files_directory);
282
283 tracker = fd_tracker_create(unlinked_files_directory, TRACKER_FD_LIMIT);
284 LTTNG_ASSERT(tracker);
285
286 ret = fd_tracker_open_unsuspendable_fd(tracker, &out_fd,
287 NULL, 1, noop_open, &stdout_fd);
288 LTTNG_ASSERT(!ret);
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");
292
293 ret = fd_tracker_close_unsuspendable_fd(tracker,
294 &stdout_fd, 1, noop_close, NULL);
295 LTTNG_ASSERT(!ret);
296
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);
302 }
303
304 static
305 int open_pipes(void *data __attribute__((unused)), int *out_fds)
306 {
307 unsigned int i;
308 const unsigned int pipe_count = TRACKER_FD_LIMIT / 2;
309
310 for (i = 0; i < pipe_count; i++) {
311 int ret = pipe(&out_fds[i * 2]);
312
313 if (ret) {
314 return -errno;
315 }
316 }
317 return 0;
318 }
319
320 static
321 int close_pipes(void *data __attribute__((unused)), int *fds)
322 {
323 int i;
324 int *pipes = fds;
325
326 for (i = 0; i < TRACKER_FD_LIMIT; i++) {
327 int ret = close(pipes[i]);
328
329 if (ret) {
330 return -errno;
331 }
332 }
333 return 0;
334 }
335
336 /*
337 * Validate that the tracker enforces the open file descriptor limit
338 * when unsuspendable file descriptors are being opened.
339 */
340 static
341 void test_unsuspendable_limit(void)
342 {
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;
347
348 get_temporary_directories(&test_directory, &unlinked_files_directory);
349
350 /* This test assumes TRACKER_FD_LIMIT is a multiple of 2. */
351 LTTNG_ASSERT((TRACKER_FD_LIMIT % 2 == 0) && TRACKER_FD_LIMIT);
352
353 tracker = fd_tracker_create(unlinked_files_directory, TRACKER_FD_LIMIT);
354 LTTNG_ASSERT(tracker);
355
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)",
359 TRACKER_FD_LIMIT);
360
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");
364
365 ret = fd_tracker_close_unsuspendable_fd(tracker,
366 fds, TRACKER_FD_LIMIT, close_pipes, NULL);
367 LTTNG_ASSERT(!ret);
368
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);
374 }
375
376 /*
377 * Validate that the tracker refuses to track two identical unsuspendable
378 * file descriptors.
379 */
380 static
381 void test_unsuspendable_close_untracked(void)
382 {
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;
386
387 get_temporary_directories(&test_directory, &unlinked_files_directory);
388
389 tracker = fd_tracker_create(unlinked_files_directory, TRACKER_FD_LIMIT);
390 if (!tracker) {
391 goto end;;
392 }
393
394 ret = pipe(unknown_fds);
395 LTTNG_ASSERT(!ret);
396 ret = close(unknown_fds[0]);
397 LTTNG_ASSERT(ret == 0);
398 ret = close(unknown_fds[1]);
399 LTTNG_ASSERT(ret == 0);
400
401 ret = fd_tracker_open_unsuspendable_fd(tracker, &out_fd,
402 NULL, 1, noop_open, &stdout_fd);
403 LTTNG_ASSERT(!ret);
404
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");
408
409 ret = fd_tracker_close_unsuspendable_fd(tracker,
410 &stdout_fd, 1, noop_close, NULL);
411 LTTNG_ASSERT(!ret);
412
413 fd_tracker_destroy(tracker);
414 ret = rmdir(test_directory);
415 ok(ret == 0, "Test directory is empty");
416 end:
417 free(test_directory);
418 free(unlinked_files_directory);
419 }
420
421 static int open_files(struct fd_tracker *tracker,
422 struct lttng_directory_handle *directory,
423 unsigned int count,
424 struct fs_handle **handles,
425 char **file_paths)
426 {
427 int ret = 0;
428 unsigned int i;
429
430 for (i = 0; i < count; i++) {
431 int p_ret;
432 char *file_path;
433 struct fs_handle *handle;
434 mode_t mode = S_IWUSR | S_IRUSR;
435
436 p_ret = asprintf(&file_path, "file-%u", i);
437 LTTNG_ASSERT(p_ret >= 0);
438 file_paths[i] = file_path;
439
440 handle = fd_tracker_open_fs_handle(tracker, directory, file_path,
441 O_RDWR | O_CREAT, &mode);
442 if (!handle) {
443 ret = -1;
444 break;
445 }
446 handles[i] = handle;
447 }
448 return ret;
449 }
450
451 static int open_same_file(struct fd_tracker *tracker,
452 struct lttng_directory_handle *directory,
453 const char *file,
454 unsigned int count,
455 struct fs_handle **handles)
456 {
457 int ret = 0;
458 unsigned int i;
459
460 for (i = 0; i < count; i++) {
461 struct fs_handle *handle;
462 mode_t mode = S_IWUSR | S_IRUSR;
463
464 handle = fd_tracker_open_fs_handle(tracker, directory, file,
465 O_RDWR | O_CREAT, &mode);
466 if (!handle) {
467 ret = -1;
468 break;
469 }
470 handles[i] = handle;
471 }
472 return ret;
473 }
474
475 static
476 int cleanup_files(struct fd_tracker *tracker __attribute__((unused)),
477 const char *dir __attribute__((unused)),
478 unsigned int count, struct fs_handle **handles,
479 char **file_paths)
480 {
481 int ret = 0;
482 unsigned int i;
483
484 for (i = 0; i < count; i++) {
485 char *file_path = file_paths[i];
486
487 if (!file_path) {
488 break;
489 }
490 if (fs_handle_unlink(handles[i])) {
491 diag("Failed to unlink fs_handle to file %s", file_path);
492 ret = -1;
493 }
494 if (fs_handle_close(handles[i])) {
495 diag("Failed to close fs_handle to file %s", file_path);
496 ret = -1;
497 }
498 free(file_path);
499 }
500 return ret;
501 }
502
503 static
504 void test_suspendable_limit(void)
505 {
506 int ret;
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;
514
515 memset(output_files, 0, sizeof(output_files));
516 memset(handles, 0, sizeof(handles));
517
518 get_temporary_directories(&test_directory, &unlinked_files_directory);
519
520 tracker = fd_tracker_create(unlinked_files_directory, TRACKER_FD_LIMIT);
521 if (!tracker) {
522 goto end;
523 }
524
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);
528
529 ret = open_files(tracker, dir_handle, files_to_create, handles,
530 output_files);
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);
535
536 ret = cleanup_files(tracker, test_directory, files_to_create, handles,
537 output_files);
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);
543 end:
544 free(test_directory);
545 free(unlinked_files_directory);
546 }
547
548 static
549 void test_mixed_limit(void)
550 {
551 int ret;
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;
559
560 memset(output_files, 0, sizeof(output_files));
561 memset(handles, 0, sizeof(handles));
562
563 get_temporary_directories(&test_directory, &unlinked_files_directory);
564
565 tracker = fd_tracker_create(unlinked_files_directory, TRACKER_FD_LIMIT);
566 if (!tracker) {
567 goto end;
568 }
569
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);
573
574 ret = open_files(tracker, dir_handle, files_to_create, handles,
575 output_files);
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);
581
582 /*
583 * Open unsuspendable fds (stdin, stdout, stderr) and verify that the fd
584 * cap is still respected.
585 */
586 diag("Check file descriptor count after adding %d unsuspendable fds",
587 STDIO_FD_COUNT);
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);
595
596 ret = cleanup_files(tracker, test_directory, files_to_create, handles,
597 output_files);
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);
603 end:
604 free(test_directory);
605 free(unlinked_files_directory);
606 }
607
608 /*
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.
613 *
614 * The content of the files is also verified at the end.
615 */
616 static
617 void test_suspendable_restore(void)
618 {
619 int ret;
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;
625 int handle_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;
632
633 memset(output_files, 0, sizeof(output_files));
634 memset(handles, 0, sizeof(handles));
635
636 get_temporary_directories(&test_directory, &unlinked_files_directory);
637
638 tracker = fd_tracker_create(unlinked_files_directory, TRACKER_FD_LIMIT);
639 if (!tracker) {
640 goto end;
641 }
642
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);
646
647 ret = open_files(tracker, dir_handle, files_to_create, handles,
648 output_files);
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);
654
655 for (content_index = 0; content_index < sizeof(file_contents); content_index++) {
656 for (handle_index = 0; handle_index < files_to_create; handle_index++) {
657 int fd;
658 struct fs_handle *handle = handles[handle_index];
659 const char *path = output_files[handle_index];
660
661 fd = fs_handle_get_fd(handle);
662 if (fd < 0) {
663 write_success = false;
664 diag("Failed to restore fs_handle to %s",
665 path);
666 goto skip_write;
667 }
668
669 do {
670 ret = write(fd, file_contents + content_index, 1);
671 } while (ret < 0 && errno == EINTR);
672
673 if (ret != 1) {
674 write_success = false;
675 PERROR("write() to %s failed", path);
676 goto skip_write;
677 }
678
679 if (fd_count() > (TRACKER_FD_LIMIT + STDIO_FD_COUNT +
680 unknown_fds_count +
681 dir_handle_fd_count)) {
682 fd_cap_respected = false;
683 }
684
685 fs_handle_put_fd(handle);
686 }
687 }
688 skip_write:
689 ok(write_success, "Wrote reference string to %d files",
690 files_to_create);
691 ok(fd_cap_respected, "FD tracker enforced the file descriptor cap");
692
693 /* Validate the contents of the files. */
694 for (handle_index = 0; handle_index < files_to_create; handle_index++) {
695 struct stat fd_stat;
696 const char *path = output_files[handle_index];
697 char read_buf[sizeof(file_contents)];
698 char *read_pos;
699 size_t to_read = sizeof(read_buf);
700 int fd;
701
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);
706 LTTNG_ASSERT(!ret);
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));
711 content_ok = false;
712 (void) close(fd);
713 break;
714 }
715
716 read_pos = read_buf;
717 do {
718 ret = read(fd, read_pos, to_read);
719 if (ret > 0) {
720 to_read -= ret;
721 read_pos += ret;
722 }
723 } while (to_read && (ret < 0 && errno == EINTR));
724 if (ret < 0) {
725 content_ok = false;
726 PERROR("Failed to read file %s", path);
727 (void) close(fd);
728 break;
729 }
730
731 if (strcmp(file_contents, read_buf)) {
732 content_ok = false;
733 diag("File content doesn't match the expectated string");
734 (void) close(fd);
735 break;
736 }
737 (void) close(fd);
738 }
739 ok(content_ok, "Files contain the expected content");
740 ret = cleanup_files(tracker, test_directory, files_to_create, handles,
741 output_files);
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);
747 end:
748 free(test_directory);
749 free(unlinked_files_directory);
750 }
751
752 static
753 void test_unlink(void)
754 {
755 int ret;
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;
760 struct stat statbuf;
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;
765 int fd;
766
767 get_temporary_directories(&test_directory, &unlinked_files_directory);
768 ret = asprintf(&unlinked_file_zero, "%s/%u", unlinked_files_directory,
769 0);
770 LTTNG_ASSERT(ret > 0);
771 ret = asprintf(&unlinked_file_one, "%s/%u", unlinked_files_directory,
772 1);
773 LTTNG_ASSERT(ret > 0);
774
775 tracker = fd_tracker_create(unlinked_files_directory, 1);
776 if (!tracker) {
777 goto end;
778 }
779
780 dir_handle = lttng_directory_handle_create(test_directory);
781 LTTNG_ASSERT(dir_handle);
782
783 /* Open two handles to the same file. */
784 ret = open_same_file(tracker, dir_handle, file_name, handles_to_open,
785 handles);
786 ok(!ret, "Successfully opened %i handles to %s/%s", handles_to_open,
787 test_directory, file_name);
788 if (ret) {
789 goto end;
790 }
791
792 /*
793 * Unlinking the first handle should cause the file to be renamed
794 * to '0'.
795 */
796 ret = fs_handle_unlink(handles[0]);
797 ok(!ret, "Successfully unlinked the first handle to %s/%s",
798 test_directory, file_name);
799
800 /*
801 * The original file should no longer exist on the file system, and a
802 * new file named '0' should exist.
803 */
804 ok(lttng_directory_handle_stat(dir_handle, file_name, &statbuf) == -1 &&
805 errno == ENOENT,
806 "%s no longer present on file system after unlink",
807 file_name);
808 ok(lttng_directory_handle_stat(
809 dir_handle, unlinked_file_zero, &statbuf) == 0,
810 "%s exists on file system after unlink",
811 unlinked_file_zero);
812
813 /*
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.
817 */
818 fd = fs_handle_get_fd(handles[0]);
819 ok(fd >= 0, "Got fd from first handle");
820
821 fd = fs_handle_get_fd(handles[1]);
822 ok (fd < 0, "fd tracker does not allow two fds to be used at once");
823
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]);
828
829 /* The second unlink should fail with -ENOENT. */
830 ret = fs_handle_unlink(handles[1]);
831 ok(ret == -ENOENT,
832 "ENOENT is reported when attempting to unlink the second handle to %s/%s",
833 test_directory, file_name);
834
835 /*
836 * Opening a new handle to 'my_file' should succeed.
837 */
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);
842
843 /*
844 * Unlinking the new handle should cause the file to be renamed
845 * to '1' since '0' already exists.
846 */
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",
852 unlinked_file_one);
853
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");
860
861 ok(lttng_directory_handle_stat(dir_handle, file_name, &statbuf) == -1 &&
862 errno == ENOENT,
863 "%s no longer present on file system after handle close",
864 file_name);
865 ok(lttng_directory_handle_stat(
866 dir_handle, unlinked_file_zero, &statbuf) == -1 &&
867 errno == ENOENT,
868 "%s no longer present on file system after handle close",
869 unlinked_file_zero);
870 ok(lttng_directory_handle_stat(dir_handle, unlinked_file_one,
871 &statbuf) == -1 &&
872 errno == ENOENT,
873 "%s no longer present on file system after handle close",
874 unlinked_file_one);
875
876 ret = rmdir(test_directory);
877 ok(ret == 0, "Test directory is empty");
878 end:
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);
885 }
886
887 int main(void)
888 {
889 plan_tests(NUM_TESTS);
890 diag("File descriptor tracker unit tests");
891
892 rcu_register_thread();
893
894 unknown_fds_count = fd_count() - STDIO_FD_COUNT;
895 LTTNG_ASSERT(unknown_fds_count >= 0);
896
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();
907
908 diag("Suspendable - check that file descriptor limit is enforced");
909 test_suspendable_limit();
910 diag("Suspendable - restoration test");
911 test_suspendable_restore();
912
913 diag("Mixed - check that file descriptor limit is enforced");
914 test_mixed_limit();
915
916 diag("Suspendable - Unlinking test");
917 test_unlink();
918
919 rcu_barrier();
920 rcu_unregister_thread();
921 return exit_status();
922 }
This page took 0.046813 seconds and 3 git commands to generate.