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 <common/compat/directory-handle.hpp>
   9 #include <common/compat/errno.hpp>
  10 #include <common/error.hpp>
  11 #include <common/fd-tracker/fd-tracker.hpp>
  12 #include <common/fs-handle.hpp>
  13
  14 #include <dirent.h>
  15 #include <fcntl.h>
  16 #include <inttypes.h>
  17 #include <stdarg.h>
  18 #include <stdbool.h>
  19 #include <stdio.h>
  20 #include <stdlib.h>
  21 #include <string.h>
  22 #include <sys/stat.h>
  23 #include <sys/types.h>
  24 #include <tap/tap.h>
  25 #include <unistd.h>
  26 #include <urcu.h>
  27
  28 /* For error.h */
  29 int lttng_opt_quiet = 1;
  30 int lttng_opt_verbose;
  31 int lttng_opt_mi;
  32
  33 /* Number of TAP tests in this file */
  34 #define NUM_TESTS 61
  35 /* 3 for stdin, stdout, and stderr */
  36 #define STDIO_FD_COUNT             3
  37 #define TRACKER_FD_LIMIT           50
  38 #define TMP_DIR_PATTERN            "/tmp/fd-tracker-XXXXXX"
  39 #define TEST_UNLINK_DIRECTORY_NAME "unlinked_files"
  40
  41 #ifdef __linux__
  42 #define SELF_FD_DIR "/proc/self/fd"
  43 #else
  44 /* Most Unices have /dev/fd */
  45 #define SELF_FD_DIR "/dev/fd"
  46 #endif
  47
  48 /*
  49  * Count of fds, beyond stdin, stderr, stdout that were open
  50  * at the launch of the test. This allows the test to succeed when
  51  * run by automake's test runner or valgrind which both open
  52  * fds behind our back.
  53  */
  54 int unknown_fds_count;
  55
  56 const char file_contents[] = "Bacon ipsum dolor amet jerky drumstick sirloin "
  57                              "strip steak venison boudin filet mignon picanha doner shoulder. "
  58                              "Strip steak brisket alcatra, venison beef chuck cupim pastrami. "
  59                              "Landjaeger tri-tip salami leberkas ball tip, ham hock chuck sausage "
  60                              "flank jerky cupim. Pig bacon chuck pancetta andouille.";
  61
  62 static void get_temporary_directories(char **_test_directory, char **_unlink_directory)
  63 {
  64         int ret;
  65         char tmp_path_pattern[] = TMP_DIR_PATTERN;
  66         char *output_dir;
  67
  68         output_dir = mkdtemp(tmp_path_pattern);
  69         if (!output_dir) {
  70                 diag("Failed to create temporary path of the form %s", TMP_DIR_PATTERN);
  71                 abort();
  72         }
  73
  74         *_test_directory = strdup(output_dir);
  75         LTTNG_ASSERT(*_test_directory);
  76         ret = asprintf(_unlink_directory, "%s/%s", output_dir, TEST_UNLINK_DIRECTORY_NAME);
  77         if (ret < 0) {
  78                 abort();
  79         }
  80 }
  81
  82 static int fd_count()
  83 {
  84         DIR *dir;
  85         struct dirent *entry;
  86         int count = 0;
  87
  88         dir = opendir(SELF_FD_DIR);
  89         if (!dir) {
  90                 perror("# Failed to enumerate " SELF_FD_DIR
  91                        " to count the number of used file descriptors");
  92                 count = -1;
  93                 goto end;
  94         }
  95
  96         while ((entry = readdir(dir)) != nullptr) {
  97                 if (!strcmp(entry->d_name, ".") || !strcmp(entry->d_name, "..")) {
  98                         continue;
  99                 }
 100                 count++;
 101         }
 102         /* Don't account for the file descriptor opened by opendir(). */
 103         count--;
 104         if (closedir(dir)) {
 105                 perror("# Failed to close test program's " SELF_FD_DIR
 106                        " directory file descriptor");
 107         }
 108 end:
 109         return count;
 110 }
 111
 112 static void check_fd_count(int expected_count)
 113 {
 114         int count = 0;
 115
 116         count = fd_count();
 117         ok(count == expected_count,
 118            "Expected %d open file descriptors (%d are open)",
 119            expected_count,
 120            count);
 121 }
 122
 123 static int noop_open(void *data, int *fds)
 124 {
 125         *fds = *((int *) data);
 126         return 0;
 127 }
 128
 129 static int noop_close(void *data __attribute__((unused)), int *fds __attribute__((unused)))
 130 {
 131         return 0;
 132 }
 133
 134 static void track_std_fds(struct fd_tracker *tracker)
 135 {
 136         int i;
 137         struct {
 138                 int fd;
 139                 const char *name;
 140         } files[] = {
 141                 { .fd = fileno(stdin), .name = "stdin" },
 142                 { .fd = fileno(stdout), .name = "stdout" },
 143                 { .fd = fileno(stderr), .name = "stderr" },
 144         };
 145
 146         for (i = 0; i < sizeof(files) / sizeof(*files); i++) {
 147                 int out_fd, ret;
 148
 149                 ret = fd_tracker_open_unsuspendable_fd(
 150                         tracker, &out_fd, &files[i].name, 1, noop_open, &files[i].fd);
 151                 LTTNG_ASSERT(out_fd == files[i].fd);
 152
 153                 ok(ret == 0, "Track unsuspendable fd %d (%s)", files[i].fd, files[i].name);
 154         }
 155 }
 156
 157 static void untrack_std_fds(struct fd_tracker *tracker)
 158 {
 159         int i;
 160         struct {
 161                 int fd;
 162                 const char *name;
 163         } files[] = {
 164                 { .fd = fileno(stdin), .name = "stdin" },
 165                 { .fd = fileno(stdout), .name = "stdout" },
 166                 { .fd = fileno(stderr), .name = "stderr" },
 167         };
 168
 169         for (i = 0; i < sizeof(files) / sizeof(*files); i++) {
 170                 int fd = files[i].fd;
 171                 int ret = fd_tracker_close_unsuspendable_fd(
 172                         tracker, &files[i].fd, 1, noop_close, nullptr);
 173
 174                 ok(ret == 0, "Untrack unsuspendable fd %d (%s)", fd, files[i].name);
 175         }
 176 }
 177
 178 /*
 179  * Basic test opening and closing three unsuspendable fds.
 180  */
 181 static void test_unsuspendable_basic()
 182 {
 183         int ret;
 184         struct fd_tracker *tracker;
 185         char *test_directory = nullptr, *unlinked_files_directory = nullptr;
 186
 187         get_temporary_directories(&test_directory, &unlinked_files_directory);
 188
 189         tracker = fd_tracker_create(unlinked_files_directory, TRACKER_FD_LIMIT);
 190         ok(tracker,
 191            "Created an fd tracker with a limit of %d simulateously opened file descriptors",
 192            TRACKER_FD_LIMIT);
 193         if (!tracker) {
 194                 goto end;
 195         }
 196
 197         track_std_fds(tracker);
 198         untrack_std_fds(tracker);
 199
 200         fd_tracker_destroy(tracker);
 201         ret = rmdir(test_directory);
 202         ok(ret == 0, "Test directory is empty");
 203 end:
 204         free(test_directory);
 205         free(unlinked_files_directory);
 206 }
 207
 208 static int error_open(void *data, int *fds __attribute__((unused)))
 209 {
 210         return *((int *) data);
 211 }
 212
 213 static int error_close(void *data, int *fds __attribute__((unused)))
 214 {
 215         return *((int *) data);
 216 }
 217
 218 /*
 219  * Validate that user callback return values are returned to the
 220  * caller of the fd tracker.
 221  */
 222 static void test_unsuspendable_cb_return()
 223 {
 224         int ret, stdout_fd = fileno(stdout), out_fd = 42;
 225         struct fd_tracker *tracker;
 226         int expected_error = -ENETDOWN;
 227         char *test_directory = nullptr, *unlinked_files_directory = nullptr;
 228
 229         get_temporary_directories(&test_directory, &unlinked_files_directory);
 230
 231         tracker = fd_tracker_create(test_directory, TRACKER_FD_LIMIT);
 232         LTTNG_ASSERT(tracker);
 233
 234         /* The error_open callback should fail and return 'expected_error'. */
 235         ret = fd_tracker_open_unsuspendable_fd(
 236                 tracker, &out_fd, nullptr, 1, error_open, &expected_error);
 237         ok(ret == expected_error,
 238            "fd_tracker_open_unsuspendable_fd() forwards the user callback's error code");
 239         ok(out_fd == 42,
 240            "Output fd parameter is unaffected on error of fd_tracker_open_unsuspendable_fd()");
 241
 242         /*
 243          * Track a valid fd since we don't want the tracker to fail with an
 244          * invalid fd error for this test.
 245          */
 246         ret = fd_tracker_open_unsuspendable_fd(tracker, &out_fd, nullptr, 1, noop_open, &stdout_fd);
 247         ok(out_fd == stdout_fd,
 248            "fd_tracker_open_unsuspendable_fd() sets the output fd parameter to the newly-tracked fd's value");
 249         LTTNG_ASSERT(!ret);
 250
 251         ret = fd_tracker_close_unsuspendable_fd(
 252                 tracker, &stdout_fd, 1, error_close, &expected_error);
 253         ok(ret == expected_error,
 254            "fd_tracker_close_unsuspendable_fd() forwards the user callback's error code");
 255         ret = fd_tracker_close_unsuspendable_fd(
 256                 tracker, &stdout_fd, 1, noop_close, &expected_error);
 257         LTTNG_ASSERT(!ret);
 258
 259         fd_tracker_destroy(tracker);
 260         ret = rmdir(test_directory);
 261         ok(ret == 0, "Test directory is empty");
 262         free(test_directory);
 263         free(unlinked_files_directory);
 264 }
 265
 266 /*
 267  * Validate that the tracker refuses to track two identical unsuspendable
 268  * file descriptors.
 269  */
 270 static void test_unsuspendable_duplicate()
 271 {
 272         int ret, stdout_fd = fileno(stdout), out_fd;
 273         struct fd_tracker *tracker;
 274         char *test_directory = nullptr, *unlinked_files_directory = nullptr;
 275
 276         get_temporary_directories(&test_directory, &unlinked_files_directory);
 277
 278         tracker = fd_tracker_create(unlinked_files_directory, TRACKER_FD_LIMIT);
 279         LTTNG_ASSERT(tracker);
 280
 281         ret = fd_tracker_open_unsuspendable_fd(tracker, &out_fd, nullptr, 1, noop_open, &stdout_fd);
 282         LTTNG_ASSERT(!ret);
 283         ret = fd_tracker_open_unsuspendable_fd(tracker, &out_fd, nullptr, 1, noop_open, &stdout_fd);
 284         ok(ret == -EEXIST, "EEXIST reported on open of an already tracked file descriptor");
 285
 286         ret = fd_tracker_close_unsuspendable_fd(tracker, &stdout_fd, 1, noop_close, nullptr);
 287         LTTNG_ASSERT(!ret);
 288
 289         fd_tracker_destroy(tracker);
 290         ret = rmdir(test_directory);
 291         ok(ret == 0, "Test directory is empty");
 292         free(test_directory);
 293         free(unlinked_files_directory);
 294 }
 295
 296 static int open_pipes(void *data __attribute__((unused)), int *out_fds)
 297 {
 298         unsigned int i;
 299         const unsigned int pipe_count = TRACKER_FD_LIMIT / 2;
 300
 301         for (i = 0; i < pipe_count; i++) {
 302                 int ret = pipe(&out_fds[i * 2]);
 303
 304                 if (ret) {
 305                         return -errno;
 306                 }
 307         }
 308         return 0;
 309 }
 310
 311 static int close_pipes(void *data __attribute__((unused)), int *fds)
 312 {
 313         int i;
 314         int *pipes = fds;
 315
 316         for (i = 0; i < TRACKER_FD_LIMIT; i++) {
 317                 int ret = close(pipes[i]);
 318
 319                 if (ret) {
 320                         return -errno;
 321                 }
 322         }
 323         return 0;
 324 }
 325
 326 /*
 327  * Validate that the tracker enforces the open file descriptor limit
 328  * when unsuspendable file descriptors are being opened.
 329  */
 330 static void test_unsuspendable_limit()
 331 {
 332         struct fd_tracker *tracker;
 333         int ret, stdout_fd = fileno(stdout), out_fd;
 334         int fds[TRACKER_FD_LIMIT];
 335         char *test_directory = nullptr, *unlinked_files_directory = nullptr;
 336
 337         get_temporary_directories(&test_directory, &unlinked_files_directory);
 338
 339         /* This test assumes TRACKER_FD_LIMIT is a multiple of 2. */
 340         LTTNG_ASSERT((TRACKER_FD_LIMIT % 2 == 0) && TRACKER_FD_LIMIT);
 341
 342         tracker = fd_tracker_create(unlinked_files_directory, TRACKER_FD_LIMIT);
 343         LTTNG_ASSERT(tracker);
 344
 345         ret = fd_tracker_open_unsuspendable_fd(
 346                 tracker, fds, nullptr, TRACKER_FD_LIMIT, open_pipes, nullptr);
 347         ok(ret == 0,
 348            "File descriptor tracker allowed the user to meet its limit with unsuspendable file descriptors (%d)",
 349            TRACKER_FD_LIMIT);
 350
 351         ret = fd_tracker_open_unsuspendable_fd(tracker, &out_fd, nullptr, 1, noop_open, &stdout_fd);
 352         ok(ret == -EMFILE,
 353            "EMFILE reported when exceeding the file descriptor limit while opening an unsuspendable fd");
 354
 355         ret = fd_tracker_close_unsuspendable_fd(
 356                 tracker, fds, TRACKER_FD_LIMIT, close_pipes, nullptr);
 357         LTTNG_ASSERT(!ret);
 358
 359         fd_tracker_destroy(tracker);
 360         ret = rmdir(test_directory);
 361         ok(ret == 0, "Test directory is empty");
 362         free(test_directory);
 363         free(unlinked_files_directory);
 364 }
 365
 366 /*
 367  * Validate that the tracker refuses to track two identical unsuspendable
 368  * file descriptors.
 369  */
 370 static void test_unsuspendable_close_untracked()
 371 {
 372         int ret, stdout_fd = fileno(stdout), unknown_fds[2], out_fd;
 373         struct fd_tracker *tracker;
 374         char *test_directory = nullptr, *unlinked_files_directory = nullptr;
 375
 376         get_temporary_directories(&test_directory, &unlinked_files_directory);
 377
 378         tracker = fd_tracker_create(unlinked_files_directory, TRACKER_FD_LIMIT);
 379         if (!tracker) {
 380                 goto end;
 381                 ;
 382         }
 383
 384         ret = pipe(unknown_fds);
 385         LTTNG_ASSERT(!ret);
 386         ret = close(unknown_fds[0]);
 387         LTTNG_ASSERT(ret == 0);
 388         ret = close(unknown_fds[1]);
 389         LTTNG_ASSERT(ret == 0);
 390
 391         ret = fd_tracker_open_unsuspendable_fd(tracker, &out_fd, nullptr, 1, noop_open, &stdout_fd);
 392         LTTNG_ASSERT(!ret);
 393
 394         ret = fd_tracker_close_unsuspendable_fd(tracker, unknown_fds, 1, noop_close, nullptr);
 395         ok(ret == -EINVAL, "EINVAL reported on close of an untracked file descriptor");
 396
 397         ret = fd_tracker_close_unsuspendable_fd(tracker, &stdout_fd, 1, noop_close, nullptr);
 398         LTTNG_ASSERT(!ret);
 399
 400         fd_tracker_destroy(tracker);
 401         ret = rmdir(test_directory);
 402         ok(ret == 0, "Test directory is empty");
 403 end:
 404         free(test_directory);
 405         free(unlinked_files_directory);
 406 }
 407
 408 static int open_files(struct fd_tracker *tracker,
 409                       struct lttng_directory_handle *directory,
 410                       unsigned int count,
 411                       struct fs_handle **handles,
 412                       char **file_paths)
 413 {
 414         int ret = 0;
 415         unsigned int i;
 416
 417         for (i = 0; i < count; i++) {
 418                 int p_ret;
 419                 char *file_path;
 420                 struct fs_handle *handle;
 421                 mode_t mode = S_IWUSR | S_IRUSR;
 422
 423                 p_ret = asprintf(&file_path, "file-%u", i);
 424                 LTTNG_ASSERT(p_ret >= 0);
 425                 file_paths[i] = file_path;
 426
 427                 handle = fd_tracker_open_fs_handle(
 428                         tracker, directory, file_path, O_RDWR | O_CREAT, &mode);
 429                 if (!handle) {
 430                         ret = -1;
 431                         break;
 432                 }
 433                 handles[i] = handle;
 434         }
 435         return ret;
 436 }
 437
 438 static int open_same_file(struct fd_tracker *tracker,
 439                           struct lttng_directory_handle *directory,
 440                           const char *file,
 441                           unsigned int count,
 442                           struct fs_handle **handles)
 443 {
 444         int ret = 0;
 445         unsigned int i;
 446
 447         for (i = 0; i < count; i++) {
 448                 struct fs_handle *handle;
 449                 mode_t mode = S_IWUSR | S_IRUSR;
 450
 451                 handle = fd_tracker_open_fs_handle(
 452                         tracker, directory, file, O_RDWR | O_CREAT, &mode);
 453                 if (!handle) {
 454                         ret = -1;
 455                         break;
 456                 }
 457                 handles[i] = handle;
 458         }
 459         return ret;
 460 }
 461
 462 static int cleanup_files(struct fd_tracker *tracker __attribute__((unused)),
 463                          const char *dir __attribute__((unused)),
 464                          unsigned int count,
 465                          struct fs_handle **handles,
 466                          char **file_paths)
 467 {
 468         int ret = 0;
 469         unsigned int i;
 470
 471         for (i = 0; i < count; i++) {
 472                 char *file_path = file_paths[i];
 473
 474                 if (!file_path) {
 475                         break;
 476                 }
 477                 if (fs_handle_unlink(handles[i])) {
 478                         diag("Failed to unlink fs_handle to file %s", file_path);
 479                         ret = -1;
 480                 }
 481                 if (fs_handle_close(handles[i])) {
 482                         diag("Failed to close fs_handle to file %s", file_path);
 483                         ret = -1;
 484                 }
 485                 free(file_path);
 486         }
 487         return ret;
 488 }
 489
 490 static void test_suspendable_limit()
 491 {
 492         int ret;
 493         const int files_to_create = TRACKER_FD_LIMIT * 10;
 494         struct fd_tracker *tracker;
 495         char *test_directory = nullptr, *unlinked_files_directory = nullptr;
 496         char *output_files[files_to_create];
 497         struct fs_handle *handles[files_to_create];
 498         struct lttng_directory_handle *dir_handle = nullptr;
 499         int dir_handle_fd_count;
 500
 501         memset(output_files, 0, sizeof(output_files));
 502         memset(handles, 0, sizeof(handles));
 503
 504         get_temporary_directories(&test_directory, &unlinked_files_directory);
 505
 506         tracker = fd_tracker_create(unlinked_files_directory, TRACKER_FD_LIMIT);
 507         if (!tracker) {
 508                 goto end;
 509         }
 510
 511         dir_handle = lttng_directory_handle_create(test_directory);
 512         LTTNG_ASSERT(dir_handle);
 513         dir_handle_fd_count = !!lttng_directory_handle_uses_fd(dir_handle);
 514
 515         ret = open_files(tracker, dir_handle, files_to_create, handles, output_files);
 516         ok(!ret,
 517            "Created %d files with a limit of %d simultaneously-opened file descriptor",
 518            files_to_create,
 519            TRACKER_FD_LIMIT);
 520         check_fd_count(TRACKER_FD_LIMIT + STDIO_FD_COUNT + unknown_fds_count + dir_handle_fd_count);
 521
 522         ret = cleanup_files(tracker, test_directory, files_to_create, handles, output_files);
 523         ok(!ret, "Close all opened filesystem handles");
 524         ret = rmdir(test_directory);
 525         ok(ret == 0, "Test directory is empty");
 526         fd_tracker_destroy(tracker);
 527         lttng_directory_handle_put(dir_handle);
 528 end:
 529         free(test_directory);
 530         free(unlinked_files_directory);
 531 }
 532
 533 static void test_mixed_limit()
 534 {
 535         int ret;
 536         const int files_to_create = TRACKER_FD_LIMIT;
 537         struct fd_tracker *tracker;
 538         char *test_directory = nullptr, *unlinked_files_directory = nullptr;
 539         char *output_files[files_to_create];
 540         struct fs_handle *handles[files_to_create];
 541         struct lttng_directory_handle *dir_handle = nullptr;
 542         int dir_handle_fd_count;
 543
 544         memset(output_files, 0, sizeof(output_files));
 545         memset(handles, 0, sizeof(handles));
 546
 547         get_temporary_directories(&test_directory, &unlinked_files_directory);
 548
 549         tracker = fd_tracker_create(unlinked_files_directory, TRACKER_FD_LIMIT);
 550         if (!tracker) {
 551                 goto end;
 552         }
 553
 554         dir_handle = lttng_directory_handle_create(test_directory);
 555         LTTNG_ASSERT(dir_handle);
 556         dir_handle_fd_count = !!lttng_directory_handle_uses_fd(dir_handle);
 557
 558         ret = open_files(tracker, dir_handle, files_to_create, handles, output_files);
 559         ok(!ret,
 560            "Created %d files with a limit of %d simultaneously-opened file descriptor",
 561            files_to_create,
 562            TRACKER_FD_LIMIT);
 563         diag("Check file descriptor count after opening %u files", files_to_create);
 564         check_fd_count(TRACKER_FD_LIMIT + STDIO_FD_COUNT + unknown_fds_count + dir_handle_fd_count);
 565
 566         /*
 567          * Open unsuspendable fds (stdin, stdout, stderr) and verify that the fd
 568          * cap is still respected.
 569          */
 570         diag("Check file descriptor count after adding %d unsuspendable fds", STDIO_FD_COUNT);
 571         track_std_fds(tracker);
 572         check_fd_count(TRACKER_FD_LIMIT + unknown_fds_count + dir_handle_fd_count);
 573         diag("Untrack unsuspendable file descriptors");
 574         untrack_std_fds(tracker);
 575         check_fd_count(TRACKER_FD_LIMIT + unknown_fds_count + dir_handle_fd_count);
 576
 577         ret = cleanup_files(tracker, test_directory, files_to_create, handles, output_files);
 578         ok(!ret, "Close all opened filesystem handles");
 579         ret = rmdir(test_directory);
 580         ok(ret == 0, "Test directory is empty");
 581         fd_tracker_destroy(tracker);
 582         lttng_directory_handle_put(dir_handle);
 583 end:
 584         free(test_directory);
 585         free(unlinked_files_directory);
 586 }
 587
 588 /*
 589  * Open more files than allowed by the fd tracker's cap and write,
 590  * byte-by-byte, and in round-robin, a string. The goal is to force
 591  * the fd tracker to suspend and resume the fs_handles often and
 592  * verify that the fd cap is always respected.
 593  *
 594  * The content of the files is also verified at the end.
 595  */
 596 static void test_suspendable_restore()
 597 {
 598         int ret;
 599         const int files_to_create = TRACKER_FD_LIMIT * 10;
 600         struct fd_tracker *tracker;
 601         char *output_files[files_to_create];
 602         struct fs_handle *handles[files_to_create];
 603         size_t content_index;
 604         int handle_index;
 605         bool write_success = true;
 606         bool fd_cap_respected = true;
 607         bool content_ok = true;
 608         struct lttng_directory_handle *dir_handle = nullptr;
 609         int dir_handle_fd_count;
 610         char *test_directory = nullptr, *unlinked_files_directory = nullptr;
 611
 612         memset(output_files, 0, sizeof(output_files));
 613         memset(handles, 0, sizeof(handles));
 614
 615         get_temporary_directories(&test_directory, &unlinked_files_directory);
 616
 617         tracker = fd_tracker_create(unlinked_files_directory, TRACKER_FD_LIMIT);
 618         if (!tracker) {
 619                 goto end;
 620         }
 621
 622         dir_handle = lttng_directory_handle_create(test_directory);
 623         LTTNG_ASSERT(dir_handle);
 624         dir_handle_fd_count = !!lttng_directory_handle_uses_fd(dir_handle);
 625
 626         ret = open_files(tracker, dir_handle, files_to_create, handles, output_files);
 627         ok(!ret,
 628            "Created %d files with a limit of %d simultaneously-opened file descriptor",
 629            files_to_create,
 630            TRACKER_FD_LIMIT);
 631         diag("Check file descriptor count after opening %u files", files_to_create);
 632         check_fd_count(TRACKER_FD_LIMIT + STDIO_FD_COUNT + unknown_fds_count + dir_handle_fd_count);
 633
 634         for (content_index = 0; content_index < sizeof(file_contents); content_index++) {
 635                 for (handle_index = 0; handle_index < files_to_create; handle_index++) {
 636                         int fd;
 637                         struct fs_handle *handle = handles[handle_index];
 638                         const char *path = output_files[handle_index];
 639
 640                         fd = fs_handle_get_fd(handle);
 641                         if (fd < 0) {
 642                                 write_success = false;
 643                                 diag("Failed to restore fs_handle to %s", path);
 644                                 goto skip_write;
 645                         }
 646
 647                         do {
 648                                 ret = write(fd, file_contents + content_index, 1);
 649                         } while (ret < 0 && errno == EINTR);
 650
 651                         if (ret != 1) {
 652                                 write_success = false;
 653                                 PERROR("write() to %s failed", path);
 654                                 goto skip_write;
 655                         }
 656
 657                         if (fd_count() > (TRACKER_FD_LIMIT + STDIO_FD_COUNT + unknown_fds_count +
 658                                           dir_handle_fd_count)) {
 659                                 fd_cap_respected = false;
 660                         }
 661
 662                         fs_handle_put_fd(handle);
 663                 }
 664         }
 665 skip_write:
 666         ok(write_success, "Wrote reference string to %d files", files_to_create);
 667         ok(fd_cap_respected, "FD tracker enforced the file descriptor cap");
 668
 669         /* Validate the contents of the files. */
 670         for (handle_index = 0; handle_index < files_to_create; handle_index++) {
 671                 struct stat fd_stat;
 672                 const char *path = output_files[handle_index];
 673                 char read_buf[sizeof(file_contents)];
 674                 char *read_pos;
 675                 size_t to_read = sizeof(read_buf);
 676                 int fd;
 677
 678                 fd = lttng_directory_handle_open_file(dir_handle, path, O_RDONLY, 0);
 679                 LTTNG_ASSERT(fd >= 0);
 680                 ret = fstat(fd, &fd_stat);
 681                 LTTNG_ASSERT(!ret);
 682                 if (fd_stat.st_size != sizeof(file_contents)) {
 683                         diag("Content size of file %s doesn't match, got %" PRId64 ", expected %zu",
 684                              path,
 685                              (int64_t) fd_stat.st_size,
 686                              sizeof(file_contents));
 687                         content_ok = false;
 688                         (void) close(fd);
 689                         break;
 690                 }
 691
 692                 read_pos = read_buf;
 693                 do {
 694                         ret = read(fd, read_pos, to_read);
 695                         if (ret > 0) {
 696                                 to_read -= ret;
 697                                 read_pos += ret;
 698                         }
 699                 } while (to_read && (ret < 0 && errno == EINTR));
 700                 if (ret < 0) {
 701                         content_ok = false;
 702                         PERROR("Failed to read file %s", path);
 703                         (void) close(fd);
 704                         break;
 705                 }
 706
 707                 if (strcmp(file_contents, read_buf) != 0) {
 708                         content_ok = false;
 709                         diag("File content doesn't match the expectated string");
 710                         (void) close(fd);
 711                         break;
 712                 }
 713                 (void) close(fd);
 714         }
 715         ok(content_ok, "Files contain the expected content");
 716         ret = cleanup_files(tracker, test_directory, files_to_create, handles, output_files);
 717         ok(!ret, "Close all opened filesystem handles");
 718         ret = rmdir(test_directory);
 719         ok(ret == 0, "Test directory is empty");
 720         fd_tracker_destroy(tracker);
 721         lttng_directory_handle_put(dir_handle);
 722 end:
 723         free(test_directory);
 724         free(unlinked_files_directory);
 725 }
 726
 727 static void test_unlink()
 728 {
 729         int ret;
 730         struct fd_tracker *tracker;
 731         const int handles_to_open = 2;
 732         struct fs_handle *handles[handles_to_open];
 733         struct fs_handle *new_handle = nullptr;
 734         struct stat statbuf;
 735         struct lttng_directory_handle *dir_handle = nullptr;
 736         const char file_name[] = "my_file";
 737         char *test_directory = nullptr, *unlinked_files_directory = nullptr;
 738         char *unlinked_file_zero = nullptr, *unlinked_file_one = nullptr;
 739         int fd;
 740
 741         get_temporary_directories(&test_directory, &unlinked_files_directory);
 742         ret = asprintf(&unlinked_file_zero, "%s/%u", unlinked_files_directory, 0);
 743         LTTNG_ASSERT(ret > 0);
 744         ret = asprintf(&unlinked_file_one, "%s/%u", unlinked_files_directory, 1);
 745         LTTNG_ASSERT(ret > 0);
 746
 747         tracker = fd_tracker_create(unlinked_files_directory, 1);
 748         if (!tracker) {
 749                 goto end;
 750         }
 751
 752         dir_handle = lttng_directory_handle_create(test_directory);
 753         LTTNG_ASSERT(dir_handle);
 754
 755         /* Open two handles to the same file. */
 756         ret = open_same_file(tracker, dir_handle, file_name, handles_to_open, handles);
 757         ok(!ret,
 758            "Successfully opened %i handles to %s/%s",
 759            handles_to_open,
 760            test_directory,
 761            file_name);
 762         if (ret) {
 763                 goto end;
 764         }
 765
 766         /*
 767          * Unlinking the first handle should cause the file to be renamed
 768          * to '0'.
 769          */
 770         ret = fs_handle_unlink(handles[0]);
 771         ok(!ret, "Successfully unlinked the first handle to %s/%s", test_directory, file_name);
 772
 773         /*
 774          * The original file should no longer exist on the file system, and a
 775          * new file named '0' should exist.
 776          */
 777         ok(lttng_directory_handle_stat(dir_handle, file_name, &statbuf) == -1 && errno == ENOENT,
 778            "%s no longer present on file system after unlink",
 779            file_name);
 780         ok(lttng_directory_handle_stat(dir_handle, unlinked_file_zero, &statbuf) == 0,
 781            "%s exists on file system after unlink",
 782            unlinked_file_zero);
 783
 784         /*
 785          * It should be possible to use the file descriptors of both handles.
 786          * Since only one file descriptor can be opened at once, this should
 787          * force the fd_tracker to suspend and restore the handles.
 788          */
 789         fd = fs_handle_get_fd(handles[0]);
 790         ok(fd >= 0, "Got fd from first handle");
 791
 792         fd = fs_handle_get_fd(handles[1]);
 793         ok(fd < 0, "fd tracker does not allow two fds to be used at once");
 794
 795         fs_handle_put_fd(handles[0]);
 796         fd = fs_handle_get_fd(handles[1]);
 797         ok(fd >= 0, "Got fd from second handle");
 798         fs_handle_put_fd(handles[1]);
 799
 800         /* The second unlink should fail with -ENOENT. */
 801         ret = fs_handle_unlink(handles[1]);
 802         ok(ret == -ENOENT,
 803            "ENOENT is reported when attempting to unlink the second handle to %s/%s",
 804            test_directory,
 805            file_name);
 806
 807         /*
 808          * Opening a new handle to 'my_file' should succeed.
 809          */
 810         ret = open_same_file(tracker, dir_handle, file_name, 1, &new_handle);
 811         ok(!ret,
 812            "Successfully opened a new handle to previously unlinked file %s/%s",
 813            test_directory,
 814            file_name);
 815         LTTNG_ASSERT(new_handle);
 816
 817         /*
 818          * Unlinking the new handle should cause the file to be renamed
 819          * to '1' since '0' already exists.
 820          */
 821         ret = fs_handle_unlink(new_handle);
 822         ok(!ret, "Successfully unlinked the new handle handle to %s/%s", test_directory, file_name);
 823         ok(stat(unlinked_file_one, &statbuf) == 0,
 824            "%s exists on file system after unlink",
 825            unlinked_file_one);
 826
 827         ret = fs_handle_close(handles[0]);
 828         ok(!ret, "Successfully closed the first handle");
 829         ret = fs_handle_close(handles[1]);
 830         ok(!ret, "Successfully closed the second handle");
 831         ret = fs_handle_close(new_handle);
 832         ok(!ret, "Successfully closed the third handle");
 833
 834         ok(lttng_directory_handle_stat(dir_handle, file_name, &statbuf) == -1 && errno == ENOENT,
 835            "%s no longer present on file system after handle close",
 836            file_name);
 837         ok(lttng_directory_handle_stat(dir_handle, unlinked_file_zero, &statbuf) == -1 &&
 838                    errno == ENOENT,
 839            "%s no longer present on file system after handle close",
 840            unlinked_file_zero);
 841         ok(lttng_directory_handle_stat(dir_handle, unlinked_file_one, &statbuf) == -1 &&
 842                    errno == ENOENT,
 843            "%s no longer present on file system after handle close",
 844            unlinked_file_one);
 845
 846         ret = rmdir(test_directory);
 847         ok(ret == 0, "Test directory is empty");
 848 end:
 849         fd_tracker_destroy(tracker);
 850         free(test_directory);
 851         free(unlinked_files_directory);
 852         free(unlinked_file_zero);
 853         free(unlinked_file_one);
 854         lttng_directory_handle_put(dir_handle);
 855 }
 856
 857 int main()
 858 {
 859         plan_tests(NUM_TESTS);
 860         diag("File descriptor tracker unit tests");
 861
 862         rcu_register_thread();
 863
 864         unknown_fds_count = fd_count() - STDIO_FD_COUNT;
 865         LTTNG_ASSERT(unknown_fds_count >= 0);
 866
 867         diag("Unsuspendable - basic");
 868         test_unsuspendable_basic();
 869         diag("Unsuspendable - callback return values");
 870         test_unsuspendable_cb_return();
 871         diag("Unsuspendable - duplicate file descriptors");
 872         test_unsuspendable_duplicate();
 873         diag("Unsuspendable - closing an untracked file descriptor");
 874         test_unsuspendable_close_untracked();
 875         diag("Unsuspendable - check that file descriptor limit is enforced");
 876         test_unsuspendable_limit();
 877
 878         diag("Suspendable - check that file descriptor limit is enforced");
 879         test_suspendable_limit();
 880         diag("Suspendable - restoration test");
 881         test_suspendable_restore();
 882
 883         diag("Mixed - check that file descriptor limit is enforced");
 884         test_mixed_limit();
 885
 886         diag("Suspendable - Unlinking test");
 887         test_unlink();
 888
 889         rcu_barrier();
 890         rcu_unregister_thread();
 891         return exit_status();
 892 }