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.hpp>
  25 #include <common/compat/errno.hpp>
  26 #include <common/error.hpp>
  27 #include <common/fs-handle.hpp>
  28 #include <common/fd-tracker/fd-tracker.hpp>
  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 }