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(void)
  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)) != NULL) {
  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, NULL);
 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(void)
 182 {
 183         int ret;
 184         struct fd_tracker *tracker;
 185         char *test_directory = NULL, *unlinked_files_directory = NULL;
 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(void)
 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 = NULL, *unlinked_files_directory = NULL;
 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, NULL, 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, NULL, 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(void)
 271 {
 272         int ret, stdout_fd = fileno(stdout), out_fd;
 273         struct fd_tracker *tracker;
 274         char *test_directory = NULL, *unlinked_files_directory = NULL;
 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, NULL, 1, noop_open, &stdout_fd);
 282         LTTNG_ASSERT(!ret);
 283         ret = fd_tracker_open_unsuspendable_fd(tracker, &out_fd, NULL, 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, NULL);
 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(void)
 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 = NULL, *unlinked_files_directory = NULL;
 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, NULL, TRACKER_FD_LIMIT, open_pipes, NULL);
 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, NULL, 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(tracker, fds, TRACKER_FD_LIMIT, close_pipes, NULL);
 356         LTTNG_ASSERT(!ret);
 357
 358         fd_tracker_destroy(tracker);
 359         ret = rmdir(test_directory);
 360         ok(ret == 0, "Test directory is empty");
 361         free(test_directory);
 362         free(unlinked_files_directory);
 363 }
 364
 365 /*
 366  * Validate that the tracker refuses to track two identical unsuspendable
 367  * file descriptors.
 368  */
 369 static void test_unsuspendable_close_untracked(void)
 370 {
 371         int ret, stdout_fd = fileno(stdout), unknown_fds[2], out_fd;
 372         struct fd_tracker *tracker;
 373         char *test_directory = NULL, *unlinked_files_directory = NULL;
 374
 375         get_temporary_directories(&test_directory, &unlinked_files_directory);
 376
 377         tracker = fd_tracker_create(unlinked_files_directory, TRACKER_FD_LIMIT);
 378         if (!tracker) {
 379                 goto end;
 380                 ;
 381         }
 382
 383         ret = pipe(unknown_fds);
 384         LTTNG_ASSERT(!ret);
 385         ret = close(unknown_fds[0]);
 386         LTTNG_ASSERT(ret == 0);
 387         ret = close(unknown_fds[1]);
 388         LTTNG_ASSERT(ret == 0);
 389
 390         ret = fd_tracker_open_unsuspendable_fd(tracker, &out_fd, NULL, 1, noop_open, &stdout_fd);
 391         LTTNG_ASSERT(!ret);
 392
 393         ret = fd_tracker_close_unsuspendable_fd(tracker, unknown_fds, 1, noop_close, NULL);
 394         ok(ret == -EINVAL, "EINVAL reported on close of an untracked file descriptor");
 395
 396         ret = fd_tracker_close_unsuspendable_fd(tracker, &stdout_fd, 1, noop_close, NULL);
 397         LTTNG_ASSERT(!ret);
 398
 399         fd_tracker_destroy(tracker);
 400         ret = rmdir(test_directory);
 401         ok(ret == 0, "Test directory is empty");
 402 end:
 403         free(test_directory);
 404         free(unlinked_files_directory);
 405 }
 406
 407 static int open_files(struct fd_tracker *tracker,
 408                       struct lttng_directory_handle *directory,
 409                       unsigned int count,
 410                       struct fs_handle **handles,
 411                       char **file_paths)
 412 {
 413         int ret = 0;
 414         unsigned int i;
 415
 416         for (i = 0; i < count; i++) {
 417                 int p_ret;
 418                 char *file_path;
 419                 struct fs_handle *handle;
 420                 mode_t mode = S_IWUSR | S_IRUSR;
 421
 422                 p_ret = asprintf(&file_path, "file-%u", i);
 423                 LTTNG_ASSERT(p_ret >= 0);
 424                 file_paths[i] = file_path;
 425
 426                 handle = fd_tracker_open_fs_handle(
 427                         tracker, directory, file_path, O_RDWR | O_CREAT, &mode);
 428                 if (!handle) {
 429                         ret = -1;
 430                         break;
 431                 }
 432                 handles[i] = handle;
 433         }
 434         return ret;
 435 }
 436
 437 static int open_same_file(struct fd_tracker *tracker,
 438                           struct lttng_directory_handle *directory,
 439                           const char *file,
 440                           unsigned int count,
 441                           struct fs_handle **handles)
 442 {
 443         int ret = 0;
 444         unsigned int i;
 445
 446         for (i = 0; i < count; i++) {
 447                 struct fs_handle *handle;
 448                 mode_t mode = S_IWUSR | S_IRUSR;
 449
 450                 handle = fd_tracker_open_fs_handle(
 451                         tracker, directory, file, O_RDWR | O_CREAT, &mode);
 452                 if (!handle) {
 453                         ret = -1;
 454                         break;
 455                 }
 456                 handles[i] = handle;
 457         }
 458         return ret;
 459 }
 460
 461 static int cleanup_files(struct fd_tracker *tracker __attribute__((unused)),
 462                          const char *dir __attribute__((unused)),
 463                          unsigned int count,
 464                          struct fs_handle **handles,
 465                          char **file_paths)
 466 {
 467         int ret = 0;
 468         unsigned int i;
 469
 470         for (i = 0; i < count; i++) {
 471                 char *file_path = file_paths[i];
 472
 473                 if (!file_path) {
 474                         break;
 475                 }
 476                 if (fs_handle_unlink(handles[i])) {
 477                         diag("Failed to unlink fs_handle to file %s", file_path);
 478                         ret = -1;
 479                 }
 480                 if (fs_handle_close(handles[i])) {
 481                         diag("Failed to close fs_handle to file %s", file_path);
 482                         ret = -1;
 483                 }
 484                 free(file_path);
 485         }
 486         return ret;
 487 }
 488
 489 static void test_suspendable_limit(void)
 490 {
 491         int ret;
 492         const int files_to_create = TRACKER_FD_LIMIT * 10;
 493         struct fd_tracker *tracker;
 494         char *test_directory = NULL, *unlinked_files_directory = NULL;
 495         char *output_files[files_to_create];
 496         struct fs_handle *handles[files_to_create];
 497         struct lttng_directory_handle *dir_handle = NULL;
 498         int dir_handle_fd_count;
 499
 500         memset(output_files, 0, sizeof(output_files));
 501         memset(handles, 0, sizeof(handles));
 502
 503         get_temporary_directories(&test_directory, &unlinked_files_directory);
 504
 505         tracker = fd_tracker_create(unlinked_files_directory, TRACKER_FD_LIMIT);
 506         if (!tracker) {
 507                 goto end;
 508         }
 509
 510         dir_handle = lttng_directory_handle_create(test_directory);
 511         LTTNG_ASSERT(dir_handle);
 512         dir_handle_fd_count = !!lttng_directory_handle_uses_fd(dir_handle);
 513
 514         ret = open_files(tracker, dir_handle, files_to_create, handles, output_files);
 515         ok(!ret,
 516            "Created %d files with a limit of %d simultaneously-opened file descriptor",
 517            files_to_create,
 518            TRACKER_FD_LIMIT);
 519         check_fd_count(TRACKER_FD_LIMIT + STDIO_FD_COUNT + unknown_fds_count + dir_handle_fd_count);
 520
 521         ret = cleanup_files(tracker, test_directory, files_to_create, handles, output_files);
 522         ok(!ret, "Close all opened filesystem handles");
 523         ret = rmdir(test_directory);
 524         ok(ret == 0, "Test directory is empty");
 525         fd_tracker_destroy(tracker);
 526         lttng_directory_handle_put(dir_handle);
 527 end:
 528         free(test_directory);
 529         free(unlinked_files_directory);
 530 }
 531
 532 static void test_mixed_limit(void)
 533 {
 534         int ret;
 535         const int files_to_create = TRACKER_FD_LIMIT;
 536         struct fd_tracker *tracker;
 537         char *test_directory = NULL, *unlinked_files_directory = NULL;
 538         char *output_files[files_to_create];
 539         struct fs_handle *handles[files_to_create];
 540         struct lttng_directory_handle *dir_handle = NULL;
 541         int dir_handle_fd_count;
 542
 543         memset(output_files, 0, sizeof(output_files));
 544         memset(handles, 0, sizeof(handles));
 545
 546         get_temporary_directories(&test_directory, &unlinked_files_directory);
 547
 548         tracker = fd_tracker_create(unlinked_files_directory, TRACKER_FD_LIMIT);
 549         if (!tracker) {
 550                 goto end;
 551         }
 552
 553         dir_handle = lttng_directory_handle_create(test_directory);
 554         LTTNG_ASSERT(dir_handle);
 555         dir_handle_fd_count = !!lttng_directory_handle_uses_fd(dir_handle);
 556
 557         ret = open_files(tracker, dir_handle, files_to_create, handles, output_files);
 558         ok(!ret,
 559            "Created %d files with a limit of %d simultaneously-opened file descriptor",
 560            files_to_create,
 561            TRACKER_FD_LIMIT);
 562         diag("Check file descriptor count after opening %u files", files_to_create);
 563         check_fd_count(TRACKER_FD_LIMIT + STDIO_FD_COUNT + unknown_fds_count + dir_handle_fd_count);
 564
 565         /*
 566          * Open unsuspendable fds (stdin, stdout, stderr) and verify that the fd
 567          * cap is still respected.
 568          */
 569         diag("Check file descriptor count after adding %d unsuspendable fds", STDIO_FD_COUNT);
 570         track_std_fds(tracker);
 571         check_fd_count(TRACKER_FD_LIMIT + unknown_fds_count + dir_handle_fd_count);
 572         diag("Untrack unsuspendable file descriptors");
 573         untrack_std_fds(tracker);
 574         check_fd_count(TRACKER_FD_LIMIT + unknown_fds_count + dir_handle_fd_count);
 575
 576         ret = cleanup_files(tracker, test_directory, files_to_create, handles, output_files);
 577         ok(!ret, "Close all opened filesystem handles");
 578         ret = rmdir(test_directory);
 579         ok(ret == 0, "Test directory is empty");
 580         fd_tracker_destroy(tracker);
 581         lttng_directory_handle_put(dir_handle);
 582 end:
 583         free(test_directory);
 584         free(unlinked_files_directory);
 585 }
 586
 587 /*
 588  * Open more files than allowed by the fd tracker's cap and write,
 589  * byte-by-byte, and in round-robin, a string. The goal is to force
 590  * the fd tracker to suspend and resume the fs_handles often and
 591  * verify that the fd cap is always respected.
 592  *
 593  * The content of the files is also verified at the end.
 594  */
 595 static void test_suspendable_restore(void)
 596 {
 597         int ret;
 598         const int files_to_create = TRACKER_FD_LIMIT * 10;
 599         struct fd_tracker *tracker;
 600         char *output_files[files_to_create];
 601         struct fs_handle *handles[files_to_create];
 602         size_t content_index;
 603         int handle_index;
 604         bool write_success = true;
 605         bool fd_cap_respected = true;
 606         bool content_ok = true;
 607         struct lttng_directory_handle *dir_handle = NULL;
 608         int dir_handle_fd_count;
 609         char *test_directory = NULL, *unlinked_files_directory = NULL;
 610
 611         memset(output_files, 0, sizeof(output_files));
 612         memset(handles, 0, sizeof(handles));
 613
 614         get_temporary_directories(&test_directory, &unlinked_files_directory);
 615
 616         tracker = fd_tracker_create(unlinked_files_directory, TRACKER_FD_LIMIT);
 617         if (!tracker) {
 618                 goto end;
 619         }
 620
 621         dir_handle = lttng_directory_handle_create(test_directory);
 622         LTTNG_ASSERT(dir_handle);
 623         dir_handle_fd_count = !!lttng_directory_handle_uses_fd(dir_handle);
 624
 625         ret = open_files(tracker, dir_handle, files_to_create, handles, output_files);
 626         ok(!ret,
 627            "Created %d files with a limit of %d simultaneously-opened file descriptor",
 628            files_to_create,
 629            TRACKER_FD_LIMIT);
 630         diag("Check file descriptor count after opening %u files", files_to_create);
 631         check_fd_count(TRACKER_FD_LIMIT + STDIO_FD_COUNT + unknown_fds_count + dir_handle_fd_count);
 632
 633         for (content_index = 0; content_index < sizeof(file_contents); content_index++) {
 634                 for (handle_index = 0; handle_index < files_to_create; handle_index++) {
 635                         int fd;
 636                         struct fs_handle *handle = handles[handle_index];
 637                         const char *path = output_files[handle_index];
 638
 639                         fd = fs_handle_get_fd(handle);
 640                         if (fd < 0) {
 641                                 write_success = false;
 642                                 diag("Failed to restore fs_handle to %s", path);
 643                                 goto skip_write;
 644                         }
 645
 646                         do {
 647                                 ret = write(fd, file_contents + content_index, 1);
 648                         } while (ret < 0 && errno == EINTR);
 649
 650                         if (ret != 1) {
 651                                 write_success = false;
 652                                 PERROR("write() to %s failed", path);
 653                                 goto skip_write;
 654                         }
 655
 656                         if (fd_count() > (TRACKER_FD_LIMIT + STDIO_FD_COUNT + unknown_fds_count +
 657                                           dir_handle_fd_count)) {
 658                                 fd_cap_respected = false;
 659                         }
 660
 661                         fs_handle_put_fd(handle);
 662                 }
 663         }
 664 skip_write:
 665         ok(write_success, "Wrote reference string to %d files", files_to_create);
 666         ok(fd_cap_respected, "FD tracker enforced the file descriptor cap");
 667
 668         /* Validate the contents of the files. */
 669         for (handle_index = 0; handle_index < files_to_create; handle_index++) {
 670                 struct stat fd_stat;
 671                 const char *path = output_files[handle_index];
 672                 char read_buf[sizeof(file_contents)];
 673                 char *read_pos;
 674                 size_t to_read = sizeof(read_buf);
 675                 int fd;
 676
 677                 fd = lttng_directory_handle_open_file(dir_handle, path, O_RDONLY, 0);
 678                 LTTNG_ASSERT(fd >= 0);
 679                 ret = fstat(fd, &fd_stat);
 680                 LTTNG_ASSERT(!ret);
 681                 if (fd_stat.st_size != sizeof(file_contents)) {
 682                         diag("Content size of file %s doesn't match, got %" PRId64 ", expected %zu",
 683                              path,
 684                              (int64_t) fd_stat.st_size,
 685                              sizeof(file_contents));
 686                         content_ok = false;
 687                         (void) close(fd);
 688                         break;
 689                 }
 690
 691                 read_pos = read_buf;
 692                 do {
 693                         ret = read(fd, read_pos, to_read);
 694                         if (ret > 0) {
 695                                 to_read -= ret;
 696                                 read_pos += ret;
 697                         }
 698                 } while (to_read && (ret < 0 && errno == EINTR));
 699                 if (ret < 0) {
 700                         content_ok = false;
 701                         PERROR("Failed to read file %s", path);
 702                         (void) close(fd);
 703                         break;
 704                 }
 705
 706                 if (strcmp(file_contents, read_buf)) {
 707                         content_ok = false;
 708                         diag("File content doesn't match the expectated string");
 709                         (void) close(fd);
 710                         break;
 711                 }
 712                 (void) close(fd);
 713         }
 714         ok(content_ok, "Files contain the expected content");
 715         ret = cleanup_files(tracker, test_directory, files_to_create, handles, output_files);
 716         ok(!ret, "Close all opened filesystem handles");
 717         ret = rmdir(test_directory);
 718         ok(ret == 0, "Test directory is empty");
 719         fd_tracker_destroy(tracker);
 720         lttng_directory_handle_put(dir_handle);
 721 end:
 722         free(test_directory);
 723         free(unlinked_files_directory);
 724 }
 725
 726 static void test_unlink(void)
 727 {
 728         int ret;
 729         struct fd_tracker *tracker;
 730         const int handles_to_open = 2;
 731         struct fs_handle *handles[handles_to_open];
 732         struct fs_handle *new_handle = NULL;
 733         struct stat statbuf;
 734         struct lttng_directory_handle *dir_handle = NULL;
 735         const char file_name[] = "my_file";
 736         char *test_directory = NULL, *unlinked_files_directory = NULL;
 737         char *unlinked_file_zero = NULL, *unlinked_file_one = NULL;
 738         int fd;
 739
 740         get_temporary_directories(&test_directory, &unlinked_files_directory);
 741         ret = asprintf(&unlinked_file_zero, "%s/%u", unlinked_files_directory, 0);
 742         LTTNG_ASSERT(ret > 0);
 743         ret = asprintf(&unlinked_file_one, "%s/%u", unlinked_files_directory, 1);
 744         LTTNG_ASSERT(ret > 0);
 745
 746         tracker = fd_tracker_create(unlinked_files_directory, 1);
 747         if (!tracker) {
 748                 goto end;
 749         }
 750
 751         dir_handle = lttng_directory_handle_create(test_directory);
 752         LTTNG_ASSERT(dir_handle);
 753
 754         /* Open two handles to the same file. */
 755         ret = open_same_file(tracker, dir_handle, file_name, handles_to_open, handles);
 756         ok(!ret,
 757            "Successfully opened %i handles to %s/%s",
 758            handles_to_open,
 759            test_directory,
 760            file_name);
 761         if (ret) {
 762                 goto end;
 763         }
 764
 765         /*
 766          * Unlinking the first handle should cause the file to be renamed
 767          * to '0'.
 768          */
 769         ret = fs_handle_unlink(handles[0]);
 770         ok(!ret, "Successfully unlinked the first handle to %s/%s", test_directory, file_name);
 771
 772         /*
 773          * The original file should no longer exist on the file system, and a
 774          * new file named '0' should exist.
 775          */
 776         ok(lttng_directory_handle_stat(dir_handle, file_name, &statbuf) == -1 && errno == ENOENT,
 777            "%s no longer present on file system after unlink",
 778            file_name);
 779         ok(lttng_directory_handle_stat(dir_handle, unlinked_file_zero, &statbuf) == 0,
 780            "%s exists on file system after unlink",
 781            unlinked_file_zero);
 782
 783         /*
 784          * It should be possible to use the file descriptors of both handles.
 785          * Since only one file descriptor can be opened at once, this should
 786          * force the fd_tracker to suspend and restore the handles.
 787          */
 788         fd = fs_handle_get_fd(handles[0]);
 789         ok(fd >= 0, "Got fd from first handle");
 790
 791         fd = fs_handle_get_fd(handles[1]);
 792         ok(fd < 0, "fd tracker does not allow two fds to be used at once");
 793
 794         fs_handle_put_fd(handles[0]);
 795         fd = fs_handle_get_fd(handles[1]);
 796         ok(fd >= 0, "Got fd from second handle");
 797         fs_handle_put_fd(handles[1]);
 798
 799         /* The second unlink should fail with -ENOENT. */
 800         ret = fs_handle_unlink(handles[1]);
 801         ok(ret == -ENOENT,
 802            "ENOENT is reported when attempting to unlink the second handle to %s/%s",
 803            test_directory,
 804            file_name);
 805
 806         /*
 807          * Opening a new handle to 'my_file' should succeed.
 808          */
 809         ret = open_same_file(tracker, dir_handle, file_name, 1, &new_handle);
 810         ok(!ret,
 811            "Successfully opened a new handle to previously unlinked file %s/%s",
 812            test_directory,
 813            file_name);
 814         LTTNG_ASSERT(new_handle);
 815
 816         /*
 817          * Unlinking the new handle should cause the file to be renamed
 818          * to '1' since '0' already exists.
 819          */
 820         ret = fs_handle_unlink(new_handle);
 821         ok(!ret, "Successfully unlinked the new handle handle to %s/%s", test_directory, file_name);
 822         ok(stat(unlinked_file_one, &statbuf) == 0,
 823            "%s exists on file system after unlink",
 824            unlinked_file_one);
 825
 826         ret = fs_handle_close(handles[0]);
 827         ok(!ret, "Successfully closed the first handle");
 828         ret = fs_handle_close(handles[1]);
 829         ok(!ret, "Successfully closed the second handle");
 830         ret = fs_handle_close(new_handle);
 831         ok(!ret, "Successfully closed the third handle");
 832
 833         ok(lttng_directory_handle_stat(dir_handle, file_name, &statbuf) == -1 && errno == ENOENT,
 834            "%s no longer present on file system after handle close",
 835            file_name);
 836         ok(lttng_directory_handle_stat(dir_handle, unlinked_file_zero, &statbuf) == -1 &&
 837                    errno == ENOENT,
 838            "%s no longer present on file system after handle close",
 839            unlinked_file_zero);
 840         ok(lttng_directory_handle_stat(dir_handle, unlinked_file_one, &statbuf) == -1 &&
 841                    errno == ENOENT,
 842            "%s no longer present on file system after handle close",
 843            unlinked_file_one);
 844
 845         ret = rmdir(test_directory);
 846         ok(ret == 0, "Test directory is empty");
 847 end:
 848         fd_tracker_destroy(tracker);
 849         free(test_directory);
 850         free(unlinked_files_directory);
 851         free(unlinked_file_zero);
 852         free(unlinked_file_one);
 853         lttng_directory_handle_put(dir_handle);
 854 }
 855
 856 int main(void)
 857 {
 858         plan_tests(NUM_TESTS);
 859         diag("File descriptor tracker unit tests");
 860
 861         rcu_register_thread();
 862
 863         unknown_fds_count = fd_count() - STDIO_FD_COUNT;
 864         LTTNG_ASSERT(unknown_fds_count >= 0);
 865
 866         diag("Unsuspendable - basic");
 867         test_unsuspendable_basic();
 868         diag("Unsuspendable - callback return values");
 869         test_unsuspendable_cb_return();
 870         diag("Unsuspendable - duplicate file descriptors");
 871         test_unsuspendable_duplicate();
 872         diag("Unsuspendable - closing an untracked file descriptor");
 873         test_unsuspendable_close_untracked();
 874         diag("Unsuspendable - check that file descriptor limit is enforced");
 875         test_unsuspendable_limit();
 876
 877         diag("Suspendable - check that file descriptor limit is enforced");
 878         test_suspendable_limit();
 879         diag("Suspendable - restoration test");
 880         test_suspendable_restore();
 881
 882         diag("Mixed - check that file descriptor limit is enforced");
 883         test_mixed_limit();
 884
 885         diag("Suspendable - Unlinking test");
 886         test_unlink();
 887
 888         rcu_barrier();
 889         rcu_unregister_thread();
 890         return exit_status();
 891 }